DRL Wiki - User contributions [en]

Strategy:The Wall

2012-06-19T21:03:54Z

Game Hunter: tag fix

__NOTOC__
{{infostrat switch}}
== Main Guide (v0.9.9.4) ==

=== Version Changes (v0.9.9.5) ===

Nothing significant to the weapon itself.

=== Version Changes (v0.9.9.6) ===

Monster AI is a bit different, making the level harder.

=== General Tactics ===
Base strategy posted by [[User:GinDiamond|GinDiamond]] 15:00, June 19 2012 (EST).

The Wall can be very challenging if one does not understand the basic mechanics of monster movement, and the fact that walls can be destroyed with fire or plasma damage.

To start the Wall, situate yourself about 7 tiles away from either of the far left corners of the Wall:

<pre>
#############################
...########7.................
...########.65...............
...########...4..............
...########....3.............
...########.....2@...........
</pre>

Then, you have to use your rockets to blow a hole in the Wall (aprx. 8 rockets). Try to keep the number of "pockets" low, so enemies can't hide out in them. Better yet, use the splash from rocket explosions to make yourself a little 2-tile nook to duck behind when things get rough. Try to make a 3-tile wide hole that is even with the nook on your side:

<pre>
#############################
.............................
.............................
.............................
...######@...................
...########..................
...########..................
...########..................
</pre>

From here, use a shotgun (combat, tactical, double) to blow an enemy back if it comes too close. When an enemy is about 3 tiles from you (use the wait key), shoot them with a shotgun (or a rapid-fire weapon if you have the right traits):

<pre>
#############################
.............................
.............................
......BXX....................
...######@...................
...########..................
...########..................
...########..................
</pre>
NOTE: Double shotguns, used this way, will easily take down a hell knight in three bangs.

This way, the enemy will be blown backward, and you'll hit any other close-by enemies. However, if the enemy is right up next to you like this:

<pre>
#############################
.............................
.............................
........B....................
...######@...................
...########..................
...########..................
...########..................
</pre>

then you're screwed, because if you use a shotgun, it will blow them backward diagonally and then when they retaliate, the splash will destroy your nook. Use a rapid-fire weapon or a strong melee weapon.

If using rapid-fire, try to wait for an enemy to get in this position (you'll have to creep up out of your nook:)

<pre>
#############################
.............................
.............................
.........@...................
..B######....................
B..########..................
...########..................
...########..................
</pre>

That way, you can use your rapid-fire weapon to pick them off without fear of enemy fire.
When the enemy creeps up to your level, duck behind your nook, reload, and then corner-shoot like this:

<pre>
#############################
.............................
.............................
...BXXXXX....................
..B######@...................
...########..................
...########..................
...########..................
</pre>

Once all of the enemies are dead (16, I think), you can reap the rewards on the far side behind the Wall.

Strategy:Contest pages

2012-05-29T21:03:05Z

Game Hunter: fixed link

This page contains all Strategy-based pages included in the strategy contest (found [http://forum.chaosforge.org/index.php/topic,4867.0.html here] on the Chaosforge forums), as well as any winners for them. It also contains information regarding the contest.

==Contest Rules==
Entries will be graded on the merit of the information given, rather than its sheer volume. While it is true that a large and informative entry will likely be marked higher than a small and informative entry (simply because it contains more amounts of useful information), '''the key factors that attribute to a successful entry are''':
*Detail - either in having many possible strategies, or explaining the various considerations of a given strategy
*Originality - creativity, regarding both the strategy itself and how it is presented
*Accuracy - up-to-date for the current public version, and valid as a strategy itself
*Comprehension - one with basic knowledge of game [[mechanics]] (and, if necessary, an accompanying Game Data page) should understand the strategy
*Focus - keep to the scope of the topic at hand

'''All entries should be emailed to [http://mailto:theuberhunter@gmail.com theuberhunter@gmail.com]''' using the following format:
*The subject line should read "[WIKICOMP#X] Strategy:" (minus quotes, where X is the competition number), followed by the topic
**example: [WIKICOMP#1] Strategy:Rocket launcher
*The entry itself can either be written in the body of the email, separate from the rest of the email's content, or as a document file attached to the email. For procedures on formatting, refer to the formatting guidelines just after the rules.
*Include a username somewhere in the email. Your forum name is recommended (and necessary, if you want to get your prize) but any name will do. If no username is given, it will default to the email address of the submission.

After submitting the email, a reply should be added to the forum topic, stating that (in so many words) you have entered a submission for the current contest. If there is more than one topic for the current contest, also name the topic (or topics) for which you wrote an entry (or entries). While this is not required to enter, it is necessary as validation so that the prize is handed out to the appropriate member. Alternatively, you are allowed to submit your entry through the forum topic, though this carries the risk of letting other contestants view your entry before the deadline has been reached.

Prizes will be determined on a per-topic basis. Some topics will be worth more (in terms of their prize) than others. '''The contest judge ([[User:Game Hunter|Game Hunter]]) reserves the right not to award a prize for a given topic in a given contest if none of the entries are of sufficient quality to be worthy of the prize given.'''

A player can submit an entry for each topic during a contest, and can potentially receive the prize for each one. '''Multiple entries should be submitted separately: one email per topic.'''

Each contest will accept entries for about one week: '''the deadline will always be Midnight GMT of that day''' ([http://wwp.greenwichmeantime.com see here for the current GMT time]). After the deadline is reached, there will be, at most, a one-week period during which submissions will be examined and a winner for each topic will be determined. After the grading period, prizes will be handed out to winners.

Regardless of the winner, all entries will have their strategies added to the Wiki. These will initially be posted immediately after the contest ends, ordered by date. After all entries are graded and a winner is chosen, the winner's strategy entry will be placed at the top of the page (with the others left unmoved). This entry will then be used as the basis on which to add other components of strategy: the other entries will eventually be merged into this entry (and will be handled by Game_Hunter).

==Formatting Guidelines==
Entries are expected to be written in a format appropriate for Wiki reading. A good starting place for this is to use a very basic text program such as Notepad. You can also try to write your entry on the Wiki itself, using "Show Preview" to check for errors, then copy-paste it as your entry.

Basic etiquette is as follows:
*Do not use typical indentations under any circumstance. Indentations using the TAB key have no effect on the display here, and indentations created with spaces are meant for a different task. If you really want indentation, add a colon (:) where the indent would go.
*Do not use any program-specific stylizations. Wikipedia standards have [http://meta.wikimedia.org/wiki/Help:Editing their own procedures] for the styles you may want. You are free to use these in your entry if you believe they will improve the organization of what you are writing. (Here are [http://meta.wikimedia.org/wiki/Help:Wikitext_examples additional examples] if you need a full range of possibilities.)
**The exception of this format is that you should not use section-based formatting (for example, <nowiki>==Title==</nowiki>) as this is reserved for possible segmentation of the strategy page itself.
*Paragraphs should be of an appropriate length. If a paragraph is too short, attempt to merge it with another paragraph containing similar ideas. If a paragraph is too long, either split it into separate paragraphs or use a bullet-point format. This is often expected not just on Wikis but on any Internet forum as well.
*Remove any word-wrapping before submitting an entry. Otherwise the transfer to the Wiki will require a few thousand backspaces, because the copy-paste was messed up due to the way that word-wrapping handles spaces.

==Current Contest==
===Status===
Entry period: submissions will be accepted no later than June 10, 2012 at Midnight (GMT).

===Topics===
#[[Strategy:Hell's Arena|Hell's Arena]] (prize: USD25)
#[[Strategy:The Chained Court|The Chained Court]] (prize: USD25)

==Past Contests==
===November 9-16, 2011===
#[[Strategy:Rocket launcher|Rocket launcher]] (winner: [[User:GrimmC|GrimmC]])
#[[Strategy:Intuition|Intuition]] (winner: [[User:theduck101|theduck101]])
#[[Strategy:Demon|Demon]] (winner: [[User:Elephant|Elephant]])

===November 18-27, 2011===
#[[Strategy:Combat shotgun|Combat shotgun]] (winner: [[User:GrimmC|GrimmC]])
#[[Strategy:Shottyman|Shottyman]] (winner: [[User:theduck101|theduck101]])

===January 8-16, 2012===
#[[Strategy:Double shotgun|Double shotgun]] (winner: [[User:Kashi|Kashi]])
#[[Strategy:Reloader|Reloader]] (winner: [[User:AlterAsc|AlterAsc]])
#[[Strategy:Pain elemental|Pain elemental]] (winner: [[User:Tormuse|Tormuse]])

===January 20 - February 3, 2012===
#[[Strategy:Arachnotron|Arachnotron]] (winner: [[User:IronBeer|IronBeer]])
#[[Strategy:BFG 9000|BFG 9000]] (winner: [[User:ZicherCZ|ZicherCZ]])
#[[Strategy:Juggler|Juggler]] (winner: [[User:shark20061|shark20061]])
#[[Strategy:Former commando|Former commando]] (winner: [[User:ZicherCZ|ZicherCZ]])

Strategy:Juggler

2012-05-26T22:50:52Z

Game Hunter: reorganized

{{infostrat switch}}
__NOTOC__
== Main Guide (v0.9.9.5) ==

=== Version Changes (v.0.9.9.6) ===
Nothing significant to the trait itself.

=== General Tactics ===
Basic strategy written by [[User:shark20061|shark20061]] 20:32, February 2 2012 (GMT).

If you're like me and like to carry several different weapons at once, Juggler can really come in handy. Juggler has 2 main parts, each with their own benefits.

First, Juggler lets you use swap your current weapon with your prepared one instantly. Normally, this would take 8/10 a second of time, which means that you can switch from your long range plasma rifle to your close range double shotgun if a monster suddenly appears next to you, without letting it get a free hit. Very useful against [[lost soul|lost souls]], as they almost always get free turns since they are so fast. This also means that swapping weapons this way (or by quickkey) no longer counts as a turn, which can save precious time when going for Icarus Cross [[medals]] or when under the effects of [[Effects#Berserk|berserk]], [[Effects#Invulnerable|invulnerability]], [[envirosuit pack|envirosuit packs]], or [[Light-Amp Goggles]], which have durations in turns (if it takes less than 0.1 seconds to do, it doesn't use up a turn).
*The ability to switch weapons instantly might seem minor at first glance, but it can be a lifesaver, or at least an ammo saver, in any game. Depending on the situation, you may want to use a shotgun to knock something back or spray a group of small enemies, or you might want to use a plasma gun to get something big dead fast, (such as an [[arch-vile]]) or you might want to use a [[chaingun]] for some precision shooting that isn't serious enough to warrant use of plasma (such as a [[Demon]] next to a barrel that you don't want to blow up since it might destroy useful items) or a [[rocket launcher]] to disperse large groups of enemies. Being able to switch rapidly and repeatedly in the middle of a battle can be essential in order to have the right weapon out at the right second, especially if you empty a weapon and it would be too dangerous to take the time to reload. [[User:Tormuse|Tormuse]] 10:26, February 6 2012 (GMT)
*An additional benefit introduced in version 0.9.9.5 is the fact that, if you have multiple of one kind of weapon in your main inventory, using the number keys to select your basic weapons now selects the one with the most ammo. (In previous versions, it would select the one with the *least* ammo which would mean you would frequently pull out empty weapons which was as useless as it was frustrating) This means you can now, for example, have multiple Chainguns in your inventory and if you empty one, instead of taking 2.5 seconds to reload, you can instantaneously switch to the next one and keep firing without a break! In order to take advantage of this strategy, there are a couple of things to remember: Using my above example with the Chainguns, after emptying one of them, you would have to first pull out a different weapon, say a shotgun by pressing 3, before pressing 6 to pull out the full Chaingun. This is because pressing 6 while you're wielding the Chaingun produces the message "you already have the chaingun in your hands" and nothing happens. The additional step of pulling out the shotgun is also instantaneous, though, so it doesn't really impact gameplay. The other thing to remember is that if the empty Chaingun is in the prepared slot, the game will default to swapping rather than switching to the full one in the main inventory. You will have to do a bit of juggling to get the empty one out of the prepared slot before you can take advantage of the ability to instantly switch to the full one. [[User:Tormuse|Tormuse]] 10:26, February 6 2012 (GMT)

The second part of Juggler allows you switch between the common weapons in your inventory instantly. This means that you don't have to have your second weapon in your prepared slot if it's any of the standard [[Weapons#Melee Weapons|melee]] or [[Weapons#Ranged Weapons|ranged]] weapons. This means that you can have a ammo box in the prepared slot and still take advantage of the Juggler bonus by using the quick keys. One very useful thing this does is that it allows you to get the common weapon upgrades -- combat knife to chainsaw, shotgun to combat shotgun and/or double shotgun, chaingun to plasma rifle, and anything to BFG9000 (on bosses) ready faster. If you have Juggler before getting to [[The Chained Court]], you can pick the chainsaw up, swap it to the prepared slot, then quickkey swap another weapon in your main weapon slot. You just picked up the chainsaw and readied it and another weapon all in 1 second and still have it ready to tear monsters apart at any time.
What's really awesome is that Juggler will work with [[assemblies]]. [[Chainsword]], [[high power weapon]], and other assembled items can be swapped by using the quickkey for the base item.

With Juggler, you can equip and use several different weapons in a row without worrying about reloading in the middle of combat or spending time switching weapons. It works well against pain elementals and the swarms of lost souls they can produce. Start with a room clearing weapon -- the double shotgun (or any shotgun really, but the double shotgun's wide spread make it work well). Fire it, then switch to a rapid fire weapon (like the chaingun, or, better, the plasma rifle). A prepared melee weapon can be used to take care of any lost souls that actually reach you.

As a convienence factor, the juggler skill lets you attack with a melee weapon if you have it in the prepared slot (so you don't have to keep switching back and forth manually), although manual switching will still be required if you plan on having an non-melee exotic or unique on deck in the prepared slot for instant switching.
*The fact that Juggler automatically uses a melee weapon in the prepared slot doesn't usually have an advantage unless you happen to have a unique melee weapon, since you can instantly switch to combat knives and chainsaws anyway. It does have a use in helping achieve medals and badges that require fists only, though, since, for example, if you have a Chainsaw in the prepared slot while your hands are empty and you have Juggler trait, you will do Chainsaw damage to your enemies, but the game will consider them fist kills. This makes fist-only challenges a lot easier! [[User:Tormuse|Tormuse]] 10:26, February 6 2012 (GMT)

There are a few points that make Juggler flexible and a viable option on most builds. The first is that it's available as early as level 2 no matter what class you pick, since it only requires 1 point in [[Finesse]]. The second is that only two master traits block Finesse, and therefore block Juggler: [[Army of the Dead]] and [[Entrenchment]]. Therefore, juggler is a nice complement that allows you to access most of the tools you need when you need them, without letting the monsters get a turn.

Strategy:Contest pages

2012-05-26T22:34:00Z

Game Hunter: new contest, oh boy

This page contains all Strategy-based pages included in the strategy contest (found [http://forum.chaosforge.org/index.php/topic,4867.0.html here] on the Chaosforge forums), as well as any winners for them. It also contains information regarding the contest.

==Contest Rules==
Entries will be graded on the merit of the information given, rather than its sheer volume. While it is true that a large and informative entry will likely be marked higher than a small and informative entry (simply because it contains more amounts of useful information), '''the key factors that attribute to a successful entry are''':
*Detail - either in having many possible strategies, or explaining the various considerations of a given strategy
*Originality - creativity, regarding both the strategy itself and how it is presented
*Accuracy - up-to-date for the current public version, and valid as a strategy itself
*Comprehension - one with basic knowledge of game [[mechanics]] (and, if necessary, an accompanying Game Data page) should understand the strategy
*Focus - keep to the scope of the topic at hand

'''All entries should be emailed to [http://mailto:theuberhunter@gmail.com theuberhunter@gmail.com]''' using the following format:
*The subject line should read "[WIKICOMP#X] Strategy:" (minus quotes, where X is the competition number), followed by the topic
**example: [WIKICOMP#1] Strategy:Rocket launcher
*The entry itself can either be written in the body of the email, separate from the rest of the email's content, or as a document file attached to the email. For procedures on formatting, refer to the formatting guidelines just after the rules.
*Include a username somewhere in the email. Your forum name is recommended (and necessary, if you want to get your prize) but any name will do. If no username is given, it will default to the email address of the submission.

After submitting the email, a reply should be added to the forum topic, stating that (in so many words) you have entered a submission for the current contest. If there is more than one topic for the current contest, also name the topic (or topics) for which you wrote an entry (or entries). While this is not required to enter, it is necessary as validation so that the prize is handed out to the appropriate member. Alternatively, you are allowed to submit your entry through the forum topic, though this carries the risk of letting other contestants view your entry before the deadline has been reached.

Prizes will be determined on a per-topic basis. Some topics will be worth more (in terms of their prize) than others. '''The contest judge ([[Game Hunter]]) reserves the right not to award a prize for a given topic in a given contest if none of the entries are of sufficient quality to be worthy of the prize given.'''

A player can submit an entry for each topic during a contest, and can potentially receive the prize for each one. '''Multiple entries should be submitted separately: one email per topic.'''

Each contest will accept entries for about one week: '''the deadline will always be Midnight GMT of that day''' ([http://wwp.greenwichmeantime.com see here for the current GMT time]). After the deadline is reached, there will be, at most, a one-week period during which submissions will be examined and a winner for each topic will be determined. After the grading period, prizes will be handed out to winners.

Regardless of the winner, all entries will have their strategies added to the Wiki. These will initially be posted immediately after the contest ends, ordered by date. After all entries are graded and a winner is chosen, the winner's strategy entry will be placed at the top of the page (with the others left unmoved). This entry will then be used as the basis on which to add other components of strategy: the other entries will eventually be merged into this entry (and will be handled by Game_Hunter).

==Formatting Guidelines==
Entries are expected to be written in a format appropriate for Wiki reading. A good starting place for this is to use a very basic text program such as Notepad. You can also try to write your entry on the Wiki itself, using "Show Preview" to check for errors, then copy-paste it as your entry.

Basic etiquette is as follows:
*Do not use typical indentations under any circumstance. Indentations using the TAB key have no effect on the display here, and indentations created with spaces are meant for a different task. If you really want indentation, add a colon (:) where the indent would go.
*Do not use any program-specific stylizations. Wikipedia standards have [http://meta.wikimedia.org/wiki/Help:Editing their own procedures] for the styles you may want. You are free to use these in your entry if you believe they will improve the organization of what you are writing. (Here are [http://meta.wikimedia.org/wiki/Help:Wikitext_examples additional examples] if you need a full range of possibilities.)
**The exception of this format is that you should not use section-based formatting (for example, <nowiki>==Title==</nowiki>) as this is reserved for possible segmentation of the strategy page itself.
*Paragraphs should be of an appropriate length. If a paragraph is too short, attempt to merge it with another paragraph containing similar ideas. If a paragraph is too long, either split it into separate paragraphs or use a bullet-point format. This is often expected not just on Wikis but on any Internet forum as well.
*Remove any word-wrapping before submitting an entry. Otherwise the transfer to the Wiki will require a few thousand backspaces, because the copy-paste was messed up due to the way that word-wrapping handles spaces.

==Current Contest==
===Status===
Entry period: submissions will be accepted no later than June 10, 2012 at Midnight (GMT).

===Topics===
#[[Strategy:Hell's Arena|Hell's Arena]] (prize: USD25)
#[[Strategy:The Chained Court|The Chained Court]] (prize: USD25)

==Past Contests==
===November 9-16, 2011===
#[[Strategy:Rocket launcher|Rocket launcher]] (winner: [[User:GrimmC|GrimmC]])
#[[Strategy:Intuition|Intuition]] (winner: [[User:theduck101|theduck101]])
#[[Strategy:Demon|Demon]] (winner: [[User:Elephant|Elephant]])

===November 18-27, 2011===
#[[Strategy:Combat shotgun|Combat shotgun]] (winner: [[User:GrimmC|GrimmC]])
#[[Strategy:Shottyman|Shottyman]] (winner: [[User:theduck101|theduck101]])

===January 8-16, 2012===
#[[Strategy:Double shotgun|Double shotgun]] (winner: [[User:Kashi|Kashi]])
#[[Strategy:Reloader|Reloader]] (winner: [[User:AlterAsc|AlterAsc]])
#[[Strategy:Pain elemental|Pain elemental]] (winner: [[User:Tormuse|Tormuse]])

===January 20 - February 3, 2012===
#[[Strategy:Arachnotron|Arachnotron]] (winner: [[User:IronBeer|IronBeer]])
#[[Strategy:BFG 9000|BFG 9000]] (winner: [[User:ZicherCZ|ZicherCZ]])
#[[Strategy:Juggler|Juggler]] (winner: [[User:shark20061|shark20061]])
#[[Strategy:Former commando|Former commando]] (winner: [[User:ZicherCZ|ZicherCZ]])

Strategy:Contest pages

2012-05-26T22:31:12Z

Game Hunter:

This page contains all Strategy-based pages included in the strategy contest (found [http://forum.chaosforge.org/index.php/topic,4867.0.html here] on the Chaosforge forums), as well as any winners for them. It also contains information regarding the contest.

==Contest Rules==
Entries will be graded on the merit of the information given, rather than its sheer volume. While it is true that a large and informative entry will likely be marked higher than a small and informative entry (simply because it contains more amounts of useful information), '''the key factors that attribute to a successful entry are''':
*Detail - either in having many possible strategies, or explaining the various considerations of a given strategy
*Originality - creativity, regarding both the strategy itself and how it is presented
*Accuracy - up-to-date for the current public version, and valid as a strategy itself
*Comprehension - one with basic knowledge of game [[mechanics]] (and, if necessary, an accompanying Game Data page) should understand the strategy
*Focus - keep to the scope of the topic at hand

'''All entries should be emailed to [http://mailto:theuberhunter@gmail.com theuberhunter@gmail.com]''' using the following format:
*The subject line should read "[WIKICOMP#X] Strategy:" (minus quotes, where X is the competition number), followed by the topic
**example: [WIKICOMP#1] Strategy:Rocket launcher
*The entry itself can either be written in the body of the email, separate from the rest of the email's content, or as a document file attached to the email. For procedures on formatting, refer to the formatting guidelines just after the rules.
*Include a username somewhere in the email. Your forum name is recommended (and necessary, if you want to get your prize) but any name will do. If no username is given, it will default to the email address of the submission.

After submitting the email, a reply should be added to the forum topic, stating that (in so many words) you have entered a submission for the current contest. If there is more than one topic for the current contest, also name the topic (or topics) for which you wrote an entry (or entries). While this is not required to enter, it is necessary as validation so that the prize is handed out to the appropriate member. Alternatively, you are allowed to submit your entry through the forum topic, though this carries the risk of letting other contestants view your entry before the deadline has been reached.

Prizes will be determined on a per-topic basis. Some topics will be worth more (in terms of their prize) than others. '''The contest judge ([[Game Hunter]]) reserves the right not to award a prize for a given topic in a given contest if none of the entries are of sufficient quality to be worthy of the prize given.'''

A player can submit an entry for each topic during a contest, and can potentially receive the prize for each one. '''Multiple entries should be submitted separately: one email per topic.'''

Each contest will accept entries for about one week: '''the deadline will always be Midnight GMT of that day''' ([http://wwp.greenwichmeantime.com see here for the current GMT time]). After the deadline is reached, there will be, at most, a one-week period during which submissions will be examined and a winner for each topic will be determined. After the grading period, prizes will be handed out to winners.

Regardless of the winner, all entries will have their strategies added to the Wiki. These will initially be posted immediately after the contest ends, ordered by date. After all entries are graded and a winner is chosen, the winner's strategy entry will be placed at the top of the page (with the others left unmoved). This entry will then be used as the basis on which to add other components of strategy: the other entries will eventually be merged into this entry (and will be handled by Game_Hunter).

==Formatting Guidelines==
Entries are expected to be written in a format appropriate for Wiki reading. A good starting place for this is to use a very basic text program such as Notepad. You can also try to write your entry on the Wiki itself, using "Show Preview" to check for errors, then copy-paste it as your entry.

Basic etiquette is as follows:
*Do not use typical indentations under any circumstance. Indentations using the TAB key have no effect on the display here, and indentations created with spaces are meant for a different task. If you really want indentation, add a colon (:) where the indent would go.
*Do not use any program-specific stylizations. Wikipedia standards have [http://meta.wikimedia.org/wiki/Help:Editing their own procedures] for the styles you may want. You are free to use these in your entry if you believe they will improve the organization of what you are writing. (Here are [http://meta.wikimedia.org/wiki/Help:Wikitext_examples additional examples] if you need a full range of possibilities.)
**The exception of this format is that you should not use section-based formatting (for example, <nowiki>==Title==</nowiki>) as this is reserved for possible segmentation of the strategy page itself.
*Paragraphs should be of an appropriate length. If a paragraph is too short, attempt to merge it with another paragraph containing similar ideas. If a paragraph is too long, either split it into separate paragraphs or use a bullet-point format. This is often expected not just on Wikis but on any Internet forum as well.
*Remove any word-wrapping before submitting an entry. Otherwise the transfer to the Wiki will require a few thousand backspaces, because the copy-paste was messed up due to the way that word-wrapping handles spaces.

==Current Contest==
===Status===
Entry period: submissions will be accepted no later than February 4, 2012 at Midnight (GMT).

===Topics===
#[[Strategy:Arachnotron|Arachnotron]] (prize USD10)
#[[Strategy:BFG 9000|BFG 9000]] (prize USD10)
#[[Strategy:Juggler|Juggler]] (prize USD10)
#[[Strategy:Former commando|Former commando]] (prize USD10)

==Past Contests==
===November 9-16, 2011===
#[[Strategy:Rocket launcher|Rocket launcher]] (winner: [[User:GrimmC|GrimmC]])
#[[Strategy:Intuition|Intuition]] (winner: [[User:theduck101|theduck101]])
#[[Strategy:Demon|Demon]] (winner: [[User:Elephant|Elephant]])

===November 18-27, 2011===
#[[Strategy:Combat shotgun|Combat shotgun]] (winner: [[User:GrimmC|GrimmC]])
#[[Strategy:Shottyman|Shottyman]] (winner: [[User:theduck101|theduck101]])

===January 8-16, 2012===
#[[Strategy:Double shotgun|Double shotgun]] (winner: [[User:Kashi|Kashi]])
#[[Strategy:Reloader|Reloader]] (winner: [[User:AlterAsc|AlterAsc]])
#[[Strategy:Pain elemental|Pain elemental]] (winner: [[User:Tormuse|Tormuse]])

Strategy:BFG 9000

2012-05-26T22:30:29Z

Game Hunter:

{{infostrat switch}}
__NOTOC__
== Main Guide (0.9.9.5) ==

=== Version Changes (0.9.9.6) ===
Nothing significant to the weapon itself.

=== General Tactics ===
Basic strategy written by [[ZicherCZ|ZicherCZ]] 16:55, February 03 2012 (GMT).

BFG9000, the ultimate in conventional DoomRL warfare, is highly efficient against practically any foe, but consumes ammunition like there's no tomorrow.

A few tips on efficient use:
* BFG is the best weapon to use against targets you want to take out really quickly. [[Arch-vile|Archviles]] (doubly so those in the Mortuary) or [[Mancubus|mancubi]] can serve as a prime example, although, more likely than not, these would require two shots to go down. If you don't mind a bit of an overkill, you can, with near-certainty, take out those nasty [[Former_commando|former commandos]] and [[Revenant|revenants]] in one shot as well. [[Cyberdemon|Cyberdemon]] will then die (on average) after 5, 6, 7, 9 and 11 shots (with growing difficulty level). For the [[Spider Mastermind|Mastermind]] and [[John_Carmack|JC]] add 1 to Cyberdemon's numbers.
* If at all possible, try to hit multiple foes at once. The explosion radius of 10 is a definite help to this.
* If you happen to find another BFG, take it to save space in your inventory.. Its clip can hold 100 plasma cells, while an inventory slot can hold only 50 (70 with [[Backpack|backpack]]).
* Bulk-modding the BFG once increases the number of shots without reloading from two to three, which can be a life-saver at times. Another bulk mod will then increase this number to four, another one to five, fourth to seven and fifth then to nine (the exact clip sizes are 130, 169, 219, 285 and 371). With regards to the previous tip, a spare B5-modded BFG can hold more plasma cells than seven inventory slots.

Strategy:Former commando

2012-05-26T22:30:13Z

Game Hunter:

{{infostrat switch}}
__NOTOC__
== Main Guide (0.9.9.5) ==

=== Version Changes (0.9.9.6) ===
Nothing significant to the enemy itself.

=== General Tactics ===
Basic strategy written by [[ZicherCZ|ZicherCZ]] 12:00, February 03 2012 (GMT).

Former commandos are the toughest of all formers, and one of the deadliest enemies throughout the whole game. With a good enough accuracy and a plasma rifle in their hands, they can easily take you down in two volleys. Their ranged offensive power is something to be afraid of, but they share all formers offensive weakness - their pitiful melee attack. On the defensive side they do not go down easily as well. They have natural two points of armor and will happily grab and wear any armor from the ground to become even more hardy. Their double health, compared to other formers, doesn't help either.

Sometimes commandos spawn with a pack of 4-6 former humans and sergeants. If you happen to start a level close to them, and you can't retreat, they should be your top kill priority. Commandos wield a plasma gun that is left for you to take after their death. On Nightmare! and Angel of Darkness they ressurect with a new, fully loaded one, so farming one commando for plasma cells is a viable option.

So, how does one deal with them? If possible, don't allow them to get a shot at you. When you see one, retreat behind a corner and wait for them to come into melee range. [[Strategy:Giftdropping|Gift-dropping]] can help a lot, cornershooting can beat them down a bit before they come close. But beware of knockback of your weapons - you don't want to push them away and let them shower you with plasma.

The best position you can get them in is this:

###h
# #
###
@

or

###
# #h
###
@

This works for any side of any corner. In these positions, the commando cannot attack you and potencial knockback (for example from shotguns) will send them back along the wall. If retreat to a safe position is not a viable option, you may simply want to whip out the biggest weapon at your disposal and try to one-hit-kill them.

=== Weapon Usage ===

==== Melee ====
Commandos are pushovers in melee combat, but you have to get to their melee range or lure them to you. Again, gift-dropping and waiting around a corner is probably the best idea. Or simply leave them alone.

==== Pistol ====
Pistols, unless heavily modded, exotic or unique, are very weak against commandos. An unmodded standard pistol would need seven bullets on average to kill them. Thus, it's definitely wise to retreat if you meet one in the open. Unless you can use any of the strategies mentioned before, that is.

==== Shotgun ====
These fare better against commandos. A double shotgun can fairly reliably kill them point-blank in one shot (approx. 70% chance).
On the other hand, if you find one on the edge of your line of sight, even a normal shotgun has a good chance of knockback. With the commandos normal speed, they will then return to your line of sight on your reload without firing. This can be a bit ammo-consuming though.

==== Rapid Fire ====
Chaingun will not make it for you. It takes three volleys on average to kill a commando, and you may not get the chance to fire three times. Plasma gun works quite better - the chance to kill a commando is about 55% when all the shots hit.

==== Explosive ====
With the rocket launcher, a standard attack has slightly below 50% chance of one-hit-kill, and even if it does not kill the commando right away, it will push it back. Then you can just wait for it to come into your line of sight again to kill it with a second rocket. BFG 9000, on the other hand, allows for a nearly 100% chance to kill a commando in one hit. And you'll get those 40 plasma cells back if it's plasma rifle is not destroyed in the blast.

Strategy:BFG 9000

2012-05-26T22:25:18Z

Game Hunter:

{{infostrat switch}}
== Main Guide (0.9.9.5) ==

=== Version Changes (0.9.9.6) ===
Nothing significant to the weapon itself.

=== General Tactics ===
Basic strategy written by [[ZicherCZ|ZicherCZ]] 16:55, February 03 2012 (GMT).

BFG9000, the ultimate in conventional DoomRL warfare, is highly efficient against practically any foe, but consumes ammunition like there's no tomorrow.

A few tips on efficient use:
* BFG is the best weapon to use against targets you want to take out really quickly. [[Arch-vile|Archviles]] (doubly so those in the Mortuary) or [[Mancubus|mancubi]] can serve as a prime example, although, more likely than not, these would require two shots to go down. If you don't mind a bit of an overkill, you can, with near-certainty, take out those nasty [[Former_commando|former commandos]] and [[Revenant|revenants]] in one shot as well. [[Cyberdemon|Cyberdemon]] will then die (on average) after 5, 6, 7, 9 and 11 shots (with growing difficulty level). For the [[Spider Mastermind|Mastermind]] and [[John_Carmack|JC]] add 1 to Cyberdemon's numbers.
* If at all possible, try to hit multiple foes at once. The explosion radius of 10 is a definite help to this.
* If you happen to find another BFG, take it to save space in your inventory.. Its clip can hold 100 plasma cells, while an inventory slot can hold only 50 (70 with [[Backpack|backpack]]).
* Bulk-modding the BFG once increases the number of shots without reloading from two to three, which can be a life-saver at times. Another bulk mod will then increase this number to four, another one to five, fourth to seven and fifth then to nine (the exact clip sizes are 130, 169, 219, 285 and 371). With regards to the previous tip, a spare B5-modded BFG can hold more plasma cells than seven inventory slots.

Strategy:Arachnotron

2012-05-26T22:24:06Z

Game Hunter: reorganized

__NOTOC__
{{infostrat switch}}
== Main Guide (v0.9.9.5) ==

=== Version Changes (v0.9.9.6) ===
Nothing significant to the enemy itself.

=== General Tactics ===
Base strategy posted by [[User:IronBeer|IronBeer]] 19:02, January 27 2012 (GMT).

The Arachnotron is a ranged attacker, equipped with a lowish-power (1d5x5) but somewhat accurate (+3) plasma gun. Even in the best circumstances, fighting a ‘tron in an open area is a hairy proposition, but a straight-up gunfight is seriously complicated by an Arachnotron’s 130% speed. This essentially means that an Arachnotron will get to make (assuming normal move/act speeds for the player) 4 actions for every 3 of your actions. Generally, these actions will be to fire upon the player should s/he be in view, and those extra actions have a nasty tendency to appear at the exact worst times.

Arachnotrons are fairly durable with 50 hitpoints and 2 points of [[armor|protection]], so fairly heavy firepower is necessary to bring one down efficiently. However, their high speed results in an enemy that can lay down a very heavy field of fire. Circle-strafing or side-stepping is somewhat effective, but two factors work against the player who attempts this. First, the sheer number of shots an Arachnotron fires mean that at least a few will hit you eventually; second, Arachnotrons are frighteningly good at getting their extra action while firing on the player. This extra action essentially means that the Arachnotron will get a free cheap shot on a “stationary” player, since the player did not move immediately prior to the Arachnotron’s last move. (See [[Dodging]].) Needless to say, this is very bad for the player.

Now that we know what we’re up against, how do we go about killing these things? As noted above, Arachnotrons are pretty tough, so we’ll probably need a few actions to bring one down. The threat of being counter-attacked should always loom large, so most of our tactics should generally involve firing such that our foe cannot retaliate.

=== Weapon Usage ===
Early-game (Hell’s Armory, ordinary floors at higher difficulty levels), your best bet is some flavor of [[shotgun]] and corner-shooting. Shotguns serve very well by permitting the player to attack blindly, and by knocking back the Arachnotron, forcing it to spend an action getting back into position. [[Knockback]] can also sometimes be used to push an Arachnotron into acid or lava, killing it more quickly, but often destroying their plasma cells in the process. If an Arachnotron is dumb enough to close into melee range while you have a shotgun equipped, you should think twice before firing at point-blank range. If the ‘tron is badly injured, and you’re certain that your next blast will kill it, then go ahead and fire. Alternatively, if the ‘tron is against a wall and won’t be knocked back, go to town- this particular foe is weak in melee. However, if the Arachnotron is fairly healthy and has a space to be knocked into, you may want to switch weapons- the danger is that you’ll knock the ‘tron out of melee range and it’ll melt you with easy short-range fire on a stationary target.

I generally don’t endorse using rapid-fire weapons against ‘trons unless your build really takes advantage of them. A [[chaingun]] in untrained hands will be a difficult and painful gunfight; a [[plasma rifle]] should do a bit better owing to the increased damage and armor reduction, but it’ll still be messy. Any rapid-fire master trait (especially [[Ammochain]]) lets a player go just about toe-to-toe with a ‘tron, generally by wasting the ‘tron first. Blind-firing into a known position is a fully viable strategy, but may be expensive, ammo-wise. Staying out of an Arachnotron’s sights is generally worth the ammo investment, and plasma users might be able to break even.

An unmodified [[rocket launcher]] is a rather poor choice for slaying ‘trons, but pretty much any practical mod setup or special rocket launcher is quite effective. A non-exhaustive list of “good” mod setups would include: 1 bulk mod, a [[micro launcher]], or a [[tactical rocket launcher]]. Alternatively, a couple levels in [[Reloader]] will work; off-setting that slow reload time is crucial to using rockets against Arachnotrons. Since they already have the potential to double-act, the base reload time only makes that problem worse should you choose to reload at a bad time. Actually fighting Arachnotrons with rockets is pretty simple: check range, aim, shoot, reload and repeat. Rockets should usually deal knockback, and an Arachnotron engaged at the edge of viewing range should seldom retaliate effectively, if at all. 3 rockets will usually do the job, but will destroy the plasma cell drop.

The [[BFG 9000]] is OVERKILL, and if you’re pointing one at an Arachnotron, it better have a lot of nearby ugly friends, or you better be sitting on a trainload of extra cells. The same problem with the rocket launcher (reload time) is also an issue for BFGs.

The last engagement option is to get up close and bash an Arachnotron’s ugly face in with a melee weapon. Surprisingly, this is a pretty good idea: Arachnotrons have -100% (yes, that is a negative) resistance to melee damage. Anybody can easily dispatch a ‘tron with a [[chainsaw]], and a trained [[Brute]] can punch one out with little trouble. Arachnotrons can hit back for moderate damage, but it is a lot less than their ranged attack. Of course, the only problem is getting close.
*If you find yourself a couple of spaces away from an arachnotron with no cover immediately available, charging into melee range is probably your best option (running mode not necessary, in my opinion). Another way to get them into melee range is to just wait around a corner and shoot them to get their attention, and wait. Charging into melee towards an arachnotron at the edge of your vision is just asking for trouble though: you'll be taking plasma volleys, and in general charging into melee exposes you to fire from other enemies, especially ones that were out of sight behind the one you're after. [[User:Matt_S|Matt_S]] 00:24, February 02 2012 (GMT)

Also, switching to your best armor is seldom a bad idea, just in case. This usually means [[red armor]], or something with Plasma resist (if you’ve gotten lucky).

=== Trait Usage ===
Defensive traits such as [[Ironman]] and [[Tough as Nails]] don’t exactly shine against Arachnotrons, but the extra tankiness is the unsung hero that will keep you alive during a firefight. I typically take Ironman after getting a master trait on just about every build I do. Brute can be valuable as well, but charging an Arachnotron just for the sake of getting a melee kill is a bad idea; baiting a ‘tron into chasing you can simplify the “closing-in” problem, but you may take some hits. [[Dodgemaster]] is actually less helpful than you would think, since Arachnotrons attack in bursts, and the trait only affects the first dodge per incoming attack. Rank 2 in Intuition is always good, perhaps even too good- the application should be pretty obvious. [[Gun Kata]] has the potential to ruin Arachnotrons so long as your pistols have the capacity to kill your target in one clip. Ammochain is a time-tested classic trait; the near-zero ammo consumption combined with a well-modded weapon allows a player to easily outshoot ‘trons. If you’ve managed to get a really good suit of armor Survivalist has the potential to be absolutely hilarious and can totally negate an incoming volley.

=== Miscellaneous Information ===
Arachnotron Caves are fiendish levels that have ended many a game for unfortunate Doomguys everywhere. They're seldom simple, and a lot of times your best bet is to simply try and bolt for the stairs or pop a [[homing phase device]]. If you feel confident in your gear and your supplies, clearing the cave presents both challenge and opportunity. The challenges lie in the fact that caves combine huge open areas with lots of blind corners. Radar shoot where possible and try and stay behind cover if using shotguns. There are positions where you can see your target but they cannot see you (and thus cannot retaliate); these positions are not intuitive or easy to communicate, but can be figured out over time. If using a well-kitted rocket launcher (or derivative), try to isolate and snipe ‘trons individually just as they enter vision. This is often easier said than done, but a Missile Launcher really helps. Rapid-fire gunners should simply try and stay in cover and poke at Arachnotrons when they wander into view; gunners typically have the firepower to quickly dispatch ‘trons but nobody can really afford to get shot up. Of course, the opportunity presented is the pile of power cells that the Arachnotrons will drop, and occasionally loot and powerups on the floor.
*This is a time where I'd recommend activating run mode if there's any Arachnotrons around you. Hurry behind any group of rocks you see, and if you have a rocket launcher or even a BFG, this is a good time to bring it out. A melee weapon can actually be really useful here, as there will often be situations where an Arachnotron comes sneaking around the corner of your rock cover, where he's too close to blow up (except with a BFG which doesn't hurt you) and where you can't corner shoot him with a shotgun. [[User:Matt_S|Matt_S]] 00:24, February 02 2012 (GMT)
*I thought this info might be helpful, which shows the minimum depth and number of Arachnotrons in a cave. More Arachnotrons will appear if playing [[Angel of 100|Ao100]]: number is dependent on depth. [[User:Shark20061|Shark20061]] 09:26, 7 March 2012 (CET)

{| cellspacing="0" cellpadding="5" align="left"
! Difficulty
! Floor of earliest appearance
! Number of Arachnotrons
|-
| ITYTD
| 17
| 4 - 5
|-
| HNTR
| 14
| 4 - 5 (up to 10 on [[Angel of 100|Ao100]])
|-
| HMP
| 11
| 5 - 8 (up to 15 on [[Angel of 100|Ao100]])
|-
| UV
| 8
| 7 - 12 (up to 24 on [[Angel of 100|Ao100]])
|-
| N!
| 5
| 7 - 15 (up to 30 on [[Angel of 100|Ao100]])
|}

 

Regarding powerups: Do not even think about taking small health globes if you're under enemy fire. Since they restore you from running to normal, Arachnotrons will get a "temporary" restoration of their [[accuracy]], from +1 all the way to +5, which is a huge difference at any range: the end result is that you'll lose much more than you could gain. Taking large health globes is safer against a single at-the-edge Arachnotron, but even that can be more dangerous than it's worth. Same thing about using med-packs - beware of using them without cover: being Technician in this case is a great help, as you can switch to running back after only 0.1s instead. [[Berserk Pack|Berserk Packs]] are mostly a shoe-in, but against arachnotrons it's not as effective as usual as each hit will deal at least 1 damage anyway.If you don't see stairs or a particularly nice powerup (like the [[Invulnerability Globe]]), run to cover. [[User:AlterAsc|AlterAsc]] 15:34, February 03 2012 (GMT)

Modding:Tutorial/Building an Episode

2012-04-23T14:48:00Z

Game Hunter: some corrections

The simplest of modules are built upon a single map, a single level. While this can provide for some very unique and thrilling gameplay, it is not nearly on the same scale of DoomRL itself, which is a gauntlet of many levels, one after another. If you'd prefer to have a module with the structure of something longer and more challenging than a single level can produce, you're probably looking to create an episode. The purpose of this tutorial is to explain exactly how that is done.

In order to fully explore the possibilities of an episodic module, make sure you understand the basics of modding. If nothing else, take a look at the tutorial [[Modding:Tutorial/Constructing a Map|Constructing a Map]] before continuing on.

== Special Concept: Setting Levels ==
The player object comes with a custom property called "episode". This is what determines where the player will be when they reach a certain depth. In fact, this is the majority is what is necessary to string together all the levels in an episode. This is combined with an episodic engine hook known as OnCreateEpisode to build the episode's content. Here is a simple example:

<source lang="lua">
core.declare( "a_mod", {} ) --initialize the module object

function a_mod.OnCreateEpisode()
player.episode = {} --initialize/reset the table

--defines first floor as a special level
player.episode[1] = { style = 1, script = "hells_arena" }
--defines second floor as a random level
player.episode[2] = { style = 1, number = 1, name = "Floor", danger = 1}
end
</source>

The following would create an episode with two levels. The first level is defined by calling a level "script": the script used here is actually Hell's Arena from the base game. Because the map was initialized with the rest of the game (and this is not a total conversion module), it is included as part of the potential level scripts. So long as a level object has been created and initialized in your module, you are free to include any levels you want as well. (Although style does not have an effect on the level, it is necessary to include as a formality.)

The second level is defined through level properties, rather than calling a script. When this is done, the game can initialize a level with these properties but must still produce some sort of generated content. For this, we require the OnGenerate() hook:

<source lang="lua">
function a_mod.OnGenerate()
Generator.reset()
Generator.generate_caves_dungeon()
end
</source>

OnGenerate() controls the content of unscripted maps. This can be technically used to create an identical series of maps, but it is much more interesting to create maps using generator functions. Generator.reset() clears any leftover data in the generator, while Generator.generate_caves_dungeon() creates a random cave level ([[Level Type#Cave|of which you are probably familiar]]). The properties defined from OnCreateEpisode() will come into play for the purposes of determining things such as the walls, doors, floors, danger level, and so on. See [[Modding:Generator]] for a complete list of generator functions with which to play around.

Now that we understand the basics of producing an episodic module, let us discuss a simple example that emulates that of a very old version of the game: Classic Mode.

== Engine Hooks ==

=== .OnCreateEpisode() ===
<source lang="lua">
function classic.OnCreateEpisode()
local BOSS_LEVEL = 10
player.episode = {}

player.episode[1] = { style = 1, script = "intro" }
for i=2,BOSS_LEVEL-1 do
player.episode[i] = { style = 1, number = i, name = "Phobos", danger = i}
end
player.episode[10] = { style = 3, script = "phobos_arena" }

statistics.bonus_levels_count = 0
end
</source>
As before, we initialize the episode table. We've also defined the end level, coined ''BOSS_LEVEL'', as the tenth floor. The layout is fairly straightforward:

*The very first level takes place in Phobos Base Entry. This is indicated with the script "intro".
*Floors two through nine are set as randomly-generated levels. They will be named "Phobos 2", "Phobos 3", etc, and will have danger levels of the same number.
*The final level is a level script called "phobos_arena". Although this is not included in the base game, we'll be providing this script ourselves for the purpose of this episode.

Finally, as a matter of completeness, since there are technically no "special" levels in this episode, we set the bonus level count to zero from the statistics object. Special levels can actually be included as part of the level initialization by defining the ''special'' key: red stairs will be automatically provided on that level in addition to everything else. In either case, however, the statistics for bonus levels must be manually set.

=== .OnGenerate() ===
<source lang="lua">
function classic.OnGenerate()
Generator.reset()
Generator.generate_tiled_dungeon()
end
</source>
This function is almost identical to the one from the concepts example: the generator object is reset, and then a tiled dungeon is set for any and all unscripted (random) levels. The tiled dungeon is the de-facto level style found in DoomRL: it is the one that always appears on the second floor, regardless of the circumstances. Since this is a classic map, all of the levels are determined in this manner. You can, however, use some randomization within '''OnGenerate()''' to change which map is actually generated. The specifics of the randomization in the base game can be found in [[Level type]].

=== .OnMortemPrint() ===
<source lang="lua">
function classic.OnMortemPrint(killedby)
if killedby == "defeated the Mastermind" then
killedby = "defeated the Cyberdemon"
elseif killedby == nil then
killedby = "played through the classics"
end
player:mortem_print( " "..player.name..", level "..player.explevel.." "..klasses[player.klass].name..", "..killedby )
end
</source>
'''OnMortemPrint()''' is where all mortem-printing should be done, hence its name. It comes with the ''killedby'' parameter, which determines the status of the player at the time of the printing. Despite its name, ''killedby'' can produce a variety of messages, including those for winning the game. This mortem_print in particular is just like the one from the tutorial for [[Modding:Tutorial/Recreating Hell's Arena|Hell's Arena]], so it should be familiar enough to understsand already.

Of particular note is that we require a change in the victory condition: ''killedby'' returns that the Mastermind was defeated in a standard victory, so we change it to reflect that it was the Cyberdemon instead.

=== .OnWinGame() ===
<source lang="lua">
function classic.OnWinGame()
ui.plot_screen([[
Once you beat the Cyberdemon and clean out the moon
base you're supposed to win, aren't you? Aren't you?
Where's your fat reward and ticket back home? What
the hell is this? It's not supposed to end this way!

It stinks like rotten meat but it looks like the
lost Deimos base. Looks like you're stuck on
The Shores of Hell. And the only way out is through...
]])
end
</source>
The '''OnWinGame()''' hook allows you to play around with some of the user interface commands upon winning the game. If you recall beating the base game, it's what happens immediately after killing the Spider Mastermind, but before the mortem appears. Our use of the hook simply displays a single screen of plot with the '''ui.plot_screen()''' function, which accepts a single string. You can play around with some properties here but that's better saved for '''OnMortem()'''.

== Levels: Phobos Arena ==
<source lang="lua">
Levels("phobos_arena",{
name = "Phobos Arena",
entry = "Then at last he found the Phobos Arena!",
welcome = "You enter a big arena. There's blood everywhere. You hear heavy mechanical footsteps...",

Create = function ()
Level.fill("wall")
Level.fill("floor", area.FULL_SHRINKED )
local scatter_area = area.new( 5,3,68,15 )
local translation = {
['.'] = "blood",
['#'] = "gwall",
['>'] = "stairs",
}
Level.scatter_put(scatter_area,translation, [[
.....
.###.
.###.
.###.
.....
]],"floor",12)

Level.flags[ LF_NOHOMING ] = true
Level.scatter(area.FULL_SHRINKED,"floor","blood",100)
Generator.set_permanence( area.FULL )
player.flags[ BF_ENTERBOSS1 ] = true
end,

OnEnter = function ()
local boss = Level.summon("cyberdemon")
boss.flags[ BF_BOSS ] = true
end,

})
</source>
This is the level included with Classic Mode: the end-game level, Phobos Arena. This is, more or less, a replica of the original end-game level prior to version 0.9.9.5. Many of the things covered here have already been explained in the singular module tutorials, so they will not be described in detail here. This is a quick overview:

*We start with a wall-bordered blank room, randomly add 12 pillars away from the borders, then randomly populate the rest of the level with blood.
*Homing phase devices will fail to work here (though there are no stairs to phase to anyway).
*Everything in the level is made permanent so that no walls can be destroyed
*The player's flags are modified so that the game knows we are on a boss level.
*Finally, the Cyberdemon is spawned at a random coordinate and given the boss flag, so that killing it ends the game.

One thing not seen in previous tutorials, however, is the Level object itself. In a singular module, the level is created with the '''run()''' function: in an episodic module, levels are defined separately and called when necessary. The basic level structure is as follows:

*Levels are technically handled with functional syntax. The identifier is placed as the first argument in this function, and a table that defines the level's properties and hooks is given as the second argument.
*Typical level properties are:
**''name'' is what the level is called, as it appears at the bottom-right.
**''entry'' is what appears in the mortem, signifying that you entered the level.
**''welcome'' is what appears in the message log as you enter the level.
*Hooks are added to the level, just as they would be for a singular module. Of particular note is that the '''run()''' hook is replaced with '''Create()''': they are functionally identical, but use different names due to where they are called.

Within the module's source, this level is given its own file in a separate folder called "data". In order for the module to access the file, a function called '''require''' is used:
<source lang="lua">
require "classic:data/phobos_arena"
</source>
The module's name is written before the colon, and the path from the module's root folder is written after. '''require''' assumes a .lua extension, and few other files would be useful at this time.

== Review ==
Included is the main.lua, phobos_arena.lua, and the module.lua used to run the file:

{{:Modding:Tutorial/Building an Episode/Source}}

Source data: [http://dl.dropbox.com/u/54818507/classic.module.zip classic.module]

Modding:Tutorial/Recreating Hell's Arena

2012-04-08T17:09:00Z

Game Hunter: /* Review */ new link

In many ways, learning through example is a solid method of figuring out how to create your own code. The archetypical example we use here is Hell's Arena, which has been the example mod of DoomRL since the inception of the sandbox. It imitates [[Hell's Arena]] as it appears in DoomRL itself, which a few additions added here and there to create a different experience.

As with all example modules in these tutorials, we will first begin with any radically-new concepts that require plenty of room, then go on to explain things by declaration. Usually this would involve looking at any cells/items/beings (or just old-fashioned tables) but this module has no new objects. Instead, we will only need to move through each engine hook and how it affects the map itself. As a measure of extra caution, generic comments will be added to this map as a means to provide understanding for those skipping all the extra details.

==Special Concept: Adding Sound and Music==

The most significant departure from the Arena's vanilla counterpart is the inclusion of custom sounds and music. This is explained sufficiently in the [[Modding:Module|module documentation]], but the steps to doing so will be laid out explicitly here.

*First and foremost, you need to the sound and/or music files. Sounds must be a .wav file, and music must be a .mid, .mp3, or .ogg file. (Note that using .mp3 or .ogg can easily make WAD files much bigger files, so take caution when adding them to your module.) It is suggested that you name your sound and music files something that describes the audio of the file, as its filename (minus the extension) will be used verbatim in the lua script.
*Second, we need to put them into the module correctly. This is done by creating additional subdirectories in your .module folder:
**sound files go into "sound"
**music files go into "music"
*Whenever you want to access one of these sound or music files, you will use one of the following methods:
**Sounds are most commonly called using '''being:play_sound'''(''filename''), where "being" is whomever you want the sound to originate from. For "surround" sounds, use '''player:play_sound()'''.
**If you want the sound at a very specific point on the map, use '''[[Modding:Level#level_explosion|Level.explosion()]]''' and set the radius, delay, and damage of the explosion to zero: this removes any physical part of the explosion, allowing you to play only a sound at that point.
**Music is added using '''core.play_music'''(''filename''). It will override any music already playing. (Unfortunately there is no way to turn off the music: if you want no music to play, create a music file that has no audio and use it instead.)
*Do not modify sound.lua or music.lua. This is technically a way to modify (or include) sounds and music for particular objects/calls, but neither of these files are included in the source folder or WAD file. For the sake of players wanting an easy dump into their DoomRL folder, it is higly recommended that you stick to the aforementioned procedure instead.

In the Hell's Arena module, Skulltag sounds are added at the start of the map, as well as the start of each wave. Music by Simon Volpert, named "Rounds of Hell", is also included at the beginning of the map and changes for each wave. (Adding sounds to beings is a lot more complicated, and we won't get into it here. Suffice it to say that it may prove more trouble than it's worth, not to mention that default sounds cannot be overwritten.)

==Engine Hooks==

===.run()===
<source lang="lua">
--always declare the module_id global
core.declare( "arena" , {} )

function arena.run()
Level.name = "Hell Arena" --that IS what it's called
Level.name_number = 0 --remove floor #
Level.fill("rwall") --immortal border tiles
local translation = {
['.'] = "floor", --gray floor
[','] = "blood", --red floor (blood)
['#'] = "rwall", --red wall (bloodstone)
['>'] = "stairs" --gray (normal) stairs
}

--create map cell string (76x18)
local map = [[
#######################.............................########################
###########.....................................................############
#####..................................................................#####
##........................................................................##
#..........................................................................#
............................................................................
..................................,,,,,,....................................
..,,,.............................,,,,,,,...................................
..,>,............................,,,,,,,,,..................................
..,,,............................,,,,,,,,...................................
..................................,,,,,,....................................
............................................................................
............................................................................
#..........................................................................#
##........................................................................##
#####..................................................................#####
###########.....................................................############
#######################.............................########################
]]
--create pillar cell string (6x5)
local column = [[
,..,.,
,####.
.####,
.####.
,..,.,
]]

--puts map in non-border area
Level.place_tile( translation, map, 2, 2 )
--adds random pillars and blood
Level.scatter_put( area.new(5,3,68,15), translation, column, "floor",9+math.random(8))
Level.scatter( area.FULL_SHRINKED,"floor","blood",100)
--all walls become indestructible
Generator.set_permanence(area.FULL)
--inserts player
Level.player(38,10)
end
</source>
If you recall in the tutorial [[Modding:Tutorial/Constructing a Map|Constructing a Map]], we used the starting coordinate (1,1) for the '''Level.place_tile()''' method, rather than (2,2). This is because we included the map's border tiles in our test map. It is, in fact, possible to customize the border of the map (there are some issues with non-cell objects on the border, so it is suggested you don't allow for them): however, if the border of the map is going to be uniform, then when you use '''Level.fill()''', fill the level with the border tiles you want. Then, when you write out the map string, you can ignore their existence altogether (the dimensions of such a map string should be 76x18), and place the map string at the starting coordinate (2,2) instead.

Additionally, we have another cell string on this map: a 6x5 group consisting of a pillar surrounded by floor tiles. Hell's Arena randomly scatters these tiles around using the '''Level.scatter_put()''' method. The arguments are as follows:
*Area in which the cell string can be placed
*character/map translation table (thus you should write this cell string in the same terms as your map's)
*name of the cell string
*cell_id on which this cell string can be placed (the method will be sure that the entire cell string can replace only the cell_id you input here)
*number of times cell string is placed

In the example, a fairly large area is carved out for these pillars to be placed, defining the same translation as for the normal map, using the variable name of the cell string, replacing the "floor" cell, and will be added anywhere from 10-17 times. Note that the middle of the map uses "blood" floor tiles rather than "floor", so that pillar will never appear here.

Finally, after placing the pillars, blood floor files are randomly added to the floor using the '''Level.scatter()''' method. '''Level.scatter()''' is similar to '''Level.scatter_put()''' but has no translation/map arguments. Instead, it asks for the area affected, the cell_id that will replace, the cell_id being replaced, and the number of times it should be added. In the example, "floor" is replaced with "blood" 100 times on any non-border tile (''area.FULL_SHRINKED'' is equivalent to '''area.new'''(''2'',''2'',''77'',''19'')).

===.OnEnter()===
<source lang="lua">
function arena.OnEnter()
core.play_music("rounds_of_hell_part_1") --use some kick-ass music
player:play_sound("preparetofight") --skulltag announcer!
player.eq.weapon = item.new( "shotgun" ) --give the man a shotty

--add 50 shotgun shells to inventory in a single "shell" item
local shells = item.new( "shell" )
shells.ammo = 50
player.inv:add( shells )
....
</source>

The '''OnEnter()''' hook begins in a way you'd tend to expect: special sound/music is added and the player's inventory is adjusted (specifically they are given a shotgun in-hand and fifty shells in the bank).

<source lang="lua">
....
Level.result(1) --sets up first wave

--big announcement stuff
ui.msg("A devilish voice announces:")
ui.msg("\"Welcome to Hell's Arena, mortal!\"")
ui.msg("\"You are either very foolish, or very brave. Either way I like it!\"")
ui.msg("\"And so do the crowds!\"")
player:play_sound("fight")
ui.msg("Suddenly you hear screams everywhere! \"Blood! Blood! BLOOD!\"")
ui.msg("The voice booms again, \"Kill all enemies and I shall reward thee!\"")
player:play_sound("one")
....
</source>

The next part of '''OnEnter()''' is a series of '''ui.msg()''' methods to display text onto the player's top part of the screen. Sounds are added are relevant points of the monologue. Note that, although '''ui.msg_enter()''' isn't being used, the player will have to press ENTER once two lines of text is fully displayed. Getting the timing of this with sounds can be tricky, so I would personally recommend that you use '''ui.msg_enter()''' just before a sound is to be played.

Also included here is the '''Level.result()''' method. '''Level.result()''' can be used in two ways:

*Calling without any arguments returns the current value of '''Level.result()'''
*Calling with an integer argument sets '''Level.result()''' to that integer value

This value can be used for a number of things, but it is most often associated with events occurring in the level.

<source lang="lua">
....
--create the first wave
Level.summon("demon",3) --3 demons
Level.summon("lostsoul",2) --2 lost souls
Level.summon("cacodemon",DIFFICULTY-1) --0/1/2/3/4 cacodemons
end
</source>

Finally, '''OnEnter()''' spawns us some enemies using the '''Level.summon()''' method. This is a very simple function: input the being_id you want to spawn and how many, and the game will randomly generate them anywhere on the map. To spawn enemies in a specific area, you will want to use Level.area_summon(), which includes an area argument.

The number of cacodemons in the level depends on the difficulty, which can be called through a pre-defined global variable called ''DIFFICULTY''. On I'm Too Young To Die, ''DIFFICULTY'' is equal to 1; on Hey, Not Too Rough, ''DIFFICULTY'' is equal to 2; and so on and so forth.

===.OnKill()===
<source lang="lua">
function arena.OnKill()
--randomized cheers from the crowd
local temp = math.random(3)
if temp == 1 then ui.msg("The crowds go wild! \"BLOOD! BLOOD!\"")
elseif temp == 2 then ui.msg("The crowds cheer! \"Blood! Blood!\"")
else ui.msg("The crowds cheer! \"Kill! Kill!\"") end
end
</source>

The '''OnKill()''' hook is used in Hell's Arena to add some crowd cheering. It is randomized between three messages using a temporary variable that changes every time another enemy dies (as the variable is re-defined each time the hook is triggered).

===.OnKillAll()===
<source lang="lua">
function arena.OnKillAll()
if Level.result() == 1 then --if first wave completes
--more talk
ui.msg("The voice booms, \"Not bad mortal! For a weakling that you ")
ui.msg("are, you show some determination.\"");
ui.msg("You hear screams everywhere! \"More Blood! More BLOOD!\"")
ui.msg("The voice continues, \"I can now let you go free, or")
ui.msg("you may try to complete the challenge!\"");

--player can choose to continue
local choice = ui.msg_confirm("\"Do you want to continue the fight?\"")
if choice then --player chose to continue
core.play_music("rounds_of_hell_part_2") --second verse better than first
player:play_sound("two")
ui.msg("The voice booms, \"I like it! Let the show go on!\"")
ui.msg("You hear screams everywhere! \"More Blood! More BLOOD!\"")

Level.drop("chaingun") --sweet drop
Level.summon("demon",3) --3 demons
Level.summon("cacodemon",DIFFICULTY) --1/2/3/4/5 cacodemons
--player chose to stop
else
ui.msg("The voice booms, \"Coward!\" ")
ui.msg("You hear screams everywhere! \"Coward! Coward! COWARD!\"")
end
....
</source>

'''OnKillAll()''' contains the bulk of code in this map, since each time a wave of enemies is killed, a number of things change. The first condition required is to check which wave we're on using '''Level.result()'''. Recall that '''Level.result()''' is equal to 1 based on the '''OnEnter()''' hook, so the first '''OnKillAll()''' will trigger for this first case.

After another lengthy explanation, the player is given a y/n confirmation using the '''ui.msg_confirm()''' method. This returns a true/false value depending on the input of the player: in the example we assign this return value to ''choice''. Thus we can use this variable to determine what happens next:

*In the event that the player chooses to accept with the "y" key (''choice'' is set to true), then we get another music change, some displayed praise, and some items and beings added to the level.
*In the event that the player choosen to decline with the "n" key (''choice'' is set to false), then we get a displayed insult.

'''Level.drop()''' should be self-explanatory: is it the item equivalent of '''Level.summon()'''. Both the '''Level.drop()''' and '''Level.summon()''' methods can have the number of items/beings omitted: if so, the default value of 1 is used.

<source lang="lua">
....
elseif Level.result() == 2 then --if second wave completes
--even more talk
ui.msg("The voice booms, \"Impressive mortal! Your determination")
ui.msg("to survive makes me excited!\"")
ui.msg("You hear screams everywhere! \"More Blood! More BLOOD!\"")
ui.msg("\"I can let you go now, and give you a small reward, or")
ui.msg("you can choose to fight the final challenge!\"")

--player can choose to continue
local choice = ui.msg_confirm("\"Do you want to continue the fight?\"")
if choice then --player chosen to continue
core.play_music("rounds_of_hell_part_3") --strongest music yet
player:play_sound("three")
ui.msg("The voice booms, \"Excellent! May the fight begin!!!\"")
ui.msg("You hear screams everywhere! \"Kill, Kill, KILL!\"")

--some more sweet loot
Level.drop("shell",4)
Level.drop("ammo",4)
--spawns are a little more difficulty-dependent
if DIFFICULTY <= 2 then --ITYTD and HNTR
Level.summon("cacodemon",DIFFICULTY+1)
elseif DIFFICULTY == 3 then --HMP
Level.summon("knight",2)
elseif DIFFICULTY >= 4 then --UV and N!
Level.summon("baron",2)
end
else --player chose to stop
ui.msg("The voice booms, \"Too bad, you won't make it far then...!\" ")
ui.msg("You hear screams everywhere! \"Boooo...\"")

--pointless loot
Level.drop("shell",3)
Level.drop("lmed")
Level.drop("smed")
end
....
</source>

This part of the '''OnKillAll()''' code shows for the case of '''Level.result()''' equal to 2. It is roughly the same as the first case (different music/items/summons/messages aside), but with the following nontrivial changes:

*The enemies used in the final wave are included in an if-then-elseif conditional statement, with each condition depending on ''DIFFICULTY''. We have three settings: cacodemons (2 on ITYTD, 3 on HNTR), hell knights (on HMP), and barons of hell (on UV and N!).
*If the player chooses to decline, they will still receive some items. This is simply how it works in the vanilla map, and serves no real purpose in a single-level module such as this.

<source lang="lua">
....
elseif Level.result() == 3 then --if third wave completes
--finally done talking
ui.msg("The voice booms, \"Congratulations mortal! A pity you came to")
ui.msg("destroy us, for you would make a formidable hell warrior!\"")
ui.msg("\"I grant you the title of Hell's Arena Champion!\"")
ui.msg("\"And a promise is a promise... search the arena again...\"")

--also pointless loot
Level.drop("scglobe")
Level.drop("barmor")
Level.drop("lmed")
end
....
</source>

Finally, '''OnKillAll()''' checks for the case of Level.result equal to 3: this is after all three waves have been killed. The announcer finishes entirely and the player receives some superfluous rewards.

<source lang="lua">
....
--increment level counter each time a wave completes
Level.result(Level.result()+1)
end
</source>

This final piece of code is very important: each time '''OnKillAll()''' is triggered, after all the '''Level.result()''' checks are made, '''Level.result()''' is incremented by one. This means that, after the first wave of enemies is killed, the case of Level.result equal to 1 is executed, the other cases are ignored, and then Level.result() is set to 2. This repeats for the other cases, albeit with different lines being executed before Level.result() is incremented.

===.OnExit()===
<source lang="lua">
function arena.OnExit()
ui.msg_enter("The voice laughs, \"Flee mortal, flee! There's no hiding in hell!\"")

--takes care of mortem text for "killed by something unknown..."
if Level.result() < 4
then arena.result = "fled alive the trials at wave "..Level.result()
else arena.result = "completed the trials"
end
end
</source>

Once the player leaves the level (and '''OnExit()''' triggers), a final statement is given (which must be confirmed to continue, lest it be missed entirely) and a new field to ''arena'' is added, this time a string called ''result''. If '''Level.result()''' is less than 4 (which is to say, all waves were not killed) then ''arena.result'' writes out when the player left using '''Level.result()''' as the wave number. If '''Level.result()''' is 4 (or technically greater) then ''arena.result'' writes out that the player finished. But where is this string going to?

===.OnMortem()===
<source lang="lua">
function arena.OnMortem()
local kill = player.killedby --calls kill descriptions from beings
if arena.result then kill = arena.result end
player:mortem_print( " "..player.name..", level "..player.explevel.." "
.." "..klasses[player.klass].name..", "..kill )
--e.g., "Cool Guy, level 1 Marine, fled alive the trials at wave 3"
player:mortem_print(" in the Hell Arena...")
end
</source>

The '''OnMortem()''' hook is called whenever the player has exited the level, immediately after '''OnExit()''', and can be used to change what is displayed on the mortem screen. Here we see ''arena.result'' in action:

*If the player is killed by an enemy, that being's ''kill_desc'' (or ''kill_desc_melee'') can be called using ''player.killedby'', which is then set to the local variable ''kill''. If not, ''kill'' will be empty when the first line executes.
*If ''arena.result'' was created (and will thus be true), then ''kill'' is instead set to that string. Since ''arena.result'' is only created if the player chooses to exit the game, this will not overwrite the case where the player is actually killed. It is done mostly to avoid any instances in which there would be a "killed by something unknown..." message.

Finally, the first two lines of the mortem are replaced with the '''player:mortem_print()''' method. ''player.name'' is the name of the player (as determined in-game); ''player.explevel'' is the character level; and ''klasses[player.klass].name'' checks the class prototype and returns the player's chosen class's name (for example, "Marine").

==Review==
Here is the entire main.lua file to view at once:

{{:Modding:Tutorial/Recreating Hell's Arena/Source}}

Source data: [http://dl.dropbox.com/u/54818507/arena.module.zip arena.module]

Modding:Tutorial/Recreating Hell's Arena/Source

2012-04-08T16:52:48Z

Game Hunter: revised for 0996

<source lang="lua">
--always declare the module_id global
core.declare( "arena" , {} )

function arena.OnEnter()
core.play_music("rounds_of_hell_part_1") --use some kick-ass music
player:play_sound("preparetofight") --skulltag announcer!
player.eq.weapon = item.new( "shotgun" ) --give the man a shotty

--add 50 shotgun shells to inventory in a single "shell" item
local shells = item.new( "shell" )
shells.ammo = 50
player.inv:add( shells )

Level.result(1) --sets up first wave

--big announcement stuff
ui.msg("A devilish voice announces:")
ui.msg("\"Welcome to Hell's Arena, mortal!\"")
ui.msg("\"You are either very foolish, or very brave. Either way I like it!\"")
ui.msg("\"And so do the crowds!\"")
player:play_sound("fight")
ui.msg("Suddenly you hear screams everywhere! \"Blood! Blood! BLOOD!\"")
ui.msg("The voice booms again, \"Kill all enemies and I shall reward thee!\"")
player:play_sound("one")

--create the first wave
Level.summon("demon",3) --3 demons
Level.summon("lostsoul",2) --2 lost souls
Level.summon("cacodemon",DIFFICULTY-1) --0/1/2/3/4 cacodemons
end

function arena.OnKill()
--randomized cheers from the crowd
local temp = math.random(3)
if temp == 1 then ui.msg("The crowds go wild! \"BLOOD! BLOOD!\"")
elseif temp == 2 then ui.msg("The crowds cheer! \"Blood! Blood!\"")
else ui.msg("The crowds cheer! \"Kill! Kill!\"") end
end

function arena.OnKillAll()
if Level.result() == 1 then --if first wave completes
--more talk
ui.msg("The voice booms, \"Not bad mortal! For a weakling that you ")
ui.msg("are, you show some determination.\"");
ui.msg("You hear screams everywhere! \"More Blood! More BLOOD!\"")
ui.msg("The voice continues, \"I can now let you go free, or")
ui.msg("you may try to complete the challenge!\"");

--player can choose to continue
local choice = ui.msg_confirm("\"Do you want to continue the fight?\"")
if choice then --player chose to continue
core.play_music("rounds_of_hell_part_2") --second verse better than first
player:play_sound("two")
ui.msg("The voice booms, \"I like it! Let the show go on!\"")
ui.msg("You hear screams everywhere! \"More Blood! More BLOOD!\"")

Level.drop("chaingun") --sweet drop
Level.summon("demon",3) --3 demons
Level.summon("cacodemon",DIFFICULTY) --1/2/3/4/5 cacodemons
--player chose to stop
else
ui.msg("The voice booms, \"Coward!\" ")
ui.msg("You hear screams everywhere! \"Coward! Coward! COWARD!\"")
end

elseif Level.result() == 2 then --if second wave completes
--even more talk
ui.msg("The voice booms, \"Impressive mortal! Your determination")
ui.msg("to survive makes me excited!\"")
ui.msg("You hear screams everywhere! \"More Blood! More BLOOD!\"")
ui.msg("\"I can let you go now, and give you a small reward, or")
ui.msg("you can choose to fight the final challenge!\"")

--player can choose to continue
local choice = ui.msg_confirm("\"Do you want to continue the fight?\"")
if choice then --player chosen to continue
core.play_music("rounds_of_hell_part_3") --strongest music yet
player:play_sound("three")
ui.msg("The voice booms, \"Excellent! May the fight begin!!!\"")
ui.msg("You hear screams everywhere! \"Kill, Kill, KILL!\"")

--some more sweet loot
Level.drop("shell",4)
Level.drop("ammo",4)
--spawns are a little more difficulty-dependent
if DIFFICULTY <= 2 then --ITYTD and HNTR
Level.summon("cacodemon",DIFFICULTY+1)
elseif DIFFICULTY == 3 then --HMP
Level.summon("knight",2)
elseif DIFFICULTY >= 4 then --UV and N!
Level.summon("baron",2)
end
else --player chose to stop
ui.msg("The voice booms, \"Too bad, you won't make it far then...!\" ")
ui.msg("You hear screams everywhere! \"Boooo...\"")

--pointless loot
Level.drop("shell",3)
Level.drop("lmed")
Level.drop("smed")
end

elseif Level.result() == 3 then --if third wave completes
--finally done talking
ui.msg("The voice booms, \"Congratulations mortal! A pity you came to")
ui.msg("destroy us, for you would make a formidable hell warrior!\"")
ui.msg("\"I grant you the title of Hell's Arena Champion!\"")
ui.msg("\"And a promise is a promise... search the arena again...\"")

--also pointless loot
Level.drop("scglobe")
Level.drop("barmor")
Level.drop("lmed")
end

--increment level counter each time a wave completes
Level.result(Level.result()+1)
end

function arena.OnExit()
ui.msg_enter("The voice laughs, \"Flee mortal, flee! There's no hiding in hell!\"")

--takes care of mortem text for "killed by something unknown..."
if Level.result() < 4
then arena.result = "fled alive the trials at wave "..Level.result()
else arena.result = "completed the trials"
end
end

function arena.OnMortem()
local kill = player.killedby --calls kill descriptions from beings
if arena.result then kill = arena.result end
player:mortem_print( " "..player.name..", level "..player.explevel.." "
.." "..klasses[player.klass].name..", "..kill )
--e.g., "Cool Guy, level 1 Marine, fled alive the trials at wave 3"
player:mortem_print(" in the Hell Arena...")
end

function arena.run()
Level.name = "Hell Arena" --that IS what it's called
Level.name_number = 0 --remove floor #
Level.fill("rwall") --immortal border tiles
local translation = {
['.'] = "floor", --gray floor
[','] = "blood", --red floor (blood)
['#'] = "rwall", --red wall (bloodstone)
['>'] = "stairs" --gray (normal) stairs
}

--create map cell string (76x18)
local map = [[
#######################.............................########################
###########.....................................................############
#####..................................................................#####
##........................................................................##
#..........................................................................#
............................................................................
..................................,,,,,,....................................
..,,,.............................,,,,,,,...................................
..,>,............................,,,,,,,,,..................................
..,,,............................,,,,,,,,...................................
..................................,,,,,,....................................
............................................................................
............................................................................
#..........................................................................#
##........................................................................##
#####..................................................................#####
###########.....................................................############
#######################.............................########################
]]
--create pillar cell string (6x5)
local column = [[
,..,.,
,####.
.####,
.####.
,..,.,
]]

--puts map in non-border area
Level.place_tile( translation, map, 2, 2 )
--adds random pillars and blood
Level.scatter_put( area.new(5,3,68,15), translation, column, "floor",9+math.random(8))
Level.scatter( area.FULL_SHRINKED,"floor","blood",100)
--all walls become indestructible
Generator.set_permanence(area.FULL)
--inserts player
Level.player(38,10)
end
</source>

Modding:Tutorial/Recreating Hell's Arena

2012-04-08T16:52:23Z

Game Hunter: revised for 0996

Modding:Tutorial/The Infinite Arena

2012-04-08T16:49:57Z

Game Hunter: /* Review */ new link

(NOTE: if you are unfamiliar with the general structure of the Hell's Arena module, it is suggested that you [[Modding:Tutorial/Recreating_Hell's_Arena|read the tutorial]] before proceeding, as many of the topics found there also are here, and will only be touched upon in this tutorial.)

[[Hell's Arena]] is a fun little level, as it can be fairly difficult to complete without some grasp on DoomRL's mechanics, but pillar and monster placement aside, it is still a fairly static map. The following tutorial is a generalized version of Hell's Arena, coined the Infinite Arena, which has been reconstructed based on [[User:Yaflhdztioxo|yaflhdztioxo's]] design from v0.9.9.1. A fair number of seemingly-superfluous tools have also been created as a means to provide easy customization possibilities for those who want to quickly change the settings of the Arena. If nothing else, you will discover a variety of helper tools in this tutorial that may prove to be useful in your own modules.

==Special Concept: Custom Tables and Functions==
The basics of tables have already been explained in the [[Modding:Tutorial/Game Objects|Game Objects]] tutorial: it was also explained there that building your own tables is generally unnecessary. There are, however, plenty of reasons to make tables for your own purposes:

*You want the game to randomly choose from a group of variables
*You want to perform calculations or subroutines on many objects simultaneously
*You are creating an object map that other functions may require (e.g., translation table for .run() )
*You want to store a number of variables in an organized manner in order to access them easily

There are two kinds of tables. The first kind are what are more commonly referred to as tables, as they contain keys and values in each of their fields:

<source lang="lua">
local some_table = {
key1 = "value1",
key2 = "value2",
....
}
</source>

In fact, these tables can contain more tables, like so:

<source lang="lua">
local big_table = {
small_table1 = {
key1 = "value1",
key2 = "value2",
},
small_table2 = {
key1 = "value3",
key3 = "value4",
},
}
</source>

Note that these sub-tables do not have to carry the same information, although you may want them to (depending on the table's purpose). In doing so, you can create very large and intricate tables to suit your needs.

The second kind of table is commonly known in the modding community as an array, and is essentially a table that does not explicitly write keys in each field. The following examples show an array, followed by a table that imitates the functionality of an array:

<source lang="lua">
local some_array = {"value1","value2","value3"}

local some_imit_table = {
[1] = "value1",
[2] = "value2",
[3] = "value3",
}

local big_array = {
{"value1","value2","value3"},
{"value4","value5","value6"},
}

local big_imit_table = {
[1] = {
[1] = "value1",
[2] = "value2",
[3] = "value3",
},
[2] = {
[1] = "value4",
[2] = "value5",
[3] = "value6",
},
}
</source>

As you can see, the array format is a lot more compact, but it also forces very specific keys on each field (namely numerical ones). Naturally, tables and arrays can be combined seamlessly, such that you can have a table of arrays or an array or tables (as well as more complicated setups).

When you want to call various parts within a table or array, you can use the following syntax (we will base these on ''big_array'' and ''big_table''):

<source lang="lua">
big_table.small_table1 --returns the contents of small_table1
big_table[small_table1] --identical to above

big_table.small_table1.key1 --returns "value1"
big_table.small_table1[key1] --identical to above
big_table[small_table1].key1 --identical to above
big_table[small_table1][key1] --identical to above

big_array.1 --returns the contents of the first array in big_array
big_array[1] --identical to above

big_array.2.2 --returns "value5"
big_array.2[2] --identical to above
big_array[2].2 --identical to above
big_array[2][2] --identical to above
</source>

As a matter of convention, we will write table-like extensions using the dot syntax and array-like extensions using the bracket syntax. (This is typically how other languages write their arrays and tables, and it is often a good idea to organize your code in such a manner so that it is easier to read when looking back at it.)

Functions, like tables, are mostly known based on using parts of pre-defined object classes: in the case of functions, we should already be fairly familiar with their capabilities when calling engine hooks and API methods. The creation of a function is very simple, nearly identical to engine hooks.

<source lang="lua">
local function sum_diff(arg1,arg2)
val1 = arg1+arg2
val2 = arg1-arg2
return(val1,val2)
end

local add_diff = function(arg1,arg2) --this line is identical to the first line of the above function
....
end
</source>

*First you must give the function a name: the above example is called '''sum_diff()'''.
*Next you must supply input arguments, if any. These are variables that can be used within the function, which is otherwise self-contained. That is to say, a function can't use any variables from anywhere else in your lua script unless they are given through the input arguments. The above example takes in two arguments, generically named ''arg1'' and ''arg2''.
*From here we add the script that is to be run when the function is called (this is usually what you concern yourself with when working with the engine hooks). In the above example, the sum of ''arg1'' and ''arg2'' is assigned to ''val1'', and their difference is assigned to ''val2''.
*Finally, we consider what the function should output. This can be accomplished in two ways when modding:
**You can simply provide outputs to the function using the return() core method. This immediately stops the function and sends outputs to the line that called the function. In the above example, ''val1'' and ''val2'' are returned. (Note that, when called, the script should contain some variables so that the return values are properly assigned.)
**You can manipulate objects. Since changing objects (such as their prototype) modify things on the engine side of the game, this can be done without having any particular outputs to the function. Even though the function is self-contained within your script, it can influence things not belonging to the script.

If you want to call a function, use its name with the appropriate input and outputs. For the above example, you could call the function in the following way:

<source lang="lua">
local num1 = 5
local num2 = 4

local sum,diff = sum_diff(num1,num2)
</source>

The ''sum'' variable will have a value of 9, and the ''diff'' variable will have a value of 1.

In the Infinite Arena module, a large portion of the code is dedicated to constructing easy-to-read and well-organized tables, as well as functions that make use of them. The tables and functions will eventually be called in the engine hooks, which leaves us with a relatively small amount of run-time code to sift through. Ideally, modules should have a format in which much of the script is written not as a part of the core module, but as something that the core module will refer to.

==Initialization Code==

===Variables===

====mobGenStats====
<source lang="lua">
--customize min_lev/max_lev/weight of each enemy (defaults given)
--for names of beings, check Object IDs in the modding documentation
--be aware that JC auto-ends the game unless modified directly
local mobGenStats = {
{ being = "former", min_lev = 0, max_lev = 12, weight = 10 },
{ being = "sergeant", min_lev = 2, max_lev = 15, weight = 10 },
{ being = "captain", min_lev = 8, max_lev = 15, weight = 10 },
....
}
</source>

''mobGenStats'' is an array of tables: each table contains four fields relating to the being prototype. In each case, a being's identifier ''being'' is given, followed by a ''min_lev'', ''max_lev'', and ''weight'' (all generation parameters). The purpose of ''mobGenStats'' is to switch particular values for others in the being prototypes that already exist. Normally this can be done for a particular enemy with the following line:

<source lang="lua">
beings.former.weight = 0
</source>

This would change the ''weight'' key in the ''former'' table of the ''beings'' array (which holds all being prototypes) to zero, thereby removing the possibility of former humans appearing through standard generation procedures. However, if a modder wants to change many parameters at once, they can use what is done in the Infinite Arena. First is the creation of the above table, and then you use the table in a for loop as follows:

<source lang="lua">
--changes the generation stats of enemies based on mobGenStats
for _,v in ipairs(mobGenStats) do
beings[v.being].min_lev = v.min_lev
beings[v.being].max_lev = v.max_lev
beings[v.being].weight = v.weight
end
</source>

The conditional statement 'for a,b in ipairs(array)' breaks down in the following way:
*''a'' is the iterator of the for loop itself (whenever the code repeats, ''a'' increases by one)
**As we have no need for a basic iterator, we leave it blank using an underscore.
*''b'' is the array iterator (directly calls the particular array, similarly increments)
*in '''ipairs()''' tells the for loop to iterate through values in an array
*''array'' is the array in question

In this particular case, the loop iterates through each array and sets the being's ''min_lev'', ''max_lev'', and ''weight'' (as found in the being prototype) to the values as determined by ''mobGenStats''. ''v.being'' is the same as a being's identifier from ''mobGenStats'', which is how the loop iterates through all being prototypes. In this way all of the beings in the prototype array can be changed quickly without a bunch of lines specifying each key and value.

<source lang="lua">
--enemy scaling for each wave: note that game difficulty will modify scaling independently
local mob_scale_factor = 0.5
</source>

Finally, we have a variable that indicates the initial scaling of enemies. For the Infinite Arena, using the base game's scaling is probably too difficult for what a player at a given difficulty would expect, so it is cut in half by default.

====itemGenStats====
<source lang="lua">
--customize level/weight of items (defaults given)
--for names of items, check Object IDs in the modding documentation
local itemGenStats = {
--Commons

--weapons
{ item = "knife", level = 1, weight = 640 },
{ item = "pistol", level = 1, weight = 70 },
{ item = "shotgun", level = 2, weight = 180 },
....
--ammo/ammo packs
....
--armor/boots
....
--consumables
....
--powerups
....
--Exotics
....
--Uniques
....
}
</source>

''itemGenStats'' is just like ''mobGenStats'', except that it is an array of tables regarding generation parameters for items. Note that ''mobGenStats'' and ''itemGenStats'' in the source set all of the monsters and items to their default settings, so there will be no difference between the generation in the base game and in the Infinite Arena unless the modder chooses to customize it personally. (''mobGenStats'' and ''itemGenStats'' are also shortened here: see Review for the full arrays.)

<source lang="lua">
--changes the generation stats of items based on itemGenStats
for _,v in ipairs(itemGenStats) do
items[v.item].level = v.level
items[v.item].weight = v.weight
end
</source>

As with ''mobGenStats'', a for loop is used to run through all of the variables in the ''itemGenStats'' tables and change the prototypes to anything that the modder wishes to customize.

<source lang="lua">
--item scaling for each wave
local item_scale_factor = 0.5
</source>

The item scaling is also dropped to scale properly with the drop in monster scaling. (Feel free to change these around for your own amusement, of course.)

====anncrMsg and crowdMsg====

<source lang="lua">
--add your own announcer lines here
local anncrMsg = {
--displays whenever player completes wave
success = {
{
"The voice booms, \"Congratulations mortal!",
"The voice booms, \"Impressive mortal!",
"The voice booms, \"Most impressive.",
"The voice booms, \"You are a formidable warrior!",
},
{
....
},
{
....
}
},
--displays whenever player decides to continue to another wave
choice = {
....
}
}
</source>

''anncrMsg'' is the opposite of the generation variables: it is a table of arrays. There are two arrays within ''anncrMsg'' labeled ''success'' and ''choice'', each of which carry their own groups of variables. ''anncrMsg'' itself is called whenever the announcer displays a message (after the third wave), using either ''success'' (whenever the player completes the wave) or ''choose'' (whenever the player chooses to continue to the next wave). Since each group of strings should be handled separately, they are grouped separately, hence the need for a table of arrays.

In addition, ''anncrMsg.success'' and ''anncrMsg.choose'' are an array of arrays themselves. The reason for this will be explained in '''build_announcerMsg()'''.

<source lang="lua">
--add your own crowd lines here
--displays whenever enemy is killed
local crowdMsg = {
"The crowd goes wild! \"BLOOD! BLOOD!\"",
"The crowd cheers! \"Blood! Blood!\"",
"The crowd cheers! \"Kill! Kill!\"",
"The crowd hisses. \"We came for a REAL fight!\"",
"The crowd boos. \"No skill, no kill!\"",
}
</source>

By contrast, ''crowdMsg'' is a simple array of strings, called whenever a crowd message is necessary. Since the crowd only needs to be called in one case, only one group of strings is initialized, and so a table of arrays is no longer required.

===Functions===

====build_gear()====
<source lang="lua">
--changes player equipment
--add "nil" for any slot that should be empty
--always refreshes all slots: do not use to change only one equipment slot
local function build_gear(weap,prep,body,foot)
player.eq:clear()
if weap then player.eq.weapon = item.new(weap) end --main weapon
if prep then player.eq.prepared = item.new(prep) end --prepared weapon
if body then player.eq.armor = item.new(body) end --body armor
if foot then player.eq.boots = item.new(foot) end --boots
end
</source>

'''build_gear()''' is an example of a "helper function", as it runs a procedure that could easily be reproduced in the run-time code but simplifies the input whenever the code needs to be modified. In this case, the function clears all of the player's equipment and potentially adds a new item in each slot. There are four inputs, each corresponding to a particular slot: if the value in an input argument is not nil, it then adds a new item to that player's equipment slot.

In the run-time code, the player need only change the input variables rather than changing several lines. This may not appear very necessary for '''build_gear()''' but the concept of a helper function can make modifications to code much easier.

====build_pack()====
<source lang="lua">
--changes player inventory
--always refreshes all slots: do not use to change only one equipment slot
local function build_pack(itemPack)
player.inv:clear()
for _,part in ipairs(itemPack) do
if items[part.name].type == ITEMTYPE_AMMO then
--ammo is handled separately, loops for however many stacks are needed
for n=1,math.ceil(part.amt/items[part.name].ammomax) do
local pack = item.new(part.name)
if part.amt < pack.ammomax then
--remainder (or single) stack
pack.ammo = part.amt
else
--filled (and/or multiple) stacks
pack.ammo = pack.ammomax
part.amt = part.amt - pack.ammomax
end
player.inv:add(pack)
end
else
--loops for however many items are needed
for n=1,part.amt do
player.inv:add(part.name)
end
end
end
end
</source>

'''build_pack()''' is another helper function, this time clearing the inventory of the player and adding in new items there. It uses the "in '''ipairs()'''" iteration method to check all variables in an array in the following way:

*if the item's ''type'' is ITEMTYPE_AMMO:
**a new for loop is run, iterating from 1 to ''ammonum''/''ammomax'' for the specific ammo (''ammonum'' currently being how much that the player's inventory receives)
**first, the new ammo stack is created
**if ''ammonum'' is less than the ammo's ''ammomax'':
***set the ammo stack equal to ''ammonum''
**otherwise:
***set the ammo stack equal to ''ammomax''
***subtract ''ammonum'' by ''ammomax''
**finally, add the ammo stack to the player's inventory (and this process repeats as necessary)
*if the item's ''type'' is not ITEMTYPE_AMMO:
**a new for loop is run, iterating as many times as items should be added for the particular item in question
**the item(s) are then added to the player's inventory, one by one

The input requires an array of tables, although the format is rather simple. Here is an example of an input for '''build_pack()''':

<source lang="lua">
local itemPack = {
{name = "chaingun", amt = 1 }
{name = "ammo", amt = 360}
{name = "smed", amt = 5 }
}
</source>

Each table in the array requires only two fields: ''name'', which corresponds to the item's identifier, and ''amt'', which specifies how many of that item should be added. In the case of ammunition, the amount of ammo should be specified instead, as it is handled uniquely in order to produce an ideal number of stacks. The above example would add one chaingun, three 9mm ammo (x100) stacks, one 9mm ammo (x60) stack, and five small med-packs to the player's inventory. Keep in mind that the player can only hold 22 items, and any items added after 22 items have been added to the inventory will be disregarded.

====build_announcerMsg()====
<source lang="lua">
local function build_announcerMsg(MSG)
for _,msgNum in ipairs(MSG) do
ui.msg(table.random_pick(msgNum))
end
end
</source>

The '''build_announcerMsg()''' function iterates through an array and selects a random index from a table within the array. The purpose of this simple function is to loop through a series of arrayed strings from ''anncrMsg'' and randomly pick strings from those arrays. '''build_announcerMsg'''(''anncrMsg.success'') sets up three random messages from each array in its array, and '''build_announcerMsg'''(''anncrMsg.choose'') sets up two random messages from each array in its array. (Setting up a lot of tables within tables can be confusing, but it becomes relatively simple as a means to organize variables together when compared to keeping track of each variable separately.)

====get_corpses() and clear_corpses()====
<source lang="lua">
--initializes table of cells that only contains corpses
local corpseCells = {}

local function get_corpses()
for i = 1, #cells do
if cells[i] and cells[i].flags then
if cells[i].flag_set[CF_CORPSE] == true then
table.insert(corpseCells, i) --i == sID's numeric value
end
end
end
end
</source>

'''get_corpses()''' is a quick function that creates a table, ''corpseCells'', and loops through all cells in the cell prototype array, selecting only those that contain the CF_CORPSE flag (indicating that the cell acts like a corpse) and adding it to ''corpseCells''. This method is often the most effective way to create a selective table of objects.

<source lang="lua">
--removes corpses and blood-like cells
local function clear_corpses()
--fade away all blood
Generator.transmute("blood", "floor")
Generator.transmute("bloodpool", "blood")
--changes corpses to blood
for i = 1, #corpseCells do
Generator.transmute(corpseCells[i], "bloodpool")
end
end
</source>

'''clear_corpses()'' puts our table of corpses to use by transmuting any cells contained in the table into the "bloodpool" cell. Additionally, all blood pools are changed to "blood" and all blood is changed to "floor". This is added to the Infinite Arena so that a ridiculous number of corpses isn't around when Arch-vile enemies begin to show themselves.

==Engine Hooks==

===.run()===
<source lang="lua">
--Creation of Infinite Arena
function inf_arena.run()
Level.name = "Infinite Arena"
Level.name_number = 0
Level.fill("rwall")
Generator.set_permanence(area.FULL)

local translation = {
["."] = "floor",
["#"] = {"rwall", LFPERMANENT = true},
["X"] = "rwall",
[","] = "blood",
[">"] = "stairs",
}

local map = [[
#######################.............................########################
###########.....................................................############
#####..................................................................#####
##........................................................................##
#..........................................................................#
....,.......................................................................
.................................,...,......................................
.,.....................................,....................................
..,>.,..........................,...........................................
.,..,.................................,.,...................................
................................,..,...,....................................
............................................................................
............................................................................
#..........................................................................#
##........................................................................##
#####..................................................................#####
###########.....................................................############
#######################.............................########################
]]
--change up the column types
local column = {
[[
,..,.,
,XXXX.
.X##X,
.XXXX.
,..,.,
]],
[[
,..,.,
,X##X.
.####,
.X##X.
,..,.,
]],
[[
,..,.,
,####.
.####,
.####.
,..,.,
]]
}

Level.place_tile(translation,map,2,2)
for i=1,11 + math.random(4) do
Level.scatter_put( area.new(5,3,68,15), translation, table.random_pick(column), "floor", 1)
end
Level.scatter(area.FULL_SHRINKED, "floor", "blood", 100)
Level.player(38, 10)
end
</source>

The '''run()''' hook is very similar to that of the Hell's Arena one. In fact, other than the name change, the only real difference is that the ''column'' string has now been expanded to an array of strings, corresponding to an array of pillars. In order to randomly select pillars, '''Level.scatter_put()''' must be iterated a number of times, adding only one pillar each time: then, by adding the '''table.random_pick()''' method to the tiles-to-be-added argument, it randomly selects one of the pillars in the ''column'' array. The result is that the columns randomly have varying degrees of destructibility.

===.OnEnter()===
<source lang="lua">
function inf_arena.OnEnter()
--inventory table used for build_pack()
local itemPack = {
{name = "smed", amt = 2},
{name = "shell", amt = 50},
}
--set up starting eq/inv
build_gear("shotgun","pistol",nil,nil)
build_pack(itemPack)

--Print announcer messages
ui.msg("A devilish voice announces: \"Welcome to Hell's Arena, mortal! " ..
"\"You are either very brave or very foolish. Either way I like it! " ..
"\"And so do the crowds!\" Suddenly you hear screams everywhere! " ..
"\"Blood! Blood! BLOOD!\" \"Kill all enemies and I shall reward thee!\"")

--spawn first wave
Level.flood_monsters(Generator.being_weight()*mob_scale_factor)
Level.result(1)
end
</source>

'''OnEnter()''' makes significant use of the helper functions, using '''build_gear()''' and '''build_pack()''' to initialize the player's starting equipment and inventory. Besides the itemPack array, this only takes two lines of code, producing a much cleaner and more organized routine than in the original Hell's Arena.

In addition, rather than directly spawning enemies using the '''Level.summon()''' method, we imitate the base game's generation code by combining '''Generator.being_weight()''', which outputs the danger level for a given map level, and '''Level.flood_monsters()''', which randomly drops enemies on the level for a given danger level. Additionally, the ''mob_scale_factor'' variable is used to change the danger level, thereby changing the scaling of the first wave.

===.OnKill()===
<source lang="lua">
function inf_arena.OnKill(being)
--random message from crowdMsg array
ui.msg(table.random_pick(crowdMsg))
end
</source>

'''OnKill()''' does exactly the same thing as the one from Hell's Arena, except that the crowd messages have been tabulated and '''table.random_pick()''' is used to choose from one of said messages. Technically, '''build_announcerMsg()''' would also work here, but since both would only require one line of code, it may as well be the simplest one to understand.

===.OnKillAll()===
<source lang="lua">
function inf_arena.OnKillAll()
--print more announcer stuff
if Level.result() == 1 then
ui.msg("The voice booms, \"Not bad mortal! For a weakling that you are, " ..
"you show some determination.\" You hear screams everywhere! " ..
"\"More Blood! More BLOOD!\" The voice continues, \"I can now " ..
"let you go free, or you may try to complete the challenge!\"")
elseif Level.result() == 2 then
ui.msg("The voice booms, \"Impressive mortal! Your determination to " ..
"survive makes me excited!\" You hear screams everywhere! " ..
"\"More Blood! More BLOOD!\" \"I can let you go now, and give you " ..
"a small reward, or you can choose to fight an additional challenge!\"")
else
--random message from anncrMsg.success array
build_announcerMsg(anncrMsg.success)
end
....
</source>
'''OnKillAll()''' has received some simplifications similar to '''OnEnter'''. To start, after the first two waves, rather than dealing with an large number of random messages here, all of it is called from the previous ''anncrMsg'' table and the '''build_announcerMsg()''' function, which randomly picks a string from an array strings, then iterates through the entire array of arrays. In the displayed run-time code, this amounts of a single line (although it is actually running quite a few lines).

<source lang="lua">
....
local choice = ui.msg_confirm("Round " .. Level.result() + 1 .. " awaits. " ..
"Do you want to continue the fight?")
if choice == true then --continuing
--random message from anncrMsg.choice array
build_announcerMsg(anncrMsg.choice)
--set up the danger level for the next wave
Level.result(Level.result() + 1);
Level.danger_level = Level.result();
--spawn items for next wave
Level.flood_items(Generator.item_amount()*item_scale_factor)
--spawn enemies for next wave
Level.flood_monsters(Generator.being_weight()*mob_scale_factor)
....
</source>

Upon choosing to continue, we use '''build_announcerMsg()''' for more messages (again, only a single line of code). Then, we increment the level by one and increase the ''danger_level'' using the amount from '''Level.result()'''. (''Level.danger_level'' is actually a property of the level object.) Finally, we use the increased danger level to add items and monsters. '''Level.flood_items(Generator.item_amount())''' is the item equivalent of '''Level.flood_monsters(Generator.being_weight())'''.

<source lang="lua">
else --quitting
if Level.result() == 1 then
ui.msg("The voice booms, \"Coward!\" You hear screams everywhere! " ..
"\"Coward! Coward! COWARD!\"")
elseif Level.result() == 2 then
ui.msg("The voice booms, \"Too bad, you won't make it far then...!\" " ..
"You hear screams everywhere! \"Boooo...\"")
elseif Level.result() < 10 then
ui.msg("The voice booms, \"An impressive run, Mortal! We appreciate " ..
"it!\" The crowd starts to chant! \"Encore! Encore!\"")
else
ui.msg("\"Ladies and gentlemen, your champion, "
.. Player.get_name() .. ". He survived " .. Level.result() ..
" rounds in our arena! That has to be some sort of record. " ..
"Give him a hand folks!\" The crowd starts to chant your name " ..
"and they begin throwing items into the ring!")
Level.flood_items(Generator.item_weight())
end
end
end
</source>
Upon choosing not to continue, the announcer displays a variety of messages, although they are few enough (and specific enough) not to create another array for them. (They CAN be tabulated, but it is less bulky than for the other cases.) If the player survived at least ten waves before stopping, the crowd "throws items onto the stage" and you get some pointless gear when you're done, just as before.

===.OnExit()===
<source lang="lua">
function inf_arena.OnExit()
if Level.result() < 10 then
ui.msg("The voice laughs, \"Flee mortal, flee! There's no hiding in hell!\"")
else
ui.msg("The voice laughs, \"Remember to come back once you return to Hell " ..
"for the extended stay\"")
end
--used in .OnMortem()
inf_arena.result = "had enough of the gauntlet at wave "..Level.result()
end
</source>

'''OnExit()''' has only gained a cosmetic change in the case where the player survived more than ten waves before retreating.

===.OnMortem()===
<source lang="lua">
function inf_arena.OnMortem()
local kill = player.killedby --calls kill descriptions from beings
if inf_arena.result then kill = inf_arena.result end
player:mortem_print( " "..player.name..", level "..player.explevel.." "
.." "..klasses[player.klass].name..", "..kill )
--e.g., "Cool Guy, level 1 Marine, had enough of the gauntlet at wave 8"
player:mortem_print(" in the Infinite Arena...")
end
</source>

As with '''OnExit()''', '''OnMortem()''' only changes some of the text in the mortem depending on how the player ends the game.

==Review==
The following is the entire source code for the Infinite Arena.
{{:Modding:Tutorial/The_Infinite_Arena/Source}}

Source data: [http://dl.dropbox.com/u/54818507/inf_arena.module.zip inf_arena.module]

Modding:Tutorial/The Infinite Arena/Source

2012-04-08T16:48:38Z

Game Hunter: forgot source tags

<source lang="lua">
core.declare("inf_arena", {} )

--enemy scaling for each wave: note that game difficulty will modify scaling independently
local mob_scale_factor = 0.5
--customize min_lev/max_lev/weight of each enemy (defaults given)
--for names of beings, check Object IDs in the modding documentation
--be aware that JC auto-ends the game unless modified directly
local mobGenStats = {
{ being = "former", min_lev = 0, max_lev = 12, weight = 10 },
{ being = "sergeant", min_lev = 2, max_lev = 15, weight = 10 },
{ being = "captain", min_lev = 8, max_lev = 15, weight = 10 },
{ being = "imp", min_lev = 0, max_lev = 17, weight = 8 },
{ being = "demon", min_lev = 4, max_lev = 20, weight = 6 },
{ being = "lostsoul", min_lev = 6, max_lev = 16, weight = 10 },
{ being = "knight", min_lev = 9, max_lev = 15, weight = 6 },
{ being = "cacodemon", min_lev = 10, max_lev = 50, weight = 6 },
{ being = "commando", min_lev = 12, max_lev = 17, weight = 6 },
{ being = "pain", min_lev = 12, max_lev = 17, weight = 2 },
{ being = "baron", min_lev = 12, max_lev = 200, weight = 6 },
{ being = "arachno", min_lev = 13, max_lev = 50, weight = 4 },
{ being = "revenant", min_lev = 13, max_lev = 200, weight = 5 },
{ being = "mancubus", min_lev = 15, max_lev = 200, weight = 7 },
{ being = "arch", min_lev = 16, max_lev = 200, weight = 4 },
{ being = "nimp", min_lev = 30, max_lev = 60, weight = 8 },
{ being = "ndemon", min_lev = 40, max_lev = 200, weight = 6 },
{ being = "ncacodemon", min_lev = 51, max_lev = 200, weight = 6 },
{ being = "narachno", min_lev = 50, max_lev = 200, weight = 5 },
{ being = "narch", min_lev = 90, max_lev = 200, weight = 3 },
{ being = "bruiser", min_lev = 50, max_lev = 200, weight = 6 },
{ being = "lava_elemental", min_lev = 70, max_lev = 200, weight = 1 },
{ being = "shambler", min_lev = 80, max_lev = 200, weight = 3 },
{ being = "agony", min_lev = 80, max_lev = 200, weight = 1 },
{ being = "cyberdemon", min_lev = 80, max_lev = 200, weight = 1 },
{ being = "arenamaster", min_lev = 0, max_lev = 0, weight = 0 },
{ being = "angel", min_lev = 0, max_lev = 0, weight = 0 },
{ being = "jc", min_lev = 0, max_lev = 0, weight = 0 },
}

--item scaling for each wave
local item_scale_factor = 0.5
--customize level/weight of items (defaults given)
--for names of items, check Object IDs in the modding documentation
local itemGenStats = {
--Commons

--weapons
{ item = "knife", level = 1, weight = 640 },
{ item = "pistol", level = 1, weight = 70 },
{ item = "shotgun", level = 2, weight = 180 },
{ item = "ashotgun", level = 2, weight = 160 },
{ item = "dshotgun", level = 4, weight = 100 },
{ item = "chaingun", level = 5, weight = 200 },
{ item = "bazooka", level = 7, weight = 200 },
{ item = "plasma", level = 12, weight = 70 },
--ammo/ammo packs
{ item = "ammo", level = 1, weight = 500 },
{ item = "pammo", level = 3, weight = 700 },
{ item = "shell", level = 2, weight = 400 },
{ item = "pshell", level = 4, weight = 200 },
{ item = "rocket", level = 5, weight = 60 },
{ item = "procket", level = 7, weight = 60 },
{ item = "cell", level = 8, weight = 36 },
{ item = "pcell", level = 10, weight = 18 },
--armor/boots
{ item = "garmor", level = 1, weight = 400 },
{ item = "barmor", level = 4, weight = 240 },
{ item = "rarmor", level = 7, weight = 150 },
{ item = "sboots", level = 4, weight = 240 },
{ item = "pboots", level = 7, weight = 150 },
{ item = "psboots", level = 11, weight = 80 },
--consumables
{ item = "smed", level = 1, weight = 600 },
{ item = "lmed", level = 5, weight = 400 },
{ item = "phase", level = 5, weight = 200 },
{ item = "hphase", level = 7, weight = 100 },
{ item = "epack", level = 5, weight = 100 },
{ item = "nuke", level = 10, weight = 40 },
{ item = "lava_element", level = 23, weight = 0 },
{ item = "mod_power", level = 7, weight = 120 },
{ item = "mod_tech", level = 6, weight = 120 },
{ item = "mod_bulk", level = 6, weight = 120 },
{ item = "mod_agility", level = 5, weight = 120 },
--powerups
{ item = "shglobe", level = 1, weight = 900 },
{ item = "lhglobe", level = 6, weight = 330 },
{ item = "scglobe", level = 4, weight = 150 },
{ item = "bpack", level = 1, weight = 200 },
{ item = "iglobe", level = 7, weight = 200 },
{ item = "msglobe", level = 16, weight = 60 },
{ item = "map", level = 1, weight = 200 },
{ item = "pmap", level = 1, weight = 80 },
{ item = "ashard", level = 5, weight = 700 },
{ item = "backpack", level = 7, weight = 0 },

--Exotics

--weapons
{ item = "chainsaw", level = 12, weight = 3 },
{ item = "ublaster", level = 8, weight = 2 },
{ item = "ucpistol", level = 4, weight = 6 },
{ item = "uashotgun", level = 6, weight = 6 },
{ item = "upshotgun", level = 12, weight = 4 },
{ item = "udshotgun", level = 10, weight = 5 },
{ item = "uminigun", level = 10, weight = 6 },
{ item = "umbazooka", level = 10, weight = 6 },
{ item = "unapalm", level = 10, weight = 6 },
{ item = "ulaser", level = 12, weight = 5 },
{ item = "unplasma", level = 15, weight = 4 },
{ item = "utristar", level = 12, weight = 4 },
{ item = "bfg9000", level = 20, weight = 2 },
{ item = "unbfg9000", level = 22, weight = 2 },
{ item = "utrans", level = 14, weight = 3 },
--armor/boots
{ item = "uoarmor", level = 7, weight = 4 },
{ item = "uparmor", level = 10, weight = 6 },
{ item = "upboots", level = 8, weight = 6 },
{ item = "ugarmor", level = 15, weight = 6 },
{ item = "ugboots", level = 10, weight = 6 },
{ item = "umedarmor", level = 5, weight = 6 },
{ item = "uduelarmor", level = 5, weight = 6 },
{ item = "ubulletarmor", level = 2, weight = 4 },
{ item = "uballisticarmor", level = 2, weight = 5 },
{ item = "ueshieldarmor", level = 5, weight = 3 },
{ item = "uplasmashield", level = 10, weight = 3 },
{ item = "uenergyshield", level = 8, weight = 3 },
{ item = "ubalshield", level = 6, weight = 3 },
{ item = "uacidboots", level = 8, weight = 5 },
--consumables
{ item = "uswpack", level = 5, weight = 10 },
{ item = "ubskull", level = 5, weight = 8 },
{ item = "ufskull", level = 7, weight = 8 },
{ item = "uhskull", level = 9, weight = 8 },
{ item = "umod_firestorm", level = 10, weight = 4 },
{ item = "umod_sniper", level = 10, weight = 4 },
{ item = "umod_nano", level = 10, weight = 4 },
{ item = "umod_onyx", level = 10, weight = 4 },

--Uniques

--weapons
{ item = "ubutcher", level = 1, weight = 2 },
{ item = "spear", level = 16, weight = 0 },
{ item = "uscythe", level = 16, weight = 0 },
{ item = "udragon", level = 16, weight = 1 },
{ item = "utrigun", level = 8, weight = 2 },
{ item = "ujackal", level = 10, weight = 2 },
{ item = "uberetta", level = 6, weight = 3 },
{ item = "usjack", level = 12, weight = 2 },
{ item = "urbazooka", level = 12, weight = 2 },
{ item = "uacid", level = 12, weight = 3 },
{ item = "urailgun", level = 15, weight = 2 },
{ item = "ubfg10k", level = 20, weight = 1 },
--armor/boots
{ item = "umarmor", level = 15, weight = 3 },
{ item = "ucarmor", level = 10, weight = 2 },
{ item = "unarmor", level = 10, weight = 3 },
{ item = "umedparmor", level = 10, weight = 2 },
{ item = "ulavaarmor", level = 12, weight = 2 },
{ item = "uenviroboots", level = 10, weight = 2 },
{ item = "ushieldarmor", level = 10, weight = 2 },
{ item = "uberarmor", level = 10, weight = 1 },
{ item = "aarmor", level = 22, weight = 0 },
--consumables
{ item = "uhwpack", level = 10, weight = 4 },
{ item = "umodstaff", level = 15, weight = 4 },
{ item = "uarenastaff", level = 4, weight = 0 },
}

--changes the generation stats of enemies based on mobGenStats
for _,v in ipairs(mobGenStats) do
beings[v.being].min_lev = v.min_lev
beings[v.being].max_lev = v.max_lev
beings[v.being].weight = v.weight
end

--changes the generation stats of items based on itemGenStats
for _,v in ipairs(itemGenStats) do
items[v.item].level = v.level
items[v.item].weight = v.weight
end

--add your own announcer lines here
local anncrMsg = {
--displays whenever player completes wave
success = {
{
"The voice booms, \"Congratulations mortal!",
"The voice booms, \"Impressive mortal!",
"The voice booms, \"Most impressive.",
"The voice booms, \"You are a formidable warrior!",
},
{
"Each of your triumphs is a work of art!",
"Your ability to survive is incredible!",
"You've given us a great show!",
"You would make a terrific hell warrior!",
},
{
"But can you keep going?\"",
"How much longer can you go?\"",
"Will you fight with us a little more?\"",
"I can let you go now if you like, or...\"",
}
},
--displays whenever player decides to continue to another wave
choice = {
{
"The voice booms, \"I like it! Let the show go on!\"",
"The voice booms, \"Excellent! May the fight begin!!!\"",
},
{
"You hear screams everywhere! \"More Blood! More BLOOD!\"",
"You hear screams everywhere! \"Kill, Kill, KILL!\"",
}
}
}

--add your own crowd lines here
--displays whenever enemy is killed
local crowdMsg = {
"The crowd goes wild! \"BLOOD! BLOOD!\"",
"The crowd cheers! \"Blood! Blood!\"",
"The crowd cheers! \"Kill! Kill!\"",
"The crowd hisses. \"We came for a REAL fight!\"",
"The crowd boos. \"No skill, no kill!\"",
}

local function build_announcerMsg(MSG)
for _,msgNum in ipairs(MSG) do
ui.msg(table.random_pick(msgNum))
end
end

--from Skulltag Arena, credit goes to yaflhdztioxo
--initializes table of cells that contains only corpses
local corpseCells = {}

local function get_corpses()
for i = 1, #cells do
if cells[i] and cells[i].flags then
if cells[i].flag_set[CF_CORPSE] == true then
table.insert(corpseCells, i) --i == sID's numeric value
end
end
end
end

--removes corpses and blood-like cells
local function clear_corpses()
--fade away all blood
Generator.transmute("blood", "floor")
Generator.transmute("bloodpool", "blood")
--changes corpses to blood
for i = 1, #corpseCells do
Generator.transmute(corpseCells[i], "bloodpool")
end
end

--changes player equipment
--add "nil" for any slot that should be empty
--always refreshes all slots: do not use to change only one equipment slot
local function build_gear(weap,prep,body,foot)
player.eq:clear()
if weap then player.eq.weapon = item.new(weap) end --main weapon
if prep then player.eq.prepared = item.new(prep) end --prepared weapon
if body then player.eq.armor = item.new(body) end --body armor
if foot then player.eq.boots = item.new(foot) end --boots
end

--changes player inventory
--always refreshes all slots: do not use to change only one equipment slot
--[[
input is an array of tables with two fields:
-name is the identifier of the item that goes in the inventory
-amt is how many items should be added (or how many units of ammo)
example table (based on default inventory):

local starter_pack = {
{name = "ammo", amt = 24},
{name = "smed", amt = 2},
}
--]]
local function build_pack(itemPack)
player.inv:clear()
for _,part in ipairs(itemPack) do
if items[part.name].type == ITEMTYPE_AMMO then
--ammo is handled separately, loops for however many stacks are needed
for n=1,math.ceil(part.amt/items[part.name].ammomax) do
local pack = item.new(part.name)
if part.amt < pack.ammomax then
--remainder (or single) stack
pack.ammo = part.amt
else
--filled (and/or multiple) stacks
pack.ammo = pack.ammomax
part.amt = part.amt - pack.ammomax
end
player.inv:add(pack)
end
else
--loops for however many items are needed
for n=1,part.amt do
player.inv:add(part.name)
end
end
end
end

function inf_arena.OnEnter()
--inventory table used for build_pack()
local itemPack = {
{name = "smed", amt = 2},
{name = "shell", amt = 50},
}
--set up starting eq/inv
build_gear("shotgun","pistol",nil,nil)
build_pack(itemPack)

--Print announcer messages
ui.msg("A devilish voice announces: \"Welcome to Hell's Arena, mortal! " ..
"\"You are either very brave or very foolish. Either way I like it! " ..
"\"And so do the crowds!\" Suddenly you hear screams everywhere! " ..
"\"Blood! Blood! BLOOD!\" \"Kill all enemies and I shall reward thee!\"")

--spawn first wave
Level.flood_monsters(Generator.being_weight()*mob_scale_factor)
Level.result(1)
end

function inf_arena.OnKill(being)
--random message from crowdMsg array
ui.msg(table.random_pick(crowdMsg))
end

function inf_arena.OnKillAll()
--print more announcer stuff
if Level.result() == 1 then
ui.msg("The voice booms, \"Not bad mortal! For a weakling that you are, " ..
"you show some determination.\" You hear screams everywhere! " ..
"\"More Blood! More BLOOD!\" The voice continues, \"I can now " ..
"let you go free, or you may try to complete the challenge!\"")
elseif Level.result() == 2 then
ui.msg("The voice booms, \"Impressive mortal! Your determination to " ..
"survive makes me excited!\" You hear screams everywhere! " ..
"\"More Blood! More BLOOD!\" \"I can let you go now, and give you " ..
"a small reward, or you can choose to fight an additional challenge!\"")
else
--random message from anncrMsg.success array
build_announcerMsg(anncrMsg.success)
end

local choice = ui.msg_confirm("Round " .. Level.result() + 1 .. " awaits. " ..
"Do you want to continue the fight?")
if choice == true then --continuing
--random message from anncrMsg.choice array
build_announcerMsg(anncrMsg.choice)
--set up the danger level for the next wave
Level.result(Level.result() + 1);
Level.danger_level = Level.result();
--spawn items for next wave
Level.flood_items(Generator.item_amount()*item_scale_factor)
--spawn enemies for next wave
Level.flood_monsters(Generator.being_weight()*mob_scale_factor)

else --quitting
if Level.result() == 1 then
ui.msg("The voice booms, \"Coward!\" You hear screams everywhere! " ..
"\"Coward! Coward! COWARD!\"")
elseif Level.result() == 2 then
ui.msg("The voice booms, \"Too bad, you won't make it far then...!\" " ..
"You hear screams everywhere! \"Boooo...\"")
elseif Level.result() < 10 then
ui.msg("The voice booms, \"An impressive run, Mortal! We appreciate " ..
"it!\" The crowd starts to chant! \"Encore! Encore!\"")
else
ui.msg("\"Ladies and gentlemen, your champion, "
.. Player.get_name() .. ". He survived " .. Level.result() ..
" rounds in our arena! That has to be some sort of record. " ..
"Give him a hand folks!\" The crowd starts to chant your name " ..
"and they begin throwing items into the ring!")
Level.flood_items(Generator.item_weight())
end
end
end

function inf_arena.OnExit()
if Level.result() < 10 then
ui.msg("The voice laughs, \"Flee mortal, flee! There's no hiding in hell!\"")
else
ui.msg("The voice laughs, \"Remember to come back once you return to Hell " ..
"for the extended stay\"")
end
--used in .OnMortem()
inf_arena.result = "had enough of the gauntlet at wave "..Level.result()
end

function inf_arena.OnMortem()
local kill = player.killedby --calls kill descriptions from beings
if inf_arena.result then kill = inf_arena.result end
player:mortem_print( " "..player.name..", level "..player.explevel.." "
.." "..klasses[player.klass].name..", "..kill )
--e.g., "Cool Guy, level 1 Marine, had enough of the gauntlet at wave 8"
player:mortem_print(" in the Infinite Arena...")
end

--Creation of Infinite Arena
function inf_arena.run()
Level.name = "Infinite Arena"
Level.name_number = 0
Level.fill("rwall")

local translation = {
["."] = "floor",
["#"] = {"rwall", LFPERMANENT = true},
["X"] = "rwall",
[","] = "blood",
[">"] = "stairs",
}

local map = [[
#######################.............................########################
###########.....................................................############
#####..................................................................#####
##........................................................................##
#..........................................................................#
....,.......................................................................
.................................,...,......................................
.,.....................................,....................................
..,>.,..........................,...........................................
.,..,.................................,.,...................................
................................,..,...,....................................
............................................................................
............................................................................
#..........................................................................#
##........................................................................##
#####..................................................................#####
###########.....................................................############
#######################.............................########################
]]
--change up the column types
local column = {
[[
,..,.,
,XXXX.
.X##X,
.XXXX.
,..,.,
]],
[[
,..,.,
,X##X.
.####,
.X##X.
,..,.,
]],
[[
,..,.,
,####.
.####,
.####.
,..,.,
]]
}

Level.place_tile(translation,map,2,2)
for i=1,11 + math.random(4) do
Level.scatter_put( area.new(5,3,68,15), translation, table.random_pick(column), "floor", 1)
end
Level.scatter(area.FULL_SHRINKED, "floor", "blood", 100)
Level.player(38, 10)
end
</source>

Modding:Tutorial/The Infinite Arena/Source

2012-04-08T16:48:04Z

Game Hunter: revised for 0996

core.declare("inf_arena", {} )

--enemy scaling for each wave: note that game difficulty will modify scaling independently
local mob_scale_factor = 0.5
--customize min_lev/max_lev/weight of each enemy (defaults given)
--for names of beings, check Object IDs in the modding documentation
--be aware that JC auto-ends the game unless modified directly
local mobGenStats = {
{ being = "former", min_lev = 0, max_lev = 12, weight = 10 },
{ being = "sergeant", min_lev = 2, max_lev = 15, weight = 10 },
{ being = "captain", min_lev = 8, max_lev = 15, weight = 10 },
{ being = "imp", min_lev = 0, max_lev = 17, weight = 8 },
{ being = "demon", min_lev = 4, max_lev = 20, weight = 6 },
{ being = "lostsoul", min_lev = 6, max_lev = 16, weight = 10 },
{ being = "knight", min_lev = 9, max_lev = 15, weight = 6 },
{ being = "cacodemon", min_lev = 10, max_lev = 50, weight = 6 },
{ being = "commando", min_lev = 12, max_lev = 17, weight = 6 },
{ being = "pain", min_lev = 12, max_lev = 17, weight = 2 },
{ being = "baron", min_lev = 12, max_lev = 200, weight = 6 },
{ being = "arachno", min_lev = 13, max_lev = 50, weight = 4 },
{ being = "revenant", min_lev = 13, max_lev = 200, weight = 5 },
{ being = "mancubus", min_lev = 15, max_lev = 200, weight = 7 },
{ being = "arch", min_lev = 16, max_lev = 200, weight = 4 },
{ being = "nimp", min_lev = 30, max_lev = 60, weight = 8 },
{ being = "ndemon", min_lev = 40, max_lev = 200, weight = 6 },
{ being = "ncacodemon", min_lev = 51, max_lev = 200, weight = 6 },
{ being = "narachno", min_lev = 50, max_lev = 200, weight = 5 },
{ being = "narch", min_lev = 90, max_lev = 200, weight = 3 },
{ being = "bruiser", min_lev = 50, max_lev = 200, weight = 6 },
{ being = "lava_elemental", min_lev = 70, max_lev = 200, weight = 1 },
{ being = "shambler", min_lev = 80, max_lev = 200, weight = 3 },
{ being = "agony", min_lev = 80, max_lev = 200, weight = 1 },
{ being = "cyberdemon", min_lev = 80, max_lev = 200, weight = 1 },
{ being = "arenamaster", min_lev = 0, max_lev = 0, weight = 0 },
{ being = "angel", min_lev = 0, max_lev = 0, weight = 0 },
{ being = "jc", min_lev = 0, max_lev = 0, weight = 0 },
}

--item scaling for each wave
local item_scale_factor = 0.5
--customize level/weight of items (defaults given)
--for names of items, check Object IDs in the modding documentation
local itemGenStats = {
--Commons

--weapons
{ item = "knife", level = 1, weight = 640 },
{ item = "pistol", level = 1, weight = 70 },
{ item = "shotgun", level = 2, weight = 180 },
{ item = "ashotgun", level = 2, weight = 160 },
{ item = "dshotgun", level = 4, weight = 100 },
{ item = "chaingun", level = 5, weight = 200 },
{ item = "bazooka", level = 7, weight = 200 },
{ item = "plasma", level = 12, weight = 70 },
--ammo/ammo packs
{ item = "ammo", level = 1, weight = 500 },
{ item = "pammo", level = 3, weight = 700 },
{ item = "shell", level = 2, weight = 400 },
{ item = "pshell", level = 4, weight = 200 },
{ item = "rocket", level = 5, weight = 60 },
{ item = "procket", level = 7, weight = 60 },
{ item = "cell", level = 8, weight = 36 },
{ item = "pcell", level = 10, weight = 18 },
--armor/boots
{ item = "garmor", level = 1, weight = 400 },
{ item = "barmor", level = 4, weight = 240 },
{ item = "rarmor", level = 7, weight = 150 },
{ item = "sboots", level = 4, weight = 240 },
{ item = "pboots", level = 7, weight = 150 },
{ item = "psboots", level = 11, weight = 80 },
--consumables
{ item = "smed", level = 1, weight = 600 },
{ item = "lmed", level = 5, weight = 400 },
{ item = "phase", level = 5, weight = 200 },
{ item = "hphase", level = 7, weight = 100 },
{ item = "epack", level = 5, weight = 100 },
{ item = "nuke", level = 10, weight = 40 },
{ item = "lava_element", level = 23, weight = 0 },
{ item = "mod_power", level = 7, weight = 120 },
{ item = "mod_tech", level = 6, weight = 120 },
{ item = "mod_bulk", level = 6, weight = 120 },
{ item = "mod_agility", level = 5, weight = 120 },
--powerups
{ item = "shglobe", level = 1, weight = 900 },
{ item = "lhglobe", level = 6, weight = 330 },
{ item = "scglobe", level = 4, weight = 150 },
{ item = "bpack", level = 1, weight = 200 },
{ item = "iglobe", level = 7, weight = 200 },
{ item = "msglobe", level = 16, weight = 60 },
{ item = "map", level = 1, weight = 200 },
{ item = "pmap", level = 1, weight = 80 },
{ item = "ashard", level = 5, weight = 700 },
{ item = "backpack", level = 7, weight = 0 },

--Exotics

--weapons
{ item = "chainsaw", level = 12, weight = 3 },
{ item = "ublaster", level = 8, weight = 2 },
{ item = "ucpistol", level = 4, weight = 6 },
{ item = "uashotgun", level = 6, weight = 6 },
{ item = "upshotgun", level = 12, weight = 4 },
{ item = "udshotgun", level = 10, weight = 5 },
{ item = "uminigun", level = 10, weight = 6 },
{ item = "umbazooka", level = 10, weight = 6 },
{ item = "unapalm", level = 10, weight = 6 },
{ item = "ulaser", level = 12, weight = 5 },
{ item = "unplasma", level = 15, weight = 4 },
{ item = "utristar", level = 12, weight = 4 },
{ item = "bfg9000", level = 20, weight = 2 },
{ item = "unbfg9000", level = 22, weight = 2 },
{ item = "utrans", level = 14, weight = 3 },
--armor/boots
{ item = "uoarmor", level = 7, weight = 4 },
{ item = "uparmor", level = 10, weight = 6 },
{ item = "upboots", level = 8, weight = 6 },
{ item = "ugarmor", level = 15, weight = 6 },
{ item = "ugboots", level = 10, weight = 6 },
{ item = "umedarmor", level = 5, weight = 6 },
{ item = "uduelarmor", level = 5, weight = 6 },
{ item = "ubulletarmor", level = 2, weight = 4 },
{ item = "uballisticarmor", level = 2, weight = 5 },
{ item = "ueshieldarmor", level = 5, weight = 3 },
{ item = "uplasmashield", level = 10, weight = 3 },
{ item = "uenergyshield", level = 8, weight = 3 },
{ item = "ubalshield", level = 6, weight = 3 },
{ item = "uacidboots", level = 8, weight = 5 },
--consumables
{ item = "uswpack", level = 5, weight = 10 },
{ item = "ubskull", level = 5, weight = 8 },
{ item = "ufskull", level = 7, weight = 8 },
{ item = "uhskull", level = 9, weight = 8 },
{ item = "umod_firestorm", level = 10, weight = 4 },
{ item = "umod_sniper", level = 10, weight = 4 },
{ item = "umod_nano", level = 10, weight = 4 },
{ item = "umod_onyx", level = 10, weight = 4 },

--Uniques

--weapons
{ item = "ubutcher", level = 1, weight = 2 },
{ item = "spear", level = 16, weight = 0 },
{ item = "uscythe", level = 16, weight = 0 },
{ item = "udragon", level = 16, weight = 1 },
{ item = "utrigun", level = 8, weight = 2 },
{ item = "ujackal", level = 10, weight = 2 },
{ item = "uberetta", level = 6, weight = 3 },
{ item = "usjack", level = 12, weight = 2 },
{ item = "urbazooka", level = 12, weight = 2 },
{ item = "uacid", level = 12, weight = 3 },
{ item = "urailgun", level = 15, weight = 2 },
{ item = "ubfg10k", level = 20, weight = 1 },
--armor/boots
{ item = "umarmor", level = 15, weight = 3 },
{ item = "ucarmor", level = 10, weight = 2 },
{ item = "unarmor", level = 10, weight = 3 },
{ item = "umedparmor", level = 10, weight = 2 },
{ item = "ulavaarmor", level = 12, weight = 2 },
{ item = "uenviroboots", level = 10, weight = 2 },
{ item = "ushieldarmor", level = 10, weight = 2 },
{ item = "uberarmor", level = 10, weight = 1 },
{ item = "aarmor", level = 22, weight = 0 },
--consumables
{ item = "uhwpack", level = 10, weight = 4 },
{ item = "umodstaff", level = 15, weight = 4 },
{ item = "uarenastaff", level = 4, weight = 0 },
}

--changes the generation stats of enemies based on mobGenStats
for _,v in ipairs(mobGenStats) do
beings[v.being].min_lev = v.min_lev
beings[v.being].max_lev = v.max_lev
beings[v.being].weight = v.weight
end

--changes the generation stats of items based on itemGenStats
for _,v in ipairs(itemGenStats) do
items[v.item].level = v.level
items[v.item].weight = v.weight
end

--add your own announcer lines here
local anncrMsg = {
--displays whenever player completes wave
success = {
{
"The voice booms, \"Congratulations mortal!",
"The voice booms, \"Impressive mortal!",
"The voice booms, \"Most impressive.",
"The voice booms, \"You are a formidable warrior!",
},
{
"Each of your triumphs is a work of art!",
"Your ability to survive is incredible!",
"You've given us a great show!",
"You would make a terrific hell warrior!",
},
{
"But can you keep going?\"",
"How much longer can you go?\"",
"Will you fight with us a little more?\"",
"I can let you go now if you like, or...\"",
}
},
--displays whenever player decides to continue to another wave
choice = {
{
"The voice booms, \"I like it! Let the show go on!\"",
"The voice booms, \"Excellent! May the fight begin!!!\"",
},
{
"You hear screams everywhere! \"More Blood! More BLOOD!\"",
"You hear screams everywhere! \"Kill, Kill, KILL!\"",
}
}
}

--add your own crowd lines here
--displays whenever enemy is killed
local crowdMsg = {
"The crowd goes wild! \"BLOOD! BLOOD!\"",
"The crowd cheers! \"Blood! Blood!\"",
"The crowd cheers! \"Kill! Kill!\"",
"The crowd hisses. \"We came for a REAL fight!\"",
"The crowd boos. \"No skill, no kill!\"",
}

local function build_announcerMsg(MSG)
for _,msgNum in ipairs(MSG) do
ui.msg(table.random_pick(msgNum))
end
end

--from Skulltag Arena, credit goes to yaflhdztioxo
--initializes table of cells that contains only corpses
local corpseCells = {}

local function get_corpses()
for i = 1, #cells do
if cells[i] and cells[i].flags then
if cells[i].flag_set[CF_CORPSE] == true then
table.insert(corpseCells, i) --i == sID's numeric value
end
end
end
end

--removes corpses and blood-like cells
local function clear_corpses()
--fade away all blood
Generator.transmute("blood", "floor")
Generator.transmute("bloodpool", "blood")
--changes corpses to blood
for i = 1, #corpseCells do
Generator.transmute(corpseCells[i], "bloodpool")
end
end

--changes player equipment
--add "nil" for any slot that should be empty
--always refreshes all slots: do not use to change only one equipment slot
local function build_gear(weap,prep,body,foot)
player.eq:clear()
if weap then player.eq.weapon = item.new(weap) end --main weapon
if prep then player.eq.prepared = item.new(prep) end --prepared weapon
if body then player.eq.armor = item.new(body) end --body armor
if foot then player.eq.boots = item.new(foot) end --boots
end

--changes player inventory
--always refreshes all slots: do not use to change only one equipment slot
--[[
input is an array of tables with two fields:
-name is the identifier of the item that goes in the inventory
-amt is how many items should be added (or how many units of ammo)
example table (based on default inventory):

local starter_pack = {
{name = "ammo", amt = 24},
{name = "smed", amt = 2},
}
--]]
local function build_pack(itemPack)
player.inv:clear()
for _,part in ipairs(itemPack) do
if items[part.name].type == ITEMTYPE_AMMO then
--ammo is handled separately, loops for however many stacks are needed
for n=1,math.ceil(part.amt/items[part.name].ammomax) do
local pack = item.new(part.name)
if part.amt < pack.ammomax then
--remainder (or single) stack
pack.ammo = part.amt
else
--filled (and/or multiple) stacks
pack.ammo = pack.ammomax
part.amt = part.amt - pack.ammomax
end
player.inv:add(pack)
end
else
--loops for however many items are needed
for n=1,part.amt do
player.inv:add(part.name)
end
end
end
end

function inf_arena.OnEnter()
--inventory table used for build_pack()
local itemPack = {
{name = "smed", amt = 2},
{name = "shell", amt = 50},
}
--set up starting eq/inv
build_gear("shotgun","pistol",nil,nil)
build_pack(itemPack)

--Print announcer messages
ui.msg("A devilish voice announces: \"Welcome to Hell's Arena, mortal! " ..
"\"You are either very brave or very foolish. Either way I like it! " ..
"\"And so do the crowds!\" Suddenly you hear screams everywhere! " ..
"\"Blood! Blood! BLOOD!\" \"Kill all enemies and I shall reward thee!\"")

--spawn first wave
Level.flood_monsters(Generator.being_weight()*mob_scale_factor)
Level.result(1)
end

function inf_arena.OnKill(being)
--random message from crowdMsg array
ui.msg(table.random_pick(crowdMsg))
end

function inf_arena.OnKillAll()
--print more announcer stuff
if Level.result() == 1 then
ui.msg("The voice booms, \"Not bad mortal! For a weakling that you are, " ..
"you show some determination.\" You hear screams everywhere! " ..
"\"More Blood! More BLOOD!\" The voice continues, \"I can now " ..
"let you go free, or you may try to complete the challenge!\"")
elseif Level.result() == 2 then
ui.msg("The voice booms, \"Impressive mortal! Your determination to " ..
"survive makes me excited!\" You hear screams everywhere! " ..
"\"More Blood! More BLOOD!\" \"I can let you go now, and give you " ..
"a small reward, or you can choose to fight an additional challenge!\"")
else
--random message from anncrMsg.success array
build_announcerMsg(anncrMsg.success)
end

local choice = ui.msg_confirm("Round " .. Level.result() + 1 .. " awaits. " ..
"Do you want to continue the fight?")
if choice == true then --continuing
--random message from anncrMsg.choice array
build_announcerMsg(anncrMsg.choice)
--set up the danger level for the next wave
Level.result(Level.result() + 1);
Level.danger_level = Level.result();
--spawn items for next wave
Level.flood_items(Generator.item_amount()*item_scale_factor)
--spawn enemies for next wave
Level.flood_monsters(Generator.being_weight()*mob_scale_factor)

else --quitting
if Level.result() == 1 then
ui.msg("The voice booms, \"Coward!\" You hear screams everywhere! " ..
"\"Coward! Coward! COWARD!\"")
elseif Level.result() == 2 then
ui.msg("The voice booms, \"Too bad, you won't make it far then...!\" " ..
"You hear screams everywhere! \"Boooo...\"")
elseif Level.result() < 10 then
ui.msg("The voice booms, \"An impressive run, Mortal! We appreciate " ..
"it!\" The crowd starts to chant! \"Encore! Encore!\"")
else
ui.msg("\"Ladies and gentlemen, your champion, "
.. Player.get_name() .. ". He survived " .. Level.result() ..
" rounds in our arena! That has to be some sort of record. " ..
"Give him a hand folks!\" The crowd starts to chant your name " ..
"and they begin throwing items into the ring!")
Level.flood_items(Generator.item_weight())
end
end
end

function inf_arena.OnExit()
if Level.result() < 10 then
ui.msg("The voice laughs, \"Flee mortal, flee! There's no hiding in hell!\"")
else
ui.msg("The voice laughs, \"Remember to come back once you return to Hell " ..
"for the extended stay\"")
end
--used in .OnMortem()
inf_arena.result = "had enough of the gauntlet at wave "..Level.result()
end

function inf_arena.OnMortem()
local kill = player.killedby --calls kill descriptions from beings
if inf_arena.result then kill = inf_arena.result end
player:mortem_print( " "..player.name..", level "..player.explevel.." "
.." "..klasses[player.klass].name..", "..kill )
--e.g., "Cool Guy, level 1 Marine, had enough of the gauntlet at wave 8"
player:mortem_print(" in the Infinite Arena...")
end

--Creation of Infinite Arena
function inf_arena.run()
Level.name = "Infinite Arena"
Level.name_number = 0
Level.fill("rwall")

local translation = {
["."] = "floor",
["#"] = {"rwall", LFPERMANENT = true},
["X"] = "rwall",
[","] = "blood",
[">"] = "stairs",
}

local map = [[
#######################.............................########################
###########.....................................................############
#####..................................................................#####
##........................................................................##
#..........................................................................#
....,.......................................................................
.................................,...,......................................
.,.....................................,....................................
..,>.,..........................,...........................................
.,..,.................................,.,...................................
................................,..,...,....................................
............................................................................
............................................................................
#..........................................................................#
##........................................................................##
#####..................................................................#####
###########.....................................................############
#######################.............................########################
]]
--change up the column types
local column = {
[[
,..,.,
,XXXX.
.X##X,
.XXXX.
,..,.,
]],
[[
,..,.,
,X##X.
.####,
.X##X.
,..,.,
]],
[[
,..,.,
,####.
.####,
.####.
,..,.,
]]
}

Level.place_tile(translation,map,2,2)
for i=1,11 + math.random(4) do
Level.scatter_put( area.new(5,3,68,15), translation, table.random_pick(column), "floor", 1)
end
Level.scatter(area.FULL_SHRINKED, "floor", "blood", 100)
Level.player(38, 10)
end

Modding:Tutorial/The Infinite Arena

2012-04-08T16:47:36Z

Game Hunter: revised for 0996

Mechanics

2012-03-30T20:21:28Z

Game Hunter: added Resistance to Combat Mechanics

The pages listed here describe what various numbers mean and how the game works behind the scenes.

==Basics==
*[[Distance]]
*[[Time]]
*[[Dice notation]]

==Player Mechanics==
*[[Experience]]
*[[Vision]]
*[[Tactics]]
*[[Effects]]

==Combat Mechanics==
*[[Health]]
*[[Protection]]
*[[Resistance]]
*[[Accuracy]]
*[[Dodging]]
*[[Shotguns]]
*[[Explosions]]
*[[Corpses]]
*[[Knockback]]
*[[Damage type]]
*[[AI]]

Template:Modarg

2012-03-27T17:47:20Z

Game Hunter: fixed missile flag link, added empty flags

<noinclude>
Whenever an input or output argument is required for an API function, one should use <nowiki>{{modarg|arg}}</nowiki> to express it. This also handles cases where links are required. Some examples:
*<nowiki>{{modarg|integer}}</nowiki> → '''integer'''
*<nowiki>{{modarg|Being}}</nowiki> → '''[[Modding:Being|Being]]'''
*<nowiki>{{modarg|CoordList}}</nowiki> → '''[[Modding:Coord|CoordList]]'''
If there are more links required, feel free to add a line to the template.
</noinclude>{{#switch: {{{1}}}
| {{#if: {{#pos:{{{1}}}|Cell Flags}} |{{{1}}} }} = '''[[Modding:Cell#Flags|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Cellset}} |{{{1}}} }} = '''[[Modding:Constants#Cellsets|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Cell}} |{{{1}}} }} = '''[[Modding:Cell|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|ExplosionFlag}}|{{{1}}} }} = '''[[Modding:Constants#ExplosionFlag|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Empty Flag}} |{{{1}}} }} = '''[[Modding:Constants#Empty Flags|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Item Flag}} |{{{1}}} }} = '''[[Modding:Item#Flags|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Level Flag}} |{{{1}}} }} = '''[[Modding:Level#Flags|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|LightFlag}} |{{{1}}} }} = '''[[Modding:Constants#LightFlag|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Missile Flag}} |{{{1}}} }} = '''[[Modding:Missile#Flags|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Flag}} |{{{1}}} }} = '''[[Modding:Constants#Flags|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|ItemType}} |{{{1}}} }} = '''[[Modding:Constants#ItemType|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|ItemSet}} |{{{1}}} }} = '''[[Modding:ItemSet|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Item}} |{{{1}}} }} = '''[[Modding:Item|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Affect}} |{{{1}}} }} = '''[[Modding:Affect|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|AltReload}} |{{{1}}} }} = '''[[Modding:Constants#AltReload|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|AltFire}} |{{{1}}} }} = '''[[Modding:Constants#AltFire|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Area}} |{{{1}}} }} = '''[[Modding:Area|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Badge}} |{{{1}}} }} = '''[[Modding:Badge|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Being}} |{{{1}}} }} = '''[[Modding:Being|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Color}} |{{{1}}} }} = '''[[Modding:Constants#Colors|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Coord}} |{{{1}}} }} = '''[[Modding:Coord|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|DamageType}} |{{{1}}} }} = '''[[Modding:Constants#DamageType|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Klass}} |{{{1}}} }} = '''[[Modding:Klass|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Medal}} |{{{1}}} }} = '''[[Modding:Medal|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Missile}} |{{{1}}} }} = '''[[Modding:Missile|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|ModArray}} |{{{1}}} }} = '''[[Modding:ModArray|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Player}} |{{{1}}} }} = '''[[Modding:Player|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Rank}} |{{{1}}} }} = '''[[Modding:Rank|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Resistance}} |{{{1}}} }} = '''[[Modding:Constants#Resistance|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Room}} |{{{1}}} }} = '''[[Modding:Generator|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|StatusEffect}} |{{{1}}} }} = '''[[Modding:Constants#StatusEffect|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Trait}} |{{{1}}} }} = '''[[Modding:Trait|{{{1}}}]]'''
| {{{1}}}
}}

Modding:Missile

2012-03-27T17:44:40Z

Game Hunter: revised with templates

Missiles are created whenever a [[Modding:Item#Ranged Weapon|ranged weapon]] fires a shot. Some of the effects of the missile (like damage) depend on the weapon that fired it. Most of the missile properties are related to animation, although some have a game effect. Some weapons fire shotgun blasts instead of missiles. Shotgun blasts (called shotguns) are separate objects with their own IDs. A weapon will interpret its missile as a shotgun if it has the IF_SHOTGUN flag.

== Missile Prototype ==
Missile prototypes are declared using the global Missile function. They are stored in a global table called missiles which can be indexed by string or numeric id. Required properties are underlined.

{{drltable|Missile Prototype|3|{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|{{modarg|string}}|id|This is the missile's string id. By convention, it should be all lowercase and shouldn't have any whitespace. (A numeric id called nid is assigned automatically.) For [[Modding:Item#Ranged Weapon|inline missile definitions]], this field is created automatically.
|{{modarg|string}}|soundID|If the missile doesn't have a sound bindings and this field exists, it will be used to look for sound bindings in a different place. Missiles are responsible for the .explode sound binding. By convention, this is the same as the ID of the weapon that fires the missile (if the weapon has a different id to begin with which isn't the case for inline definitions).
|{{modarg|string}}|ascii|This is the single character used to represent the missile animation. "-", the default, is automatically rotated as is commonly seen in DoomRL.
|{{modarg|Color}}|color|This is the color used to draw the missile animation.
|{{modarg|integer}}|delay|This is the number of milliseconds to pause after each stage of the missile animation. Typical values used by DoomRL are in the range of 10 to 50.
|{{modarg|integer}}|miss_base|When this missile is fired at the player, this is the base [[Dodging|dodge chance]].
|{{modarg|integer}}|miss_dist|When this missile is fired at the player, this is the amount that the dodge chance increases per unit of distance.
|{{modarg|string}}|firedesc|If this field is a non-empty string, this message will be used instead of the usual one when an enemy fires this weapon. The @1 escape will be replaced with the enemy's name (with appropriate article and capitalization).
|{{modarg|string}}|hitdesc|If this field is a non-empty string, this message will be used instead of the usual one when an enemy hits with this weapon.
|{{modarg|integer}}|maxrange|This field is currently unused. The default is 10.
|{{modarg|integer}}|range|If this field is non-zero, the player's targeting is restricted by this range when firing a weapon with this missile. Even if this value is large, targeting is still restricted by the player's vision. The default is 0.
|{{modarg|Missile Flag list}}|flags|This flags in this list are included in the missile's flag set. This is automatically translated into set format in a property called flagSet. The default is the empty list.
|{{modarg|integer}}|expl_delay|If this missile causes an explosion (determined by the weapon that fired it), this is the pause in milliseconds after each stage of the explosion animation. The default is 40.
|{{modarg|Color}}|expl_color|This is the color of the explosion animation. Since explosions are mulicolored, not all colors are allowed here. See [[Modding:Level#level_explosion|Level.explosion]] for details. The default is RED.
|{{modarg|ExplosionFlag list}}|expl_flags|This is a list of explosion flags that are applied to explosions created by this missile. This is automatically translated into set format in a property called expl_flagSet. The default is the empty list.
|{{modarg|Cell ID}}|content|If this field is declared, then an explosion will have a chance of transmuting cells into this cell (as described [[Explosions|here]]). This is automatically translated into a numeric id.
|}}
}}

=== Flags ===
{{drltable|Projectile Missile Flags|2|{{Table2Col
|es=background: #333;
|c1=font-family:monospace; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|MF_RAY|This flag changes the missile's animation. The delay is ignored and all cells in the path are drawn with the projectile (as with the [[Shambler|Shambler's]] ranged attack).
|MF_HARD|This flag causes the missile to continue after hitting a being (as with the [[Railgun]]).
|MF_EXACT|This flag causes the missile to stop at the targeted square (as with the [[Revenant's Launcher]]).
|MF_IMMIDATE|This flag causes the missile to always hit the targetted square (although it may still miss a being standing on that square). The missile does not respect line of fire -- it will go through walls (although AI controlled beings using such a missile will still respect line-of-sight). The animation for the missile will only display over the targeted cell. ([[Arch-vile|Arch-viles']] natural weapon uses this flag.)
|}}
}}

== Shotgun Prototype ==
Shotgun prototypes are declared using the global Shotgun function. They are stored in a global table called shotguns which can be indexed by string or numeric ID. Required properties are underlined.

{{drltable|(Missile) Prototype|3|{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|{{modarg|integer}}|id|This is the shotgun's string id. By convention, it should be all lowercase with no spaces. (A numeric id called nid is automatically created.)
|{{modarg|integer}}|range|This is the shotgun's [[Shotguns|range]].
|{{modarg|integer}}|spread|This is the shotgun's [[Shotguns|spread]].
|{{modarg|integer}}|reduce|This is the percentage of the shotgun's damage that decays per unit of distance.
|}}
}}

Modding:UI

2012-03-25T00:15:01Z

Game Hunter: revised with new templates

The UI table provides access to functions that work with the user interface.

== API ==

{{drltable|UI Interface|2|{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|{{modarg|void}} |{{moddef|list|msg|dot||string|message}}
|{{modarg|void}} |{{moddef|list|msg_clear|dot}}
|{{modarg|string}} |{{moddef|list|msg_history|dot||integer|numMessages}}
|{{modarg|void}} |{{moddef|list|msg_enter|dot||string|message}}
|{{modarg|boolean}}|{{moddef|list|msg_confirm|dot||string|message|boolean|warning}}
|{{modarg|string}} |{{moddef|list|msg_choice|dot||string|message|table|choices}}
|{{modarg|void}} |{{moddef|list|blood_slide|dot}}
|{{modarg|void}} |{{moddef|list|blink|dot||Color|color|integer|duration}}
|{{modarg|void}} |{{moddef|list|set_hint|dot||string|hint_text}}
|{{modarg|void}} |{{moddef|list|plot_screen|dot||string|text}}
|}}
}}
----
{{moddef|desc|msg|dot||string|message}}
:Prints ''message'' to the message area at the top of the screen.
----
{{moddef|desc|msg_clear|dot}}
:Adds two blank lines to the message area, clearing it out.
----
{{moddef|desc|msg_history|dot|string|integer|numMessages}}
:Returns the last ''numMessages'' messages from the message list. If 0 is entered, it will return only the most recent message.
----
{{moddef|desc|msg_enter|dot||string|message}}
:Prints ''message'' to the message area at the top of the screen, followed by the text "Press Enter...", and then waits for an Enter press (or click in Graphics mode).
----
{{moddef|desc|msg_confirm|dot|boolean|string|message|boolean|warning}}
:Prints ''message'' to the message area at the top of the screen, followed by "[y/n]", and waits for the user to hit the y or n key. Returns true if the y key was pressed, otherwise returns false. If ''warning'' is true, the confirm response is Shift-Y (similar to quitting and nuking) instead of just y.
----
{{moddef|desc|msg_choice|dot|string|string|message|table|choices}}
:Prints ''message'' to the message area at the top of the screen, followed by the list of possible ''choices'', then waits for the user to make a selection or cancel. ''Choices'' must be a character array (i.e., a table of length 1 strings) which indicates the valid choices. The function returns a string containing the choice selected, or the empty string if they hit ESC instead.
----
{{moddef|desc|blood_slide|dot}}
:Creates the blood slide animation. Doesn't work in 0.9.9.6, but will in older versions.
----
{{moddef|desc|blink|dot||Color|color|integer|duration}}
:Makes the screen flash ''color'' for ''duration'' milliseconds.
----
{{moddef|desc|set_hint|dot||string|hint_text}}
:Displays ''message'' in the hint area, which is right-aligned and under the message area.
----
{{moddef|desc|plot_screen|dot||string|text}}
:Creates a black screen that writes ''text'' one letter at a time, similar to the intro text. ''Text'' can be a multi line string, the newlines will be properly displayed.

Template:Moddef

2012-03-25T00:14:22Z

Game Hunter: added UI

<noinclude>
This is the prototypical template for expressing API functions. It works with the following args:
#Sets the type of expression. Currently there are two cases:
#*<tt>list</tt> is what's used in the table: it automatically comes with the necessary link for the description's anchor.
#*<tt>desc</tt> is what's used underneath the table: this provides the anchor that is linked to the list.
#Sets the function name. For example, if the function is called <tt>Level.place_tile</tt>, then this should be set to <tt>place_tile</tt>.
#Determines the function type. There are two cases:
#*<tt>dot</tt> is the dot form
#*<tt>cln</tt> is the colon form
#Sets the output argument, if any. Leaving this blank should always be done for <tt>list</tt> functions. You can include up to two comma-separated outputs.
#From here, input arguments are set. These are be handled in pairs: the first should be the arg type, while the second should be the arg name. You can include up to eight arg pairs in this manner.
Please note that this template is set up to include information based on the page name, so they can only be used on their appropriate pages. Thus, you can write being API functions using this template for the [[Modding:Being|being]] page, but not for the [[Modding:Coord|coord]] page.

See [[Template:Modarg]] for argument handling.
</noinclude>{{#ifeq:{{{1}}}|desc|{{Anchor|{{lc:{{#sub:{{PAGENAME}}|8|0}}}}_{{{2}}}}}
;}}{{#switch: {{#sub:{{PAGENAME}}|8|0}}
| Coord = {{#switch: {{{3}}} | dot = coord. | cln = '''Coord'''<nowiki>:</nowiki>}}
| Area = {{#switch: {{{3}}} | dot = area. | cln = '''Area'''<nowiki>:</nowiki>}}
| Item = {{#switch: {{{3}}} | dot = item. | cln = '''Item'''<nowiki>:</nowiki>}}
| Being = {{#switch: {{{3}}} | dot = being. | cln = '''Being'''<nowiki>:</nowiki>}}
| UI = {{#switch: {{{3}}} | dot = ui. | cln = '''Being'''<nowiki>:</nowiki>}}
| Player = {{#switch: {{{3}}} | dot = player. | cln = '''Player'''<nowiki>:</nowiki>}}
| Thing = {{#switch: {{{3}}} | dot = thing. | cln = '''Thing'''<nowiki>:</nowiki>}}
| Level = {{#switch: {{{3}}} | dot = Level. | ket = '''Level'''<nowiki>[{{modarg{{{5}}}}}{{{2}}}]</nowiki>}}
| Generator = Generator.
}}{{#switch: {{{1}}}
| list = [[#{{lc:{{#sub:{{PAGENAME}}|8|0}}}}_{{{2}}}|{{{2}}}]]
| desc = {{{2}}}
}}({{#if: {{{5|}}}|{{#if: {{{6|}}} | {{modarg|{{{5}}}}} {{{6}}}}}{{#if:{{{7|}}}|<nowiki>, </nowiki>{{#if: {{{8|}}} |{{modarg|{{{7}}}}} {{{8}}}}}}}{{#if:{{{9|}}}|<nowiki>, </nowiki>{{#if: {{{10|}}} |{{modarg|{{{9}}}}} {{{10}}}}}}}{{#if:{{{11|}}}|<nowiki>, </nowiki>{{#if: {{{12|}}} |{{modarg|{{{11}}}}} {{{12}}}}}}}{{#if:{{{13|}}}|<nowiki>, </nowiki>{{#if: {{{14|}}} |{{modarg|{{{13}}}}} {{{14}}}}}}}{{#if:{{{15|}}}|<nowiki>, </nowiki>{{#if: {{{16|}}} |{{modarg|{{{15}}}}} {{{16}}}}}}}{{#if:{{{17|}}}|<nowiki>, </nowiki>{{#if: {{{18|}}} |{{modarg|{{{17}}}}} {{{18}}}}}}}{{#if:{{{19|}}}|<nowiki>, </nowiki>{{#if: {{{20|}}} |{{modarg|{{{19}}}}} {{{20}}}}}}}{{#if:{{{21|}}}|<nowiki>, </nowiki>{{#if: {{{22|}}} |{{modarg|{{{21}}}}} {{{22}}}}}}}{{#if:{{{23|}}}|<nowiki>, </nowiki>{{#if: {{{24|}}} |{{modarg|{{{23}}}}} {{{24}}}}}}}}}){{#if: {{{4|}}}|<nowiki> </nowiki>→ {{#if: {{#pos:{{{4}}}|,}}|{{modarg|{{#explode:{{{4}}}|,|0}}}},{{modarg|{{#explode:{{{4}}}|,|1}}}}|{{modarg|{{{4}}}}} }} }}

Modding:Statistics

2012-03-24T22:12:39Z

Game Hunter: added real_time_ms, drltable edits

Statistics are not game objects but, rather, a table of values that are accrued throughout the game. Often they are referenced for the purpose of granting [[Modding:Medal|medals]] and [[Modding:Badge|badges]], although they can be accessed at any time.

== Properties ==
Statistics properties can be called using the syntax "''statistics.stat_name''", where stat_name refers to the property names as explained here. All statistics from the core game can be updated simply by calling them, but they are also updated by default: default updates are mentioned in the statistic's description.

In addition, you can create new statistics using the same syntax and assign them values (e.g., "''statictics.stat_name = 0''"). Values assigned to a statistic must always be an integer.

{{drltable|Statistics|2|{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|bonus_levels_count|The total number of special levels that have appeared in the game. It is updated immediately after the game creates the core game episode.
|bonus_levels_visited|The total number of special levels that the player entered. It is updated whenever the player enters a special level.
|bonus_levels_completed|The total number of special levels that the player has completed. It is updated whenever the IsCompleted hook for a level is called, or whenever the number of enemies on that level is equal to zero.
|damage_on_level|The total amount of damage the player has taken on the current level. It is updated whenever the player takes damage, and resets whenever the player exits a level.
|damage_taken|The total amount of damage that the player has taken over the course of a game. It is updated whenever the player takes damage.
|entry_time|The amount of game time (that is, measured by in-game turns) that has passed since the game started. It is updated whenever the player enters a level.
|game_time|The amount of game time that has passed since the game started. It is updated whenever a game ends.
|kills|The number of enemies that have been killed since the game started. It is updated whenever the player exits a level.
|kills_non_damage|The number of enemies that have died while the player has not taken damage. It is tracked (but not necessarily updated) each time an enemy dies.
|levels_nuked|The number of levels that have been successfully nuked. It is updated whenever a nuke explodes, or whenever a player leaves a level that had an active nuke on it.
|levers_pulled|The number of [[lever|levers]] pulled over the course of a game. It is updated whenever a lever is pulled.
|max_kills|The total number of enemies that have appeared since the game started. It is updated upon entering a new level.
|real_time|The amount of real time (that is, measured by a clock) that has passed since the game started. It is updated whenever a game ends.
|real_time_ms|The number of milliseconds that have passed since the game started. It is updated whenever a game ends.
|uniques_found|The total number of [[Specials|uniques]] found over the course of a game. It is updated whenever the player picks up a unique item.
|}}
}}

== API ==
{{drltable|Statistics Interface|2|{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|'''void'''|statistics.[[#statistics_inc|inc]]('''string''' name, '''integer''' value)
|}}
}}

{{Anchor|statistics_inc}}
;statistics.inc('''string''' name, '''integer''' value)
:This increments the statistic ''name'' by ''value''. ''value'' can be positive (increasing the statistic) or negative (decreasing the statistic).

Modding:Coord

2012-03-24T22:06:47Z

Game Hunter: drltable used

Coords (short for coordinates) are used to describe positions on the map. They are also occassionally used to indicate relative positions.

== Properties ==
Although coords are technically userdata, they can be indexed like normal tables.

{{drltable|Coord|3|{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 3px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''Integer'''|x|This is the x-coordinate of the coord. In DoomRL, x increases going from left to right, starting at 1 on the left edge of the map.
|'''Integer'''|y|This is the y-coordinate of the coord. In DoomRL, y increases going from top to bottom, starting at 1 on the upper edge of the map.
|}}
}}

== API ==

{{drltable|Coord Interface|2|{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|[[Modding:Coord|Coord]]|coord.[[#coord_new|new]]('''integer''' x, '''integer''' y)
|[[Modding:Coord|Coord]]|coord.[[#coord_unm|unm]]([[Modding:Coord|Coord]] c)
|[[Modding:Coord|Coord]]|coord.[[#coord_add|add]]([[Modding:Coord|Coord]] lhs, [[Modding:Coord|Coord]] rhs)
|[[Modding:Coord|Coord]]|coord.[[#coord_sub|sub]]([[Modding:Coord|Coord]] lhs, [[Modding:Coord|Coord]] rhs)
|[[Modding:Coord|Coord]]|coord.[[#coord_mul|mul]]([[Modding:Coord|Coord]] or '''integer''' lhs, [[Modding:Coord|Coord]] or '''integer''' rhs)
|'''boolean'''|coord.[[#coord_eq|eq]]([[Modding:Coord|Coord]] lhs, [[Modding:Coord|Coord]], rhs)
|[[Modding:Coord|Coord]]|coord.[[#coord_abs|abs]]([[Modding:Coord|Coord]] c)
|[[Modding:Coord|Coord]]|coord.[[#coord_sign|sign]]([[Modding:Coord|Coord]] c)
|'''integer'''|coord.[[#coord_distance|distance]]([[Modding:Coord|Coord]] c1, [[Modding:Coord|Coord]] c2)
|'''number'''|coord.[[#coord_real_distance|real_distance]]([[Modding:Coord|Coord]] c1, [[Modding:Coord|Coord]] c2)
|[[Modding:Coord|Coord]]|coord.[[#coord_random|random]]([[Modding:Coord|Coord]] c1, [[Modding:Coord|Coord]] c2)
|'''integer''', '''integer'''|[[Modding:Coord|Coord]]:[[#coord_get|get]]()
|'''string'''|[[Modding:Coord|Coord]]:[[#coord_tostring|tostring]]()
|[[Modding:Coord|Coord]]|[[Modding:Coord|Coord]]:[[#coord_clone|clone]]()
|'''void'''|[[Modding:Coord|Coord]]:[[#coord_random_shift|random_shift]]('''integer''' value)
|[[Modding:Coord|Coord]]|[[Modding:Coord|Coord]]:[[#coord_random_shifted|random_shifted]]('''integer''' value)
|[[Modding:Coord|CoordIterator]]|[[Modding:Coord|Coord]]:[[#coord_cross_coords|cross_coords]]()
|[[Modding:Coord|CoordIterator]]|[[Modding:Coord|Coord]]:[[#coord_around_coords|around_coords]]()
|}}
}}

{{Anchor|coord_new}}
;coord.new('''integer''' x, '''integer''' y) → [[Modding:Coord|Coord]]
:This creates a new coord with the given x and y.
----
{{Anchor|coord_unm}}
;coord.unm([[Modding:Coord|Coord]] c) → [[Modding:Coord|Coord]]
;-[[Modding:Coord|Coord]] c → [[Modding:Coord|Coord]]
:This creates a new coord whose coordinates are the inverse (negative) of the original coordinates.
----
{{Anchor|coord_add}}
;coord.add([[Modding:Coord|Coord]] lhs, [[Modding:Coord|Coord]] rhs) → [[Modding:Coord|Coord]]
;[[Modding:Coord|Coord]] lhs + [[Modding:Coord|Coord]] rhs → [[Modding:Coord|Coord]]
:This creates a new coord whose coordinates are the sums of the corresponding coordinates of ''lhs'' and ''rhs''.
----
{{Anchor|coord_sub}}
;coord.sub([[Modding:Coord|Coord]] lhs, [[Modding:Coord|Coord]] rhs) → [[Modding:Coord|Coord]]
;[[Modding:Coord|Coord]] lhs - [[Modding:Coord|Coord]] rhs → [[Modding:Coord|Coord]]
:This creates a new coord whose coordinates are the differences of the corresponding coordinates of ''lhs'' and ''rhs''.
----
{{Anchor|coord_mul}}
;coord.mul([[Modding:Coord|Coord]] or '''integer''' lhs, [[Modding:Coord|Coord]] or '''integer''' rhs) → [[Modding:Coord|Coord]]
;[[Modding:Coord|Coord]] or '''integer''' lhs * [[Modding:Coord|Coord]] or '''integer''' rhs → [[Modding:Coord|Coord]]
:With two coords, this creates a new coord whose coordinates are the products of the corresponding coordinates of ''lhs'' and ''rhs''. With an integer, a new coord is returned with the coordinates of the original coord scaled by the integer. (This doesn't apply to two integers.)
----
{{Anchor|coord_eq}}
;coord.eq([[Modding:Coord|Coord]] lhs, [[Modding:Coord|Coord]], rhs) → '''boolean'''
;[[Modding:Coord|Coord]] lhs == [[Modding:Coord|Coord]] rhs → '''boolean'''
:This determines if the given coords are coordinate-wise equal. (They might still be different objects! Beware using coords as table keys.)
----
{{Anchor|coord_abs}}
;coord.abs([[Modding:Coord|Coord]] c) → [[Modding:Coord|Coord]]
:This creates a new coord with coordinates that are the absolute value of the corresponding original coordinates.
----
{{Anchor|coord_sign}}
;coord.sign([[Modding:Coord|Coord]] c) → [[Modding:Coord|Coord]]
:This creates a new coord by applying the sign function (1 for positive, 0 for zero, -1 for negative) to each coordinate of the original coord.
----
{{Anchor|coord_distance}}
;coord.distance([[Modding:Coord|Coord]] c1, [[Modding:Coord|Coord]] c2) → '''integer'''
:Calculates the [[distance]] between the given coords.
----
{{Anchor|coord_real_distance}}
;coord.real_distance([[Modding:Coord|Coord]] c1, [[Modding:Coord|Coord]] c2) → '''number'''
:Calculates the (approximate) Euclidean distance between the biven coords.
----
{{Anchor|coord_random}}
;coord.random([[Modding:Coord|Coord]] c1, [[Modding:Coord|Coord]] c2) → [[Modding:Coord|Coord]]
:Returns a new coord uniformly at random whose x is between the x coordinates of ''c1'' and ''c2'' (inclusive) and whose y is between the y coordinates of ''c1'' and ''c2''. The coordinates of ''c1'' should be less than or equal to the corresponding coordinates of ''c2''.
----
{{Anchor|coord_get}}
;[[Modding:Coord|Coord]]:get() → '''integer''', '''integer'''
:Returns the x and y coordinates of the coord (in order).
----
{{Anchor|coord_tostring}}
;[[Modding:Coord|Coord]]:tostring() → '''string'''
:Returns a string containing the x and y coordinates separated by a comma.
----
{{Anchor|coord_clone}}
;[[Modding:Coord|Coord]]:clone() → [[Modding:Coord|Coord]]
:Returns a copy of the coord.
----
{{Anchor|coord_random_shift}}
;[[Modding:Coord|Coord]]:random_shift('''integer''' value)
:Changes the coord uniformly at random to a different coord (or possibly the same coord) whose x and y are within ''value'' of the originals. ''value'' is optional; it defaults to 1.
----
{{Anchor|coord_random_shifted}}
;[[Modding:Coord|Coord]]:random_shifted('''integer''' value) → [[Modding:Coord|Coord]]
:As random_shift, except instead of changing the existing coord, a new coord is returned.
----
{{Anchor|coord_cross_coords}}
;[[Modding:Coord|Coord]]:cross_coords() → [[Modding:Coord|Coord]] '''iterator'''
:Gives an iterator over all coords that are orthogonally adjacent to the given coord (i.e., not diagonals). This is ordered as follows: west, east, north, then south.
----
{{Anchor|coord_around_coords}}
;[[Modding:Coord|Coord]]:around_coords() → [[Modding:Coord|Coord]] '''iterator'''
:Gives an iterator over all coords adjacent to the given coord. It begins at the coord above and to the left of the given coord, then follows clockwise around the given coord.

=== Constants ===
{|style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
|colspan=3 style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Constant Coords'''
|-
|style="text-align: right; vertical-align:top; padding-right: 2ex;"|null
|style="vertical-align:top; padding-right: 2ex;"|coord.UNIT
|This is a coord with 1 in both coordinates. Be careful not to change it.
|-style="background: #333;"
|style="text-align: right; vertical-align:top; padding-right: 2ex;"|null
|style="vertical-align:top; padding-right: 2ex;"|coord.ZERO
|This is a coord with 0 in both coordinates. Be careful not to change it.
|}

Template:Modarg

2012-03-24T22:03:54Z

Game Hunter: some fixes, added StatusEffect

<noinclude>
Whenever an input or output argument is required for an API function, one should use <nowiki>{{modarg|arg}}</nowiki> to express it. This also handles cases where links are required. Some examples:
*<nowiki>{{modarg|integer}}</nowiki> → '''integer'''
*<nowiki>{{modarg|Being}}</nowiki> → '''[[Modding:Being|Being]]'''
*<nowiki>{{modarg|CoordList}}</nowiki> → '''[[Modding:Coord|CoordList]]'''
If there are more links required, feel free to add a line to the template.
</noinclude>{{#switch: {{{1}}}
| {{#if: {{#pos:{{{1}}}|Cell Flags}} |{{{1}}} }} = '''[[Modding:Cell#Flags|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Cellset}} |{{{1}}} }} = '''[[Modding:Constants#Cellsets|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Cell}} |{{{1}}} }} = '''[[Modding:Cell|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|ExplosionFlag}}|{{{1}}} }} = '''[[Modding:Constants#ExplosionFlag|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Item Flag}} |{{{1}}} }} = '''[[Modding:Item#Flags|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|LightFlag}} |{{{1}}} }} = '''[[Modding:Constants#LightFlag|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Level Flag}} |{{{1}}} }} = '''[[Modding:Level#Flags|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Flag}} |{{{1}}} }} = '''[[Modding:Constants#Flags|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|ItemType}} |{{{1}}} }} = '''[[Modding:Constants#ItemType|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|ItemSet}} |{{{1}}} }} = '''[[Modding:ItemSet|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Item}} |{{{1}}} }} = '''[[Modding:Item|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Affect}} |{{{1}}} }} = '''[[Modding:Affect|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|AltReload}} |{{{1}}} }} = '''[[Modding:Constants#AltReload|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|AltFire}} |{{{1}}} }} = '''[[Modding:Constants#AltFire|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Area}} |{{{1}}} }} = '''[[Modding:Area|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Badge}} |{{{1}}} }} = '''[[Modding:Badge|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Being}} |{{{1}}} }} = '''[[Modding:Being|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Color}} |{{{1}}} }} = '''[[Modding:Constants#Colors|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Coord}} |{{{1}}} }} = '''[[Modding:Coord|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|DamageType}} |{{{1}}} }} = '''[[Modding:Constants#DamageType|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Klass}} |{{{1}}} }} = '''[[Modding:Klass|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Medal}} |{{{1}}} }} = '''[[Modding:Medal|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Missile}} |{{{1}}} }} = '''[[Modding:Missile|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|ModArray}} |{{{1}}} }} = '''[[Modding:ModArray|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Player}} |{{{1}}} }} = '''[[Modding:Player|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Rank}} |{{{1}}} }} = '''[[Modding:Rank|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Resistance}} |{{{1}}} }} = '''[[Modding:Constants#Resistance|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Room}} |{{{1}}} }} = '''[[Modding:Generator|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|StatusEffect}} |{{{1}}} }} = '''[[Modding:Constants#StatusEffect|{{{1}}}]]'''
| {{#if: {{#pos:{{{1}}}|Trait}} |{{{1}}} }} = '''[[Modding:Trait|{{{1}}}]]'''
| {{{1}}}
}}

Modding:Affects

2012-03-24T22:02:48Z

Game Hunter: used more effective templates

These represent the various temporary effects in the game.

== Prototype ==

{{drltable|Affect Prototype|3|{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|{{modarg|string}} |id |The identifier for the affect.
|{{modarg|string}} |name |What is displayed in the status line while the effect is active.
|{{modarg|Color}} |color |The color of the name on the status line while the effect is on.
|{{modarg|Color}} |color_expire |The color of the name on the status line when the effect is wearing off.
|{{modarg|string}} |message_init |The message printed when the effect is activated.
|{{modarg|string}} |message_ending |The message printed when the effect is wearing off. This is unused in 0.9.9.6.
|{{modarg|string}} |message_done |The message printed when the effect wears off.
|{{modarg|StatusEffect}}|status_effect |The overlay effect that occurs while this effect is active.
|{{modarg|integer}} |status_strength|When multiple effects have overlay changes, the one with the highest strength will be the overlay displayed if more than one is active at the same time.
}}
}}

== Engine Hooks ==

{{drltable|Affect Hooks|2|{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|{{modarg|void}}|[[#OnAdd|OnAdd]]('''Affect''' self)
|{{modarg|void}}|[[#OnTick|OnTick]]('''Affect''' self)
|{{modarg|void}}|[[#OnRemove|OnRemove]]('''Affect''' self)
}}
}}

{{anchor|OnAdd}}
;OnAdd('''Affect''' self)
:This is called when the effect is gained.
----
{{anchor|OnTick}}
;OnTick('''Affect''' self)
:This is called every action while the effect is active.
----
{{anchor|OnRemove}}
;OnRemove('''Affect''' self)
:This is called when the effect is lost.

Modding:level blueprint (0.9.9.7)

2012-03-24T01:23:32Z

Game Hunter: uncommented push_cell

Level objects define the properties of fixed special levels. The level API, however, is a general purpose API for manipulating the level. This is used both for map generation (along with the [[Modding:Generator#API|generator API]]) and for changing the level on the fly. The Level variable also has some general properties that don't necessarily correspond to special levels in particular.

== Prototype ==
Levels prototypes are only used for special levels and scripted levels, not random levels. They are declared using the Levels function with the ID as the first argument, and a prototype table as the second argument. They are stored by ID in a global table called levels.
{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Level Prototype'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|string|ID|The unique identifier used by the engine for this level. Instead of being included in the table, this must be passed as the first argument to the Levels function.
|string|name|The name displayed in the HUD.
|string|welcome|Optional message displayed on level entry.
|integer|chance|Optional percent chance the level will appear. Defaults to 100.
|[[Modding:Functions$function_resolve_range|Range]]|level|Level range where the level may appear.
|string|entry|Optional mortem history message for level entry.
}}
|}
=== Flags ===
{{drltable|Level Flags|2|{{Table2Col
|es=background: #333;
|c1=font-family:monospace; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|LF_NOHOMING|Causes homing phase devices to act like normal phase devices.
|LF_UNIQUEITEM|Used by the level generation code to keep track of whether a unique item has dropped on the current level (in order to prevent multiple uniques from dropping on one level). This flag also causes a level feeling to occur indicating that a unique item is present.
|LF_BONUS|This flag is automatically set for so-called special levels like [[Halls of Carnage]]. (It is not set for those special levels like [[Hellgate]] that replace normal levels, only by those reached from red stairs.)
|LF_RESPAWN|Causes monsters to randomly respawn as when playing the game on Nightmare!
|LF_NORESPAWN|Prevents the Nightmare! respawn feature.
|LF_NUKED|This flag is automatically set when the level is nuked.
|LF_NONUKE|Causes the thermonuclear bomb to have no effect when it is used. It is not respected by other nuke effects.
|LF_ITEMSVISIBLE|Allows the player to see all items on the level (as with a [[Computer Map]]).
|LF_BEINGSVISIBLE|Allows the player to see all beings on the level (as with a [[Tracking Map]]).
|}}
}}
== Engine Hooks ==
{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="2" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Level Hooks'''
{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|void|[[#level_Create|Create]]()
|void|[[#level_OnTick|OnTick]]()
|void|[[#level_OnEnter|OnEnter]]()
|void|[[#level_OnExit|OnExit]]()
|void|[[#level_OnKill|OnKill]]()
|void|[[#level_OnKillAll|OnKillAll]]()
|boolean|[[#level_IsCompleted|IsCompleted]]()
}}
|}

{{Anchor|level_Create}}
;Create()
:This function should create the layout of the level. It also usually sets up the initial being and item locations. The player's initial location should be set here using Level.player.
----
{{Anchor|level_OnTick}}
;OnTick()
:This is called every 0.1s of game time. This will happen many times for each of the player's moves, so be careful about putting intense calculations here.
----
{{Anchor|level_OnEnter}}
;OnEnter()
:This is triggered just after the player enters the level.
----
{{Anchor|level_OnExit}}
;OnExit()
:This is triggered when the player leaves the level.
----
{{Anchor|level_OnKill}}
;OnKill()
:This hook is triggered whenever an enemy is killed.
----
{{Anchor|level_OnKillAll}}
;OnKillAll()
:After OnKill has triggered, if there are no enemies left on the level, the OnKillAll will be triggered. It is possible for OnKillAll to trigger again later if more enemies are spawned. By default, the "relatively safe" message is displayed.
----
{{Anchor|level_IsCompleted}}
;IsCompleted() → '''boolean'''
:The game calls this hook to determine if the game statistics should count the level as completed. This is only called for special levels, not scripted levels. By default, all enemies must be dead for the level to be complete.

== Properties ==
These are properties of the global Level variable. They are changed by the engine as the player moves from level to level. For some of the read-only properties, rawset can be used to create a lua property that shadows the pascal property, tricking APIs that are implemented in lua. This is particularly useful for tricking the generator API into using a custom style.
{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Level'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|Word|status|This is for use by level designers. It is preferred to access it through Level.result.
|string|name|This is the level name as displayed on the HUD.
|Byte|name_number|This controls the "LevX" part of the level name. If zero, it won't be displayed.
|Byte|danger_level|Level generation parameter that corresponds to depth.
|Byte|style|The style (tile set) used by the level generation functions. This property is read-only.
|string|special_exit|The sid of the level that red stairs lead to on the current level number. This property is read-only.
|string|special_name|The sid of the current level prototype or the empty string for random levels. This property is read-only.
|DWord|item_array_size|Length of the sparse array that stores all the items on the level. This property is read-only.
|DWord|being_array_size|Length of the sparse array that stores all the beings on the level. This property is read-only.
}}
|}

== API ==
{{drltable|Level Interface|2|{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|{{modarg|value}}|{{moddef|list|property_get|dot||string|property}}
|{{modarg|void}}|{{moddef|list|property_set|dot|string|property|value|value}}
|{{modarg|boolean}}|{{moddef|list|flag_get|dot||Level Flag|flag}}
|{{modarg|void}}|{{moddef|list|flag_set|dot||Level Flag|flag|boolean|value}}
|{{modarg|value}}|{{moddef|list|roll_weight|dot||list|list|integer|sum}}
|{{modarg|integer}}|{{moddef|list|weight_list_sum|dot||list|list}}
|{{modarg|void}}|{{moddef|list|place_tile|dot||table|translation|string|tile|integer|x|integer|y}}
|{{modarg|void}}|{{moddef|list|player|dot||integer|x|integer|y}}
|{{modarg|integer}}|{{moddef|list|result|dot||integer|value}}
|{{modarg|boolean}}|{{moddef|list|eye_contact|dot||Coord|c1|Coord|c2}}
|{{modarg|boolean}}|{{moddef|list|is_visible|dot||Coord|position}}
|{{modarg|void}}|{{moddef|list|nuke|dot}}
|{{modarg|void}}|{{moddef|list|explosion|dot||Coord|position|integer|radius|integer|delay|integer|damage_dice|integer|damage_sides|Color|color|Sound ID|sound|DamageType|damagetype|ExplosionFlag List|flags|Cell ID|content}}
||'''Cell-specific functions'''
|{{modarg|boolean}}|{{moddef|list|light_flag_get|dot||Coord|position|LightFlag|flag}}
|{{modarg|void}}|{{moddef|list|light_flag_set|dot||Coord|position|LightFlag|flag|boolean|value}}
|{{modarg|integer}}|{{moddef|list|hp_get|dot||Coord|position}}
|{{modarg|void}}|{{moddef|list|hp_set|dot||Coord|position|integer|value}}
|{{modarg|boolean}}|{{moddef|list|is_corpse|dot||Coord|position}}
|{{modarg|boolean}}|{{moddef|list|scan|dot||Area|scan_area|Cell ID|good}}
|{{modarg|void}}|{{moddef|list|fill|dot||Cell ID|cell|Area|fill_area}}
|{{modarg|void}}|{{moddef|list|flood|dot||Cell ID|tile|Area|flood_area}}
|{{modarg|void}}|{{moddef|list|scatter|dot||Area|scatter_area|Cell ID|good|Cell ID|fill|integer|count}}
|{{modarg|void}}|{{moddef|list|scatter_put|dot||Area|scatter_area|table|translation|string|tile|Cell ID|good|integer|count}}
|{{modarg|boolean}}|{{moddef|list|push_cell|dot||Coord|c|Coord|target|boolean|quiet}}
||'''Being-specific functions'''
|{{modarg|Being}}|{{moddef|list|get_being|dot||integer|index}}
|{{modarg|Being}}|{{moddef|list|get_being_by_uid|dot||integer|uid}}
|{{modarg|Being}}|{{moddef|list|drop_being|dot||Being ID|bid|Coord|position}}
|{{modarg|void}}|{{moddef|list|drop_being_ext|dot||table|being|Coord|position}}
|{{modarg|Being}}|{{moddef|list|summon|dot||Being ID|bid|integer|count}}
|{{modarg|Being}}|{{moddef|list|area_summon|dot||Area|where|Being ID|bid|integer|count}}
|{{modarg|void}}|{{moddef|list|clear_being|dot||Coord|position}}
|{{modarg|list}}, {{modarg|integer}}|{{moddef|list|get_being_list|dot}}
|[[Modding:Being|Being ID]]|{{moddef|list|random_being|dot}}
|{{modarg|void}}|{{moddef|list|flood_monster|dot||Being ID|bid|integer|amount}}
|{{modarg|void}}|{{moddef|list|flood_monsters|dot||integer|amount}}
|{{modarg|Being iterator}}|{{moddef|list|beings|dot}}
|{{modarg|Being iterator}}|{{moddef|list|beings_in_range|dot||Coord|position|integer|range}}
||'''Item-specific functions'''
|{{modarg|Item}}|{{moddef|list|get_item|dot||integer|index}}
|{{modarg|Item}}|{{moddef|list|get_item_by_uid|dot||integer|uid}}
|{{modarg|Item}}|{{moddef|list|drop_item|dot||Item ID|iid|Coord|position}}
|{{modarg|void}}|{{moddef|list|drop_item_ext|dot||table|item|Coord|position}}
|{{modarg|Item}}|{{moddef|list|drop|dot||Item ID|iid|integer|count}}
|{{modarg|Item}}|{{moddef|list|area_drop|dot||Area|where|Item ID|iid|integer|count}}
|{{modarg|void}}|{{moddef|list|try_destroy_item|dot||Coord|c}}
|{{modarg|list}}, {{modarg|integer}}|{{moddef|list|get_item_list|dot||integer|max_level|integer|unique_mult}}
|[[Modding:Item|Item ID]]|{{moddef|list|roll_item_type|dot||ItemType list|itypes|integer|max_level|integer|unique_mod}}
|[[Modding:Item|Item ID]]|{{moddef|list|roll_item|dot||integer|max_level|integer|unique_mod}}
|{{modarg|void}}|{{moddef|list|flood_items|dot||integer|amount|}}
|{{modarg|Item iterator}}|{{moddef|list|items|dot}}
|{{modarg|Item iterator}}|{{moddef|list|items_in_range|dot||Coord|position|integer|range}}
}}
}}

{{moddef|desc|property_get|dot|value|string|property}}
:Gets the value of the given level property. It is preferred to use the Lua dot indexing syntax instead.
----
{{moddef|desc|property_set|dot|string|property|value|value}}
:Sets the given level property to the given value. It is preferred to use the Lua dot indexing syntax instead.
----
{{moddef|desc|flag_get|dot|boolean|Level Flag|flag}}
;Level.flags[[[Modding:Constants#Level Flags|Level Flag]] flag] → '''boolean'''
:Determines the current state of the given level flag.
----
{{moddef|desc|flag_set|dot||Level Flag|flag|boolean|value}}
;Level.flags[[[Modding:Constants#Level Flags|Level Flag]] flag] = '''boolean''' value
:Sets the given level flag to the given value.
----
{{moddef|desc|roll_weight|dot|value|list|list|integer|sum}}
:Randomly chooses an item from the list according to the weight property of the list items. Sum must be the sum of the weights of all the list items.
----
{{moddef|desc|weight_list_sum|dot|integer|list|list}}
:Returns the sum of the weight properties of all the items in the list.
----
{{moddef|desc|place_tile|dot||table|translation|string|tile|integer|x|integer|y}}
:Places the map tile given by ''translation'' and ''tile'' on the map at the position given by ''x'' and ''y''. ''translation'' should be a table that maps single character strings to either cell ids, or to tables. These tables have their first array element be a cell id, but they may also contain a being and''or'' item key that is mapped to a being or item id respectively. Level.drop_being_ext and Level.drop_item_ext syntax is allowed. ''tile'' should be a string of characters that are defined in ''translation''. Line breaks correspond to line breaks on the map.
----
{{moddef|desc|player|dot||integer|x|integer|y}}
:Sets the initial position of the player for a special or scripted level. This should be called in the Create hook; after that it has no meaningful effect.
----
{{moddef|desc|result|dot|integer|integer|value}}
:If ''value'' is given, updates the level's status and returns nil. If ''value'' is omitted, returns the current status.
----
{{moddef|desc|eye_contact|dot|boolean|Coord|c1|Coord|c2}}
:Determines whether or not there is a line-of-sight path between '''c1''' and '''c2'''. This calculation ignores light flags (such that two beings can have eye contact even if they aren't visible to each other).
----
{{moddef|desc|is_visible|dot|boolean|Coord|position}}
:Determines if the given position is visible to the player.
----
{{moddef|desc|nuke|dot}}
:Triggers an immediate nuclear explosion as from a [[thermonuclear bomb]].
----
{{moddef|desc|explosion|dot||Coord|position|integer|radius|integer|delay|integer|damage_dice|integer|damage_sides|Color|color|Sound ID|sound|DamageType|damagetype|ExplosionFlag List|flags|Cell ID|content}}
:Creates an [[explosions|explosion]] centered at the given position with the given parameters. ''radius'' is the size of the explosion. ''delay'' is the delay in milliseconds between animation frames (typically this is around 40). ''damage_dice'' and ''damage_sides'' determine the damage roll for the explosion. For a no-damage explosion, both should be 0. The default damage type is fire. ''content'' determines the cell that is randomly created wherever the explosion does enough damage. By default, there are no flags and there is no content. Only some colors are supported, and these are automatically translated into 3 color combinations used by the explosion animation. The supported colors are LIGHTBLUE, BLUE, MAGENTA, GREEN, LIGHTRED, YELLOW, and the default RED.
----
{{moddef|desc|light_flag_get|dot|boolean|Coord|position|LightFlag|flag}}
;Level.light[[[Modding:Coord|Coord]] position][[[Modding:Constants#LightFlag|LightFlag]] flag] → '''boolean'''
:Gets the value of the given light flag at the given position.
----
{{moddef|desc|light_flag_set|dot||Coord|position|LightFlag|flag|boolean|value}}
;Level.light[[[Modding:Coord|Coord]] position][[[Modding:Constants#LightFlag|LightFlag]] flag] = '''boolean''' value
;Level.light[[[Modding:Constants#LightFlag|LightFlag]] flag] = '''boolean''' value
:Sets the value of the given light flag at the given position. For the syntax without a position, the light flag will be set at every position on the map.
----
{{moddef|desc|hp_get|dot|integer|Coord|position}}
;Level.hp[[[Modding:Coord|Coord]] position] → '''integer'''
:Gets the current hp of the cell at the given position.
----
{{moddef|desc|hp_set|dot||Coord|position|integer|value}}
;Level.hp[[[Modding:Coord|Coord]] position] = '''integer''' value
:Sets the current hp of the cell at the given position. Setting hp to 0 won't destroy a cell.
----
{{moddef|desc|is_corpse|dot|boolean|Coord|position}}
:Determines whether the given position has a corpse in it. This counts the cell with id "corpse" as a corpse even though it otherwise isn't a corpse as far as the engine is concerned.
----
{{moddef|desc|scan|dot|boolean|Area|scan_area|Cell ID|good}}
:Determines if every cell in ''scan_area'' is ''good''.
----
{{moddef|desc|fill|dot||Cell ID|cell|Area|fill_area}}
:Sets every cell in the given area to the area. ''fill_area'' is optional; it defaults to the full map.
----
{{moddef|desc|flood|dot||Cell ID|tile|Area|flood_area}}
:Changes CELLSET_FLOORS and CF_LIQUID tiles in the area to ''tile''. If ''tile'' has CF_HAZARD, then it will destroy items.
----
{{moddef|desc|scatter|dot||Area|scatter_area|Cell ID|good|Cell ID|fill|integer|count}}
:Chooses ''count'' random tiles in ''scatter_area'' (possibly with duplicates) and sets any chosen cells that are ''good'' to ''fill''.
----
{{moddef|desc|scatter_put|dot||Area|scatter_area|table|translation|string|tile|Cell ID|good|integer|count}}
:Chooses ''count'' random subareas with upper-left corner in ''scatter_area'' of the size appropriate of ''tile'' (using the first line length and number of lines to define a rectangular area). There may be duplicates or overlaps. For each subarea, if the area is already filled with ''good'', then it is replaced with ''tile'' (according to ''translation''). See Level.place_tile for the semantics of ''translation'' and ''tile''.
----
{{moddef|desc|push_cell|dot|boolean|Coord|c|Coord|target|boolean|quiet}}
:Swaps the content of the cells located in '''c''' and '''target''': this will only occur successfully if '''target''' is a part of CELLSET_FLOORS. If '''target''' has the CF_HAZARD flag, the cell on '''c''' activates its OnDestroy hook. '''quiet''', when set to true, includes messages (mostly specific to barrels, the only object pushed in the base game).
----
{{moddef|desc|get_being|dot|Being|integer|index}}
:Returns the being at the given index in the sparse being array. A being's index won't change as long as it is in the array.
----
{{moddef|desc|get_being_by_uid|dot|Being|integer|uid}}
:Returns the being with the given uid, or nil if that being doesn't exist or has been removed from the map.
----
{{moddef|desc|drop_being|dot|Being|Being ID|bid|Coord|position}}
:Drops a newly created being in the given position. ''bid'' can also be an actual being object, although this should not be used for beings that are already on the map. If the position is occupied, the being will be dropped nearby. The dropped being is returned. If the function fails, nil is returned.
----
{{moddef|desc|drop_being_ext|dot||table|being|Coord|position}}
:As Level.drop_being, except additional values are accetable for ''being'' as Level.drop_item_ext.
----
{{moddef|desc|summon|dot|Being|Being ID|bid|integer|count}}
:Creates new beings of the type given by ''bid'' and amount given by ''count'' and scatters them around the map. The last dropped being (if any) is returned. ''count'' is optional and defaults to 1.
----
{{moddef|desc|area_summon|dot|Being|Area|where|Being ID|bid|integer|count}}
:As Level.summon, but all the summoned beings are randomly placed in ''where'' rather than scattered across the whole map.
----
{{moddef|desc|clear_being|dot||Coord|position}}
{{moddef|desc|clear_being|dot||integer|index}}
:Removes an item from the map at the given position, or from the given index in the item array.
----
{{moddef|desc|get_being_list|dot|list,integer}}
:Returns the list and sum (ready to be used with [[#level_roll_weight|Level.roll_weight]]) for beings and beings groups according to Level.danger_level and DIFFICULTY. The result is cached.
----
{{moddef|desc|random_being|dot|Being ID}}
:Returns a random being chosen according to weights from the current level's list. This will never choose a group. The returned id is always a string id.
----
{{moddef|desc|flood_monster|dot||Being ID|bid|integer|amount}}
:Add the given monster type to the level in an amount specified by the total danger value ''amount'' (so it scales appropriately with Level.flood_monsters).
----
{{moddef|desc|flood_monsters|dot||integer|amount}}
:Adds monsters to the level using the normal algorithm for random levels. The ''amount'' is a total danger value such as a value returned by Generator.being_weight.
----
{{moddef|desc|beings|dot|Being iterator}}
:Gives an iterator over all beings in the level.
----
{{moddef|desc|beings_in_range|dot|Being iterator|Coord|position|integer|range}}
:Gives an iterator over all beings within '''range''' units of [[distance]] from '''position''' in the level.
----
{{moddef|desc|get_item|dot|Item|integer|index}}
:Returns the item at the given index in the sparse item array. An item's index won't change as long as it is in the array.
----
{{moddef|desc|get_item_by_uid|dot|Item|integer|uid}}
:Returns the item with the given uid, or nil if that item doesn't exist or has been removed from the map.
----
{{moddef|desc|drop_item|dot|Item|Item ID|iid|Coord|position}}
:Drops a newly created item in the given position. ''iid'' can also be an actual item object, although this should not be used for items that are already on the map. If the position is occupied, the item will be dropped nearby. The dropped item is returned. If the function fails, nil is returned.
----
{{moddef|desc|drop_item_ext|dot||table|item|Coord|position}}
:As Level.drop_item, except additional values are acceptable for ''item''. If ''item'' is a table, the first list element is passed used to determine which item to drop. For other key-value pairs in the table, the property of the dropped item that corresponds to the key will be set to the value.
----
{{moddef|desc|drop|dot|Item|Item ID|iid|integer|count}}
:Creates new items of the type given by ''iid'' and amount given by ''count'' and scatters them around the map. The last dropped item (if any) is returned. ''count'' is optional and defaults to 1.
----
{{moddef|desc|area_drop|dot|Item|Area|where|Item ID|iid|integer|count}}
:As Level.drop, but all dropped items are randomly placed in ''where'' rather than scattered across the whole map.
----
{{moddef|desc|try_destroy_item|dot||Coord|c}}
:Destroys an item at '''position''', if there is one to be found.
----
{{moddef|desc|get_item_list|dot|list,integer|integer|max_level|integer|unique_mult}}
:Returns the list and sum (ready to be used with [[#level_roll_weight|Level.roll_weight]]) for items according to ''max_level'', and ''unique_mult''. ''max_level'' defaults to Level.danger_level, and is used to determine which items fall in the proper level range. Unique items' weights are multiplied by ''unique_mult'' (which defaults to 1). The result is cached.
----
{{moddef|desc|roll_item_type|dot|Item ID|ItemType list|itypes|integer|max_level|integer|unique_mod}}
:Returns a random item chosen from among the given item types according to weights from the list specified by ''max_level'' and ''unique_mod''. The returned id is always a string id.
----
{{moddef|desc|roll_item|dot|Item ID|integer|max_level|integer|unique_mod}}
:As Level.roll_item_type, but the item type of the result isn't restricted.
----
{{moddef|desc|flood_items|dot||integer|amount|}}
:Adds items to the level according to the normal algorithm for random levels (not counting special features). The number of items is given by ''amount''.
----
{{moddef|desc|items|dot|Item iterator}}
:Gives an iterator over all items in the level.
----
{{moddef|desc|items_in_range|dot|Item iterator|Coord|position|integer|range}}
:Gives an iterator over all items within '''range''' units of [[distance]] from '''position''' in the level.

Modding:generator API (0.9.9.7)

2012-03-16T04:46:44Z

Game Hunter: somehow forgot generate_tiled_dungeon

The generator holds all of the ever-present functions used to create the random maps in DoomRL. It also contains a variety of helper functions, many of them useful if not vital to the creation of intricate and meticulous game design.

== API ==
{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="2" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Level Interface'''
{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|{{modarg|Coord}}|{{moddef|list|safe_empty_coord|dot}}
|{{modarg|Coord}}|{{moddef|list|standard_empty_coord|dot}}
|{{modarg|void}}|{{moddef|list|set_permanence|dot||Area|ar|boolean|val|Cell|tile}}
|{{modarg|void}}|{{moddef|list|setup_ice_event|dot}}
|{{modarg|void}}|{{moddef|list|setup_perma_event|dot}}
|{{modarg|void}}|{{moddef|list|setup_alarm_event|dot}}
|{{modarg|void}}|{{moddef|list|setup_deadly_air_event|dot||integer|step}}
|{{modarg|void}}|{{moddef|list|setup_nuke_event|dot||integer|minutes}}
|{{modarg|void}}|{{moddef|list|setup_flood_event|dot||integer|direction|integer|step|Cell|cell|boolean|pure}}
|{{modarg|integer}}|{{moddef|list|being_weight|dot}}
|{{modarg|integer}}|{{moddef|list|item_amount|dot}}
|{{modarg|void}}|{{moddef|list|restore_walls|dot||Cell|wall_cell|boolean|keep_fluids}}
|{{modarg|Cellset list}}|{{moddef|list|cell_set|dot||list|list}}
|{{modarg|void}}|{{moddef|list|horiz_river|dot||Cell|cell|integer|width|boolean|bridge}}
|{{modarg|void}}|{{moddef|list|vert_river|dot||Cell|cell|integer|width|boolean|bridge|Coord|pos}}
|{{modarg|void}}|{{moddef|list|generate_rivers|dot||boolean|allow_horiz|boolean|allow_more}}
|{{modarg|void}}|{{moddef|list|drunkard_walk|dot||Coord|start|integer|steps|Cell|cell|Cell list|ignore|boolean|break_on_edge}}
|{{modarg|void}}|{{moddef|list|drunkard_walks|dot||integer|amount|integer|steps|Cell|cell|Cell list|ignore|boolean|break_on_edge|Area|drunk_area}}
|{{modarg|void}}|{{moddef|list|contd_drunkard_walks|dot||integer|amount|integer|steps|Cell|cell|Coord|edges1|Coord|edges2|Cell list|ignore|boolean|break_on_edge}}
|{{modarg|void}}|{{moddef|list|plot_lines|dot||Coord|where|Area|larea|boolean|horiz|Cell|cell|Cell list|block}}
|{{modarg|void}}|{{moddef|list|maze_dungeon|dot||Cell|floor_cell|Cell|wall_cell|integer|granularity|integer|tries|integer|minl|integer|maxl}}
|{{modarg|void}}|{{moddef|list|warehouse_fill|dot||Cell|wall_cell|Area|fill_area|integer|box_size|integer|amount}}
|{{modarg|void}}|{{moddef|list|warehouse_dungeon|dot}}
|{{modarg|void}}|{{moddef|list|add_room|dot||Area|room}}
|{{modarg|boolean}}|{{moddef|list|add_rooms|dot}}
|{{modarg|Room}}|{{moddef|list|get_room|dot||integer|min_size|integer|max_x|integer|max_y}}
|{{modarg|void}}|{{moddef|list|generate_tiled|dot}}
|{{modarg|void}}|{{moddef|list|generate_warehouse_dungeon|dot}}
|{{modarg|void}}|{{moddef|list|generate_tiled_dungeon|dot}}
|{{modarg|void}}|{{moddef|list|generate_tiled_arena_dungeon|dot}}
|{{modarg|void}}|{{moddef|list|generate_city_dungeon|dot}}
|{{modarg|void}}|{{moddef|list|generate_maze_dungeon|dot}}
|{{modarg|void}}|{{moddef|list|generate_archi_dungeon|dot}}
|{{modarg|void}}|{{moddef|list|generate_caves_dungeon|dot}}
|{{modarg|void}}|{{moddef|list|generate_arena_dungeon|dot}}
|{{modarg|void}}|{{moddef|list|generate_fluids|dot||Area|drunk_area}}
|{{modarg|void}}|{{moddef|list|generate_barrels|dot}}
|{{modarg|void}}|{{moddef|list|generate_stairs|dot}}
|{{modarg|void}}|{{moddef|list|generate_special_stairs|dot}}
|{{modarg|void}}|{{moddef|list|generate_lever_room|dot}}
|{{modarg|void}}|{{moddef|list|generate_teleport_room|dot}}
|{{modarg|void}}|{{moddef|list|generate_ammo_room|dot}}
|{{modarg|void}}|{{moddef|list|generate_basain|dot}}
|{{modarg|void}}|{{moddef|list|generate_warehouse_room|dot}}
|{{modarg|void}}|{{moddef|list|generate_vault|dot}}
|{{modarg|void}}|{{moddef|list|add_room_feature|dot||boolean|no_monsters}}
|{{modarg|void}}|{{moddef|list|handle_rooms|dot||boolean|no_monsters}}
|{{modarg|void}}|{{moddef|list|place_player|dot}}
|{{modarg|void}}|{{moddef|list|roll_event|dot}}
|{{modarg|void}}|{{moddef|list|reset|dot}}
|}}
|}

;{{moddef|desc|safe_empty_coord|dot}}
:Gives a coordinate that satisfies all [[Modding:Constants#Empty Flags|empty flags]]. If one cannot be found, another attempt is made that excludes EF_NOSAFE; if one still cannot be found, another attempt is made that additionally excludes EF_NOSTAIRS and EF_NOHARM.
----
;{{moddef|desc|standard_empty_coord|dot}}
:Gives a coordinate that satisfies all empty flags other than EF_NOSAFE.
----
;{{moddef|desc|set_permanence|dot||Area|ar|boolean|val|Cell|tile}}
:Adds the "frozen" level event to the map and records it in the mortem history. Levels with the frozen event change all walls into ice walls and all fluids into water.
----
;{{moddef|desc|setup_ice_event|dot}}
:Adds the "frozen" level event to the map and records it in the mortem history. Levels with the frozen event change all walls into ice walls and all fluids into water.
----
;{{moddef|desc|setup_perma_event|dot}}
:Adds the "sturdy" level event to the map and records it in the mortem history. Levels with the sturdy event set all wall tiles to be permanent.
----
;{{moddef|desc|setup_alarm_event|dot}}
:Adds the "alarm" level event to the map and records it in the mortem history. Levels with the alarm event set all non-player beings' [[Modding:Constants#Being Flags|BF_HUNTING]] flag to true.
----
;{{moddef|desc|setup_deadly_air_event|dot||integer|step}}
:Adds the "deadly air" event to the map and records it in the mortem history. Levels with the deadly air event cause all beings to lose hit points every '''step''' turns.
----
;{{moddef|desc|setup_nuke_event|dot||integer|minutes}}
:Adds the "armed nuke" event to the map and records it in the mortem history. Levels with the armed nuke event begin with a [[thermonuclear bomb]] set at the player's starting position, which will explode in ''minutes'' game minutes.
----
;{{moddef|desc|setup_flood_event|dot||integer|direction|integer|step|Cell|cell|boolean|pure}}
:Adds the "flood" event to the map and records it in the mortem history. Levels with the flood event are slowly filled with a fluid: ''direction'' determines whether the floor travels from the right (-1) or from the left (+1); every ''step'' turns, ''cell'' will replace all tiles in a next column to be flooded. Setting ''pure'' to false will move the player and stairs to opposite sides of the map, with the player nearest the flood.
----
;{{moddef|desc|being_weight|dot|integer}}
:Gives a value equal to the difficulty-adjusted weight of beings for a given danger level. These are the results used for the base game's monster generation parameters.
----
;{{moddef|desc|item_amount|dot|integer}}
:Gives a value equal to the number of items spawned for a given danger level. On level types where the this amount isn't preset, this is the result used for the base game's item generation parameters.
----
;{{moddef|desc|restore_walls|dot||Cell|wall_cell|boolean|keep_fluids}}
:Sets all cells on the edge of the map to ''wall_cell''. If ''keep_fluids'' is set to true, fluid tiles will be maintained but set as permanent.
----
;{{moddef|desc|cell_set|dot|Cellset list|list|list}}
:Creates a cellset for all cells in ''list''. The returned list functions just like any [[Modding:Constants#Cellsets|CELLSET constant]].
----
;{{moddef|desc|horiz_river|dot||Cell|cell|integer|width|boolean|bridge}}
:Adds a horizontal river to the map, created using ''cell'' tiles. ''width'' sets the tile-width of the river. If ''bridge'' is set to true, a non-fluid floor bridge will be created on the river.
----
;{{moddef|desc|vert_river|dot||Cell|cell|integer|width|boolean|bridge|Coord|pos}}
;{{moddef|desc|vert_river|dot||Cell|cell|integer|width|boolean|bridge|integer|pos}}
:Adds a vertical river to the map, created using ''cell'' tiles. ''width'' sets the tile-width of the river, and ''pos'' sets the starting position of the river. If ''pos'' is given as an integer, then the starting y-coordinate of the river is at the top of the map. If ''bridge'' is set to true, a non-fluid floor bridge will be created on the river.
----
;{{moddef|desc|generate_rivers|dot||boolean|allow_horiz|boolean|allow_more}}
:Generates a random number of horizontal and vertical rivers on the map. See [[Fluids#Rivers|Rivers]] for more information. The fluid type varies with map depth.
----
;{{moddef|desc|drunkard_walk|dot||Coord|start|integer|steps|Cell|cell|Cell list|ignore|boolean|break_on_edge}}
:Generates ''cell'' tiles according to a drunken walk algorithm. It travels ''steps'' times, starting at the coordinate ''start''. Any cells in ''ignore'' will not be set over but the algorithm will still continue. If ''break_on_edge'' is set to true, the drunken walk will stop if it hits a map border: otherwise it will continue, clamping cells within the map as necessary.
----
;{{moddef|desc|drunkard_walks|dot||integer|amount|integer|steps|Cell|cell|Cell list|ignore|boolean|break_on_edge|Area|drunk_area}}
:As Generator.drunkard_walk, but repeated ''amount'' times. Additionally, rather than specifically a starting position, all walks are chosen from a random coordinate within ''drunk_area''.
----
;{{moddef|desc|contd_drunkard_walks|dot||integer|amount|integer|steps|Cell|cell|Coord|edges1|Coord|edges2|Cell list|ignore|boolean|break_on_edge}}
:As Generator.drunkard_walks, but rather than limiting the walk's starting position, the walk will stop prematurely if it has reached the x- or y-coordinates of both ''edges1'' and ''edges2''.
----
;{{moddef|desc|plot_lines|dot||Coord|where|Area|larea|boolean|horiz|Cell|cell|Cell list|block}}
:Generates a line of ''cell'' tiles on the map, starting at ''where'' and extending to the boundaries of ''larea''. ''horiz'' set to true will produce horizontal lines: otherwise it will produce vertical lines. If a cell from ''block'' is found, the line will end prematurely at the end on which it was blocked.
----
;{{moddef|desc|maze_dungeon|dot||Cell|floor_cell|Cell|wall_cell|integer|granularity|integer|tries|integer|minl|integer|maxl}}
:Generates a map-wide maze, using ''wall_cell'' as the wall tiles and ''floor_cell'' as the floor tiles. Wall corridors are at least ''minl'' tiles apart and at most ''maxl'' tiles apart: ''granularity'' sets a rough complexity of the map. The number of walls attempted to be made is equal to ''tries''.
----
;{{moddef|desc|warehouse_fill|dot||Cell|wall_cell|Area|fill_area|integer|box_size|integer|amount}}
:Generates ''wall_cell'' tiles in the shape of a square within ''fill_area''. ''boxsize'' sets the size of the side of a box, and ''amount'' sets the number of tries for boxes to be added.
----
;{{moddef|desc|warehouse_dungeon|dot}}
:Generates a map-wide warehouse setting. Warehouse dungeons are divided into three large rooms, each attempting 50 tries with boxes of side length 3.
----
;{{moddef|desc|add_room|dot||Area|room}}
:Adds ''room'' to the Generator.room_list and Generator.room_meta lists. This is used in conjunction with room generation functions.
----
;{{moddef|desc|add_rooms|dot|boolean}}
:As Generator.add_room, but locates all rooms on the map and adds them to Generator.room_list and Generator.room_meta instead.
----
;{{moddef|desc|get_room|dot|Room|integer|min_size|integer|max_x|integer|max_y}}
:Finds a room that contains at least ''min_size'' in both height and width, and has a width and height no bigger than ''max_x'' and ''max_y'', respectively.
----
;{{moddef|desc|generate_tiled|dot}}
:Generates a "normal" map. Normal levels are divided randomly into rectangular rooms.
----
;{{moddef|desc|generate_warehouse_dungeon|dot}}
:Builds a "warehouse" level. This includes everything necessary to be played as a typical random level.
----
;{{moddef|desc|generate_tiled_dungeon|dot}}
:Builds a "normal" level. This includes everything necessary to be played as a typical random level.
----
;{{moddef|desc|generate_tiled_arena_dungeon|dot}}
:Builds a "single-monster" level. This includes everything necessary to be played as a typical random level.
----
;{{moddef|desc|generate_city_dungeon|dot}}
:Builds a "city" level. This includes everything necessary to be played as a typical random level.
----
;{{moddef|desc|generate_maze_dungeon|dot}}
:Builds a "maze" level. This includes everything necessary to be played as a typical random level.
----
;{{moddef|desc|generate_archi_dungeon|dot}}
:Builds an "archi" level. This includes everything necessary to be played as a typical random level.
----
;{{moddef|desc|generate_caves_dungeon|dot}}
:Builds a "cave" level. This includes everything necessary to be played as a typical random level.
----
;{{moddef|desc|generate_arena_dungeon|dot}}
:Builds an "arena" level. This includes everything necessary to be played as a typical random level.
----
;{{moddef|desc|generate_fluids|dot||Area|drunk_area}}
:Generates all non-river fluids on the map using drunken walks, within ''drunk_area''. The fluid type varies with danger level.
----
;{{moddef|desc|generate_barrels|dot}}
:Generates all barrels on the map, The barrel type varies with danger level.
----
;{{moddef|desc|generate_stairs|dot}}
:Generates stairs on the map.
----
;{{moddef|desc|generate_special_stairs|dot}}
:Generates special stairs on the map, if a special level exists at the current map depth.
----
;{{moddef|desc|generate_lever_room|dot}}
:Finds a room of appropriate size and adjusts it into a lever room.
----
;{{moddef|desc|generate_teleport_room|dot}}
:Finds a room of appropriate size and adjusts it into a teleporter room.
----
;{{moddef|desc|generate_ammo_room|dot}}
:Finds a room of appropriate size and adjusts it into an ammo room. The type of ammo varies with danger level.
----
;{{moddef|desc|generate_basain|dot}}
:Finds a room of appropriate size and adjusts it into a room filled with fluid.
----
;{{moddef|desc|generate_warehouse_room|dot}}
:Finds a room of appropriate size and adjusts it into a room with boxes (as Generator.warehouse_fill).
----
;{{moddef|desc|generate_vault|dot}}
:Finds a room of appropriate size and adjust it into a vault. The monsters, items, and type of vault vary with danger level.
----
;{{moddef|desc|add_room_feature|dot||boolean|no_monsters}}
:Randomly selects a room generation function to be added to the map. ''no_monsters'' set to true excludes the possibility of a vault room being generated.
----
;{{moddef|desc|handle_rooms|dot||boolean|no_monsters}}
:Generates up to seven special rooms on the map and restores walls that were otherwise removed as a result of the room generation.
----
;{{moddef|desc|place_player|dot}}
:Adds to player to the map.
----
;{{moddef|desc|roll_event|dot}}
:Randomly select a level event function to be added to the map.
----
;{{moddef|desc|reset|dot}}
:Clears all generation properties and hooks, and changes the map into one bordered with the level style's walls and otherwise filled with the level style's floors.

Modding:Tutorial/Basic Syntax and Definitions

2012-03-11T20:38:14Z

Game Hunter: step before last!

The following is a very quick explanation of general programming syntax in lua. If you know even a little about programming, you do not likely need to read any of this.

==Variables==

Writing in a computer language is very brief and exact, and never involves any connotations or implications. In fact, with the exception of particular inputs and outputs, all of the language is entirely internal, purposed to communicate with the computer in order to perform calculations. Rather than directly using numbers, which do not allow for changes, you will want to assign any values you use to a variable. In lua, declaring a variable can be done by preceding it with the word "local", and assigning the variable a value is done using the equal sign.

<source lang="lua">
local yes = 1
local no = 0
</source>

With this code, whenever you would use the variable 'yes', it will be read as a true value, and whenever you would use the variable 'no', it will be read as a false value. (Note that the parameters are not always "local": this will be covered in detail elsewhere.) Variables can be reassigned as much as you want unless they are read-only on the engine side (this comes up in a few places for our purposes).

Variables in lua can be of a variety of different types. Typically you will use the following:

<source lang="lua">
local var_void = nil --singular value, used mostly to be a placeholder
local var_boolean = true --double value, true/false meant for satisfying conditions
local var_number = 3.14159 --double-precision floating-point value, pretty much any number you could possibly want
local var_string = 'awesome' --sequence of characters, must have single- or double-quotes around them
local var_function = print --subroutine, used to reference pieces of code over an entire file
local var_table = {1 = 'a'} --associative array of fields, holds a lot of information in a single place (explained later)
</source>

For the purpose of modding, you are often restricted by what type you can use based on what is allowed by the API. If an input was expecting a string and you use a boolean value, you will almost certainly get an error. Note that the left side could be just about anything you want: use whatever naming scheme works for you. There are, however, some exceptions ([http://www.lua.org/pil/1.3.html found here]) and you should be aware of them.

==Operators==

Calculations themselves are based on a variety of operators. The most basic operators are arithmetic, involving simple mathematical calculations (such as addition), and relational, which compare two values on either side of the operator. Logical operators first check the true/false values that are attached to the operator, then determine the true/false value of the whole statement, depending on which operator is used.

<source lang="lua">
--Arithmetic operators
2 + 4 --gives a value of 6 (addition)
10 - 6 --gives a value of 4 (subtraction)
3 * 7 --gives a value of 21 (multiplication)
16 / 2 --gives a value of 8 (division)
-8 --gives a value of negative 8 (unary)

--Relational operators
3 == 3 --true (note that equality relations are understood with ==)
12 ~= 1 --true (not equal to)
6 > 2 --false (greater than)
6 < 9 --true (less than)
2 >= 2 --true (greater than or equal to)
5 <= 4 --false (less than or equal to)

--Logical operators
0 or 1 --returns true; either value must be true
0 and 1 --returns false; both values must be true
not 0 --returns true; negates the value that it operates on
</source>

Using parentheses to determine the order of operations is usually the best way to write code, although generally arthemetic operations are performed before relational ones, and relational operators are performed before logical ones. (The notable exception are the unary arithmetic and the "not" logical operators, which take precendence over everything.) Finally, for cases of equal priority, the left side is calculated before the right side.

If you want to add variables or line-breaks in a string, end the string, include a double-dot syntax (".."), and add the variable or start a new line. This is known as concatenation.

<source lang="lua">
--displays "Hello world"
print("Hello " .. "world")

local var = 300
--displays "There are 300 bullets in the room."
print("There are " .. var .. " bullets in the room.")

--displays "This is just a single line of text."
print("This is just " ..
"a single line " ..
"of text.")
</source>

==Conditional Syntax==

Trying to determine how your code will run is primarily executed through conditional statements. These include:

<source lang="lua">
if condition --check to see if condition is true
then result --if condition was true, do result
end --conditional statements must always finish with this line

if condition1 --check to see if condition1 is true
then result1 --if condition1 was true, do result1
elseif condition2 --if condition1 was false, check to see if condition2 is true
then result2 --if condition2 was true, do result2
else
result3 --if condition2 (and condition1) was false, do result3
end

while condition --check if condition is true
do task --if condition was true, task is executed; if it was false, skip
end --if condition was true, repeat the statement; if it was false, end statement

repeat --repeat the following lines indefinitely
task --task executes (always executes at least once)
until condition --if condition is true, end statement

for var=val1,val2,val3 --iterate following lines based on vals
do task --task is executed a number of times equal to the number of vals
end

for var=first,last,step --iterate following lines from first to last, using step as iterator
do task --task is executed (last-first+1)/step times (rounded down)
end

for var,iter in ipairs(array) --iterate following lines for all fields in array, iter acts as index (if necessary)
do task --task is executed for as many fields as there are in the array
end

for var,iter in pairs(table) --same as above but with a table
do task --task is executed for as many keys as there are in the table
end
</source>

If a lot of these are confusing, don't worry as we'll eventually manage to find ways to include them in the tutorial as we go.

Finally, we have two miscellaneous statements: break and return. Break will prematurely exit a conditional statement, and could be used to, for instance, exit a "while true" loop (although this should probably be avoided). The following example would print the index number of the first true value in binary_array (which should be a 7) and then exit the loop.

<source lang="lua">
binary_array = {0,0,0,0,0,0,1,0,0,0,1,0,0,1}

for v,i in ipairs(binary_array) do
if i
print(i)
break
end
end
</source>

Return is used with functions. Calling return in a function ends execution of that function immediately and can be used to return data to whatever called it. Using the previous example, we can instead return the index number rather than printing it:

<source lang="lua">
index = local function findTrueValue(binary_array)
for v,i in ipairs(binary_array) do
if i
return(i)
end
end
</source>

This brief lesson in lua scripting should be all you need in order to understand the various examples found in the tutorial.

Ripper

2012-03-05T18:38:03Z

Game Hunter: firetime isn't part of melee weapon template: moved attack time mention to comments

{{infostrat switch}}
{{melee weapon|
weapon_name=Ripper|
weapon_dmg=6d6/6-36|
weapon_avgdmg=21|
weapon_dmgtype=[[Damage type#Melee|Melee]]|
weapon_accuracy=-4|
weapon_firetime=0.5s|
weapon_afire=None|
weapon_get=[[Assemblies|Assembly]]: {{exotic link|chainsaw}} + PPBT|
weapon_quote=N/A|
weapon_looks=\|
weapon_description=Assembly (same as original)|
weapon_other=This weapon has a 0.5s attack time.|
weapon_source=[http://en.wikipedia.org/wiki/Jack_the_Ripper Jack the ''Ripper'']}}

DRL Wiki

2012-02-21T19:45:26Z

Game Hunter: it's pretty patched for 0995

__NOTOC__
Welcome to the DoomRL Wiki, wherein detailed game information, strategy tips, and modding documentation are found. If you wish to make edits and generally contribute to increasing the sum of knowledge in the community, [[Special:UserLogin|you can log in]] with your [http://forum.chaosforge.org/ ChaosForge.org forum] login and password. (Note that you must have at least 20 forum posts, or be a supporter, in order to login.)

== Game Information ==

This section is meant to be as objective as possible. DO NOT add your opinions in these pages regarding their subject matter. (Naturally, if there are definite errors on any pages in Game Information, you can edit for that purpose.)

* [[Weapons]]
* [[Armor]]
* [[Items]]
* [[Specials]]
* [[Assemblies]]
* [[Enemies]]
* [[Levels]]
* [[Game Settings]]
* [[Character Development]]
* [[Achievements]]
* [[Documentation]]
* [[Mechanics]]

== Strategy Emporium ==

Stuff like strategy guides, tips and tricks, etc, goes here. To what extent the big guides go here is debatable, as this is meant to be talk-heavy as opposed to edit-heavy.

* [[Strategy:Guidelines|Guidelines]]
* [[Strategy:Contest pages|Contest]]

* Strategy-specific pages:
** [[Strategy:Giftdropping|Giftdropping]]

== Modding Community ==
* [[Modding:History|History]]
* [[Modding:Documentation|Documentation]]
* [[Modding:Tutorial|Tutorial Series]]

Strategy:Arachnotron

2012-02-14T15:31:40Z

Game Hunter: some spacing to differentiate between entries

'''Overview'''

The Arachnotron is a ranged attacker, equipped with a lowish-power (1d5x5) but somewhat accurate (+3) plasma gun. Even in the best circumstances, fighting a ‘tron in an open area is a hairy proposition, but a straight-up gunfight is seriously complicated by an Arachnotron’s 130% Speed. This essentially means that an Arachnotron will get to make (assuming normal move/act speeds for the player) 4 actions for every 3 of your actions. Generally, these actions will be to fire upon the player should s/he be in view, and those extra actions have a nasty tendency to appear at the exact worst times.

Arachnotrons are fairly durable with 50 hitpoints and 2 points of armor, so fairly heavy firepower is necessary to bring one down efficiently. However, their high speed results in an enemy that can lay down a very heavy field of fire. Circlestrafing or sidestepping is somewhat effective, but two factors work against the player who attempts this. First, the sheer number of shots an Arachnotron can put downrange mean that at least a few bolts will hit you eventually, and Arachnotrons are frighteningly good at getting their extra action while firing on the player.This extra action essentially means that the Arachnotron will get a free cheap shot on a “stationary” player, since the player did not move immediately prior to the Arachnotron’s last move. (For more info, take a look at Dodge) Needless to say, this is very bad for the player.

'''Combat Tactics'''

Now that we know what we’re up against, how do we go about killing these things? As noted above, Arachnotrons are pretty tough, so we’ll probably need a few actions to bring one down. The threat of being counter-attacked should always loom large, so most of our tactics should generally involve firing such that our foe cannot retaliate.

Early-game (Hell’s Armory, ordinary floors at higher difficulty levels), your best bet is some flavor of shotgun and corner-shooting. Shotguns serve very well by permitting the player to attack blindly, and by knocking back the Arachnotron, forcing it to spend an action getting back into position. Knockback can also sometimes be used to push an Arachnotron into acid or lava, killing it more quickly, but often destroying their plasma cells in the process. If an Arachnotron is dumb enough to close into melee range while you have a shotgun equipped, you should think twice before firing at point-blank range. If the ‘tron is badly injured, and you’re certain that your next blast will kill it, then go ahead and fire. Alternatively, if the ‘tron is against a wall and won’t be knocked back, go to town- this particular foe is weak in melee. However, if the Arachnotron is fairly healthy and has a space to be knocked into, you may want to switch weapons- the danger is that you’ll knock the ‘tron out of melee range and it’ll melt you with easy short-range fire on a stationary target.

I generally don’t endorse using rapid-fire weapons against ‘trons unless your build really takes advantage of them. A chaingun in untrained hands will be a difficult and painful gunfight; a plasma rifle should do a bit better owing to the increased damage and armor reduction, but it’ll still be messy. Any rapid-fire master trait (especially Ammochain) lets a player go just about toe-to-toe with a ‘tron, generally by wasting the ‘tron first. Blind-firing into a known position is a fully viable strategy, but may be expensive, ammo-wise. Staying out of an Arachnotron’s sights is generally worth the ammo investment, and plasma users might be able to break even.

An unmodified rocket launcher is a rather poor choice for slaying ‘trons, but pretty much any practical mod setup or special rocket launcher is quite effective. A non-exhaustive list of “good” mod setups would include: 1 bulk mod, a micro launcher, or a tactical rocket launcher. Alternatively, a couple levels in Reloader will work; offsetting that slow reload time is crucial to using rockets against Arachnotrons. Since they already have the potential to double-act, the base reload time only makes that problem worse should you choose to reload at a bad time. Actually fighting Arachnotrons with rockets is pretty simple: check range, aim, shoot, reload and repeat. Rockets should usually deal knockback, and an Arachnotron engaged at the edge of viewing range should seldom retaliate effectively, if at all. 3 rockets will usually do the job, but will destroy the plasma cell drop.

The BFG 9000 is OVERKILL, and if you’re pointing one at an Arachnotron, it better have a lot of nearby ugly friends, or you better be sitting on a trainload of extra cells. The same problem with the rocket launcher (reload time) is also an issue for BFGs.

The last engagement option is to get up close and bash an Arachnotron’s ugly face in with a melee weapon. Surprisingly, this is a pretty good idea: Arachnotrons have -100% (yes, that is a negative) resistance to melee damage. Anybody can easily dispatch a ‘tron with a chainsaw, and a trained Brute can punch one out with little trouble. Arachnotrons can hit back for moderate damage, but it is a lot less than their ranged attack. Of course, the only problem is getting close…

Also, switching to your best armor is seldom a bad idea, just in case. This usually means Red Armor, or something with Plasma resist (if you’ve gotten lucky).

'''Other Considerations'''

Defensive traits such as Ironman and Tough as Nails don’t exactly shine against Arachnotrons, but the extra tankiness is the unsung hero that will keep you alive during a firefight. I typically take Ironman after getting a master trait on just about every build I do. Brute can be valuable as well, but charging an Arachnotron just for the sake of getting a melee kill is a bad idea; baiting a ‘tron into chasing you can simplify the “closing-in” problem, but you may take some hits. Dodgemaster is actually less helpful than you would think, since Arachnotrons attack in bursts, and the trait only affects the first dodge per incoming attack. Rank 2 in Intuition is always good, perhaps even too good- the application should be pretty obvious. Gun Kata has the potential to ruin Arachnotrons so long as your pistols have the capacity to kill your target in one clip. Ammochain is a time-tested classic trait; the near-zero ammo consumption combined with a well-modded weapon allows a player to easily outshoot ‘trons. If you’ve managed to get a really good suit of armor Survivalist has the potential to be absolutely hilarious and can totally negate an incoming volley.

One other thing: Arachnotron Caves (shudder). These fiendish levels have ended many a game for unfortunate Doomguys everywhere. ‘Tron Caves are seldom simple, and a lot of times your best bet is to simply try and bolt for the stairs or pop a Homing Phase. If you feel confident in your gear and your supplies, clearing the cave presents both challenge and opportunity. The challenges lie in the fact that caves combine huge open areas with lots of blind corners. Radar shoot where possible and try and stay behind cover if using shotguns. There are positions where you can see your target but they cannot see you (and thus cannot retaliate); these positions are not intuitive or easy to communicate, but can be figured out over time. If using a well-kitted rocket launcher (or derivative), try to isolate and snipe ‘trons individually just as they enter vision. This is often easier said than done, but a Missile Launcher really helps. Rapid-fire gunners should simply try and stay in cover and poke at Arachnotrons when they wander into view; gunners typically have the firepower to quickly dispatch ‘trons but nobody can really afford to get shot up. Of course, the opportunity presented is the pile of power cells that the Arachnotrons will drop, and occasionally loot and powerups on the floor. [[User:IronBeer|IronBeer]] 19:02, January 27 2012 (GMT)

Arachnotrons are mean little spiders. Their dealing plasma damage makes them a threat, but 1d5 damage per projectile isn't the end of the world. What's really amazing is that they have 50 health and 2 armor, so they'll take a pretty good beating before going down. Their 130% speed puts them on par with demons, but realize that this affects their firing speed as well as their movement speed. Corner shooting an arachnotron with a combat shotgun is one of the safest ways to take out an arachnotron with ordinary weapons, but in a pinch a rocket launcher is effective, as is a BFG if can spare the cells. Fighting an arachnotron out in the open is dangerous (though this is true against most enemies), but sometimes it is unavoidable; this is really when bringing out the rocket launcher is nice. Some people recommend activating run mode to avoid their projectiles more, but I don't think it's necessary unless you're going to run for cover or are fighting against multiple enemies. I am personally rather stingy with run mode, however, so it could be something to try.

Arachnotrons take double damage from melee and deal rather pitiful melee damage themselves, so killing them with melee is a decent option as long as you have at least a combat knife (though if possible I'd recommend just corner shooting with shotguns if a knife really is your best melee weapon; chainsaw is more doable). If you find yourself a couple of spaces away from an arachnotron with no cover immediately available, charging into melee range is probably your best option (running mode not necessary, in my opinion). Another way to get them into melee range is to just wait around a corner and shoot them to get their attention, and wait. Charging into melee towards an arachnotron at the edge of your vision is just asking for trouble though: you'll be taking plasma volleys, and in general charging into melee exposes you to fire from other enemies, especially ones that were out of sight behind the one you're after.

The worst case scenario is finding an arachnotron cave. Lots of spiders, lava, and a lack of decent cover makes clearing out the cave a formidable task. Some people would advice phasing past the level or running for the stairs, but I like making enemies dead, so let's assume that option is off the table. How can one clear out an arachnotron cave and live to tell about it? Well, the first step is usually going to be to find cover immediately, and it's a difficult step. This is a time where I'd recommend activating run mode if there's any arachnotrons around you. Hurry behind any group of rocks you see, and if you have a rocket launcher or even a BFG, this is a good time to bring it out. A melee weapon can actually be really useful here, as there will often be situations where an arachnotron comes sneaking around the corner of your rock cover, where he's too close to blow up (except with a BFG which doesn't hurt you) and where you can't corner shoot him with a shotgun. If you blast it with a shotgun, you'll just be knocking it back, and you won't be in a position to corner shoot, while it will tear you apart with plasma. It will be just a few steps away from melee range though, and melee doesn't cause knockback and will make the arachnotron fall fast. From your cover, try to corner shoot those spider bastards when possible, shoot them with rockets when you're in their line of fire, and melee them if they sneak up on you (probably not with your fists though). [[User:Matt_S|Matt_S]] 00:24, February 02 2012 (GMT)

Some facts, copied from wiki: 130% speed, (1d5)x5 plasma damage, +3 accuracy, 60% chance to attack, -100% melee resistance, 1d3+2 melee damage

As you can see, enemy is fast,very dangerous in ranged combat and pathetic in melee.
Basic plan is simple - don't let it shoot you.Get behind the corner, or knock it back outside your FOV, or get to it.Even if you are incompetent in melee and don't have any melee wapons, it's still worth it.Just shoot it while it hits you(be careful not to knock it back though!).Pretty simple i think.

And now about caves - main source of hate for these guys.
Two main strategies: running and sidestepping.Running implies -4 penalty to enemies' accuracy and gives bonus to dodge chance during sidestep.

On HNTR and HMP arachno caves are not that common and they spawn deep enough for you to be prepared for such encounters.BFG from halls of carnage is guaranteed and it works as good as always.Also number of spiders is not that big usually.

Whole 'nother thing is UV and N!. Lvl7 on UV, lvl6 on N! - that's how early i saw caves on that difficulties.
Number of enemies is high - 6 and more - this number is not a fact, it's just rougly based on my experience.
Now they have total +5 accuracy which means 74% chance to hit on the edge of your vision.That means if you are not running and not sidestepping then expect to get hit 4 times out of 5(Since they'are not always on max range).
So if you have 0 armor, 4 arachnotrons can kill you in one turn if you decide on fighting them directly.
Your usual weapons during early arachnotron cave encounter: pistol, shotgun, chaingun, rocket launcher if HA's completed, chainsaw.
None of these is enough to kill them before they kill you.
That leaves you with only one option if you spawn in the middle - tactical retreat.Running somewhere where they can't swarm you.

Start running and carefully sidestep.If you're not sure if your next move is sidestep,or if it's impossible to sidestep all attacks, think and choose best possible.If you can get to you destination in 1 non-sidestep, better do two sidesteps.Hoping that several arachnotrons will all miss is silly, while actually sidestepping all attacks from 2 arachnotrons is quite possible and happened to different people.

Stairs/Invul globe - if you manage to get to it, you're safe.Do not even think about taking small health globes if you'are under enemy fire.Since they restore you from running to normal, arachnotrons again have +5 accuracy instead of +1, and since you spend your move not on sidestep, you'll lose much more than you could gain.Taking large health globes is safer, but even that can kill you.Same thing about using med-packs - beware of using them without cover.Being Technician here is a great help, as you can switch to running back after 0.1s of not-running.Taking berserk pack is safe, but against arachnotrons it's not as effective as usual as each hit will deal at least 1 damage.If you don't see stairs or nice powerup, run to cover.If you don't see one, then hope that you'are running towards something useful - there's not much else to say in such situation. [[User:AlterAsc|AlterAsc]] 15:34, February 03 2012 (GMT)

Strategy:Juggler

2012-02-14T15:31:08Z

Game Hunter: added contest entries

'''General'''

If you're like me and like to carry several different weapons at once, Juggler can really come in handy. Juggler has 2 main parts, each with their own benefits.

First, Juggler lets you use swap your current weapon with your prepared one instantly. Normally, this would take 8/10 a second of time, which means that you can switch from your long range plasma rifle to your close range double shotgun if a monster suddenly appears next to you, without letting it get a free hit. Very useful against Lost Souls, as they almost always get free turns since they are so fast. This also means that swapping weapons this way (or by quickkey) no longer counts as a turn, which can save precious timewhen going for Icarus Cross medals or when under the effects of berserk, invulnerability, envirosuit packs, or light amp, which have durations in turns (if it takes less than 0.1 seconds to do, it doesn't use up a turn).

The second part of juggler lets you switch between the common weapons in your inventory instantly. This means that you don't have to have your second weapon in your prepared slot if it's one of the 8 common weapons (Combat Knife, Pistol, Shotgun, Combat Shotgun, Double Shotgun, Rocket Launcher, Chaingun, or Plasma Rifle) or the chainsaw or BFG9000. This means that you can have a ammo box in the prepared slot and still take advantage of the Juggler bonus by using the quick keys. One very useful thing this does is that it allows you to get the common weapon upgrades -- combat knife to chainsaw, shotgun to combat shotgun and/or double shotgun, chaingun to plasma rifle, and anything to BFG9000 (on bosses) ready faster. If you have Juggler before getting to the Chained Court, you can pick the chainsaw up, swap it to the prepared slot, then quickkey swap another weapon in your main weapon slot. You just picked up the chainsaw and readied it and another weapon all in 1 second and still have it ready to tear monsters apart at any time.
What's really awesome is that Juggler will work with Assemblies too! Chainswords, High Power Weapons, and other assembled items can be swapped by using the quickkey for the base item.

With Juggler, you can equip and use several different weapons in a row without worrying about reloading in the middle of combat or spending time switching weapons. It works well against pain elementals and the swarms of lost souls they can produce. Start with a room clearing weapon -- the double shotgun (or any shotgun really, but the double shotgun's wide spread make it work well). Fire it, then switch to a rapid fire weapon (like the chaingun, or, better, the plasma rifle). A prepared melee weapon can be used to take care of any lost souls that actually reach you.

As a convienence factor, the juggler skill lets you attack with a melee weapon if you have it in the prepared slot (so you don't have to keep switching back and forth manually), although manual switching will still be required if you plan on having an non-melee exotic or unique on deck in the prepared slot for instant switching.

There are a few points that make Juggler flexible and a viable option on most builds. The first is that it's available as early as level 2 no matter what class you pick, since it only requires 1 point in Finesse. The second is that only two master traits block Finesse, and therefore block Juggler: Army of the Dead and Entrenchment. Therefore, juggler is a nice complement that allows you to access most of the tools you need when you need them, without letting the monsters get a turn. [[User:shark20061|shark20061]] 20:32, February 2 2012 (GMT)

The ability to switch weapons instantly might seem minor at first glance, but it can be a lifesaver, or at least an ammo saver, in any game. Depending on the situation, you may want to use a shotgun to knock something back or spray a group of small enemies, or you might want to use a plasma gun to get something big dead fast, (such as an Arch-Vile) or you might want to use a chaingun for some precision shooting that isn't serious enough to warrant a plasma gun, (such as a Demon next to a barrel that you don't want to blow up since it might destroy useful items) or a rocket launcher to disperse large groups of enemies. Being able to switch rapidly and repeatedly in the middle of a battle can be essential in order to have the right weapon out at the right second, especially if you empty a weapon and it would be too dangerous to take the time to reload.

The benefits are limited somewhat by the fact that you only get instant switching with the most basic (numbered) weapons, so it's beneficial to make assemblies with them so you have decently powerful weapons to juggle. You can include one exotic/unique weapon in your jugglable line-up if you keep it in your prepared slot when you're not using it. (since Juggler allows instant swapping) Just remember to swap the exotic/unique back into the prepared slot when you want to switch back to your basic weapons.

An additional benefit introduced in version 0.9.9.5 is the fact that, if you have multiple of one kind of weapon in your main inventory, using the number keys to select your basic weapons now selects the one with the most ammo. (In previous versions, it would select the one with the *least* ammo which would mean you would frequently pull out empty weapons which was as useless as it was frustrating) This means you can now, for example, have multiple Chainguns in your inventory and if you empty one, instead of taking 2.5 seconds to reload, you can instantaneously switch to the next one and keep firing without a break! In order to take advantage of this strategy, there are a couple of things to remember: Using my above example with the Chainguns, after emptying one of them, you would have to first pull out a different weapon, say a shotgun by pressing 3, before pressing 6 to pull out the full Chaingun. This is because pressing 6 while you're wielding the Chaingun produces the message "you already have the chaingun in your hands" and nothing happens. The additional step of pulling out the shotgun is also instantaneous, though, so it doesn't really impact gameplay. The other thing to remember is that if the empty Chaingun is in the prepared slot, the game will default to swapping rather than switching to the full one in the main inventory. You will have to do a bit of juggling to get the empty one out of the prepared slot before you can take advantage of the ability to instantly switch to the full one.

The fact that Juggler automatically uses a melee weapon in the prepared slot doesn't usually have an advantage unless you happen to have a unique melee weapon, since you can instantly switch to combat knives and chainsaws anyway. It does have a use in helping achieve medals and badges that require fists only, though, since, for example, if you have a Chainsaw in the prepared slot while your hands are empty and you have Juggler trait, you will do Chainsaw damage to your enemies, but the game will consider them fist kills. This makes fist-only challenges a lot easier! [[User:Tormuse|Tormuse]] 10:26, February 6 2012 (GMT)

Strategy:Former commando

2012-02-14T15:28:42Z

Game Hunter: added contest entry

{{infostrat switch}}
Former commandos are the toughest of all formers, and one of the deadliest enemies throughout the whole game. With a good enough accuracy and a plasma rifle in their hands, they can easily take you down in two volleys. Their ranged offensive power is something to be afraid of, but they share all formers offensive weakness - their pitiful melee attack.

On the defensive side they do not go down easily as well. They have natural two points of armor and will happily grab and wear any armor from the ground to become even more hardy. Their double health, compared to other formers, doesn't help either.

So how to deal with them? If possible, don't allow them to get a shot at you. When you see one, retreat behind a corner and wait for them to come into melee range. [[Strategy:Giftdropping|Gift-dropping]] can help a lot, cornershooting can beat them down a bit before they come close. But beware of knockback of your weapons - you don't want to push them away and let them shower you with plasma.

The best position you can get them in is this:

###h
# #
###
@

or

###
# #h
###
@

This works for any side of any corner. In these positions, the commando cannot attack you and potencial knockback (for example from shotguns) will send them back along the wall.
* If retreat to a safe position is not a viable option, you may simply want to whip out the biggest weapon at your disposal and try to one-hit-kill them.

Weapon considerations:
*Melee: Commandos are pushovers in melee combat, but you have to get to their melee range or lure them to you. Again, gift-dropping and waiting around a corner is probably the best idea. Or simply leave them alone.
*Pistols: Pistols, unless heavily modded, exotic or unique, are very weak against commandos. An unmodded standard pistol would need seven bullets on average to kill them. Thus, it's definitely wise to retreat if you meet one in the open. Unless you can use any of the strategies mentioned before, that is.
*Shotguns: These fare better against commandos. A double shotgun can fairly reliably kill them point-blank in one shot (approx. 70% chance).
On the other hand, if you find one on the edge of your line of sight, even a normal shotgun has a good chance of knockback. With the commandos normal speed, they will then return to your line of sight on your reload without firing. This can be a bit ammo-consuming though.
*Rapid-fire weapons: Chaingun will not make it for you. It takes three volleys on average to kill a commando, and you may not get the chance to fire three times. Plasma gun works quite better - the chance to kill a commando is about 55% when all the shots hit.
*Rocket launcher: a standard rocket has slightly below 50% chance of one-hit-kill, and even if it does not kill the commando right away, it will push it back. Then you can just wait for it to come into your line of sight again to kill it with a second rocket.
*BFG 9000: Nearly 100% chance to kill a commando in one hit. And you'll get those 40 plasma cells back if it's plasma rifle is not destroyed in the blast.

There are two more considerations:
* Sometimes commandos spawn with a pack of 4-6 former humans and sergeants. If you happen to start a level close to them, and you can't retreat, they should be your top kill priority.

* Commandos wield a plasma gun that is left for you to take after their death. On Nightmare! and Angel of Darkness they ressurect with a new, fully loaded one, so farming one commando for plasma cells is a viable option. [[ZicherCZ|ZicherCZ]] 12:00, February 03 2012 (GMT)

Strategy:BFG 9000

2012-02-14T15:27:05Z

Game Hunter: added contest entry

{{infostrat switch}}
BFG9000, the ultimate in conventional DoomRL warfare, is highly efficient against practically any foe, but consumes ammunition like there's no tomorrow.

A few tips on efficient use:
* BFG is the best weapon to use against targets you want to take out really quickly. [[Arch-vile|Archviles]] (doubly so those in the Mortuary) or [[Mancubus|mancubi]] can serve as a prime example, although, more likely than not, these would require two shots to go down. If you don't mind a bit of an overkill, you can, with near-certainty, take out those nasty [[Former_commando|former commandos]] and [[Revenant|revenants]] in one shot as well. [[Cyberdemon|Cyberdemon]] will then die (on average) after 5, 6, 7, 9 and 11 shots (with growing difficulty level). For the [[Spider Mastermind|Mastermind]] and [[John_Carmack|JC]] add 1 to Cyberdemon's numbers.
* If at all possible, try to hit multiple foes at once. The explosion radius of 10 is a definite help to this.
* If you happen to find another BFG, take it to save space in your inventory.. Its clip can hold 100 plasma cells, while an inventory slot can hold only 50 (70 with [[Backpack|backpack]]).
* Bulk-modding the BFG once increases the number of shots without reloading from two to three, which can be a life-saver at times. Another bulk mod will then increase this number to four, another one to five, fourth to seven and fifth then to nine (the exact clip sizes are 130, 169, 219, 285 and 371). With regards to the previous tip, a spare B5-modded BFG can hold more plasma cells than seven inventory slots. [[ZicherCZ|ZicherCZ]] 16:55, February 03 2012 (GMT)

Strategy:Arachnotron

2012-02-14T15:24:53Z

Game Hunter: added contest entries

Levels

2012-02-03T18:57:29Z

Game Hunter: updated enough to remove tag

__NOTOC__
Levels are the heart of DoomRL, and without them there would be no game. It is where the player explores, where enemies roam, where special items lie in wait. They are filled with either fortune or your own personal doom.

==Basic Objects==
All levels are made of basic objects like floors, walls, and doors.
*'''HP''': This is one of the parameters that governs how difficulty the object is to destroy. Whenever an object takes damage, it's HP is decreased. Once its HP falls to 0, it changes to a floor tile. Some objects cannot be destroyed; these are indicated as "none". Also, some objects have two versions: one that can be destroyed and one that can't.
*'''Armor''': This also makes objects harder to destroy. Whenever an object takes damage, the object's armor is subtracted from the damage before the damage is subtracted from HP. Unlike the armor of the player and his enemies, objects' armor may reduce damage to 0.
*'''Fragile''': Objects can usually only be damaged by [[Damage type#plasma|plasma]], [[Damage type#fire|fire]], or [[Damage type#acid|acid]] damage. Fragile objects can be damaged by any damage type.

{| style="rules: cols; border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
|colspan=11 style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Basic Objects'''
|-
|style="text-align: center; padding: 1ex; border: solid darkred; border-width: 0 1px 1px 0" width=100|'''Name'''
|style="text-align: center; padding: 1ex; border: solid darkred; border-width: 0 1px 1px 1px" width=50|'''Appearance'''
|style="text-align: center; padding: 1ex; border: solid darkred; border-width: 0 1px 1px 1px" width=50|'''HP'''
|style="text-align: center; padding: 1ex; border: solid darkred; border-width: 0 1px 1px 1px" width=50|'''Armor'''
|style="text-align: center; padding: 1ex; border: solid darkred; border-width: 0 1px 1px 1px" width=50|'''Fragile'''
|style="text-align: center; padding: 1ex; border: solid darkred; border-width: 0 0 1px 1px"|'''Special'''
|- style="background: #333;"
|style="text-align: left; padding-right: 1ex; border: solid darkred; border-width: 1px 1px 0 0"|floor
|style="text-align: center; border: solid darkred; border-width: 1px 1px 0 1px"|'''·'''
|style="text-align: center; border: solid darkred; border-width: 1px 1px 0 1px"|none
|style="text-align: center; border: solid darkred; border-width: 1px 1px 0 1px"|N/A
|style="text-align: center; border: solid darkred; border-width: 1px 1px 0 1px"|N/A
|style="text-align: center; border: solid darkred; border-width: 1px 0 0 1px"|N/A
|-
|style="text-align: left; padding-right: 1ex; border: solid darkred; border-width: 0 1px 0 0"|blood
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|'''·'''
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|none
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|N/A
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|N/A
|style="text-align: center; border: solid darkred; border-width: 0 0 0 1px"|N/A
|- style="background: #333;"
|style="text-align: left; padding-right: 1ex; border: solid darkred; border-width: 0 1px 0 0"|pool of blood
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|'''•'''
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|none
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|N/A
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|N/A
|style="text-align: center; border: solid darkred; border-width: 0 0 0 1px"|N/A
|-
|style="text-align: left; padding-right: 1ex; border: solid darkred; border-width: 0 1px 0 0"|Phobos rock
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|'''.'''
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|none
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|N/A
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|N/A
|style="text-align: center; border: solid darkred; border-width: 0 0 0 1px"|N/A
|- style="background: #333;"
|style="text-align: left; padding-right: 1ex; border: solid darkred; border-width: 0 1px 0 0"|wall, blooded wall
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|'''#''', '''#'''
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|10
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|10
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|no
|style="text-align: center; border: solid darkred; border-width: 0 0 0 1px"|N/A
|-
|style="text-align: left; padding-right: 1ex; border: solid darkred; border-width: 0 1px 0 0"|bloodstone, blooded wall
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|'''#''', '''#'''
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|15
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|10
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|no
|style="text-align: center; border: solid darkred; border-width: 0 0 0 1px"|N/A
|- style="background: #333;"
|style="text-align: left; padding-right: 1ex; border: solid darkred; border-width: 0 1px 0 0"|green wall
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|'''#'''
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|15
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|10
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|no
|style="text-align: center; border: solid darkred; border-width: 0 0 0 1px"|N/A
|-
|style="text-align: left; padding-right: 1ex; border: solid darkred; border-width: 0 1px 0 0"|crate, blooded crate
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|'''#''', '''#''', '''#'''
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|5
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|5
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|no
|style="text-align: center; border: solid darkred; border-width: 0 0 0 1px"|N/A
|- style="background: #333;"
|style="text-align: left; padding-right: 1ex; border: solid darkred; border-width: 0 1px 0 0"|closed door
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|'''+'''
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|6
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|4
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|yes
|style="text-align: center; border: solid darkred; border-width: 0 0 0 1px"|Can be opened.
|-
|style="text-align: left; padding-right: 1ex; border: solid darkred; border-width: 0 1px 0 0"|locked door
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|'''+'''
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|6
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|6
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|yes
|style="text-align: center; border: solid darkred; border-width: 0 0 0 1px"|N/A
|- style="background: #333;"
|style="text-align: left; padding-right: 1ex; border: solid darkred; border-width: 0 1px 0 0"|open door
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|'''/'''
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|none
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|N/A
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|N/A
|style="text-align: center; border: solid darkred; border-width: 0 0 0 1px"|Can be closed.
|-
|style="text-align: left; padding-right: 1ex; border: solid darkred; border-width: 0 1px 0 0"|[[lever]]
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|'''&'''
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|10
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|0
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|no
|style="text-align: center; border: solid darkred; border-width: 0 0 0 1px"|see link in name for details
|- style="background: #333;"
|style="text-align: left; padding-right: 1ex; border: solid darkred; border-width: 0 1px 0 0"|barrel of fuel
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|'''0'''
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|2
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|3
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|yes
|style="text-align: center; border: solid darkred; border-width: 0 0 0 1px"|Can be pushed. When destroyed, creates a radius 4 [[explosions|explosion]] dealing 5d5 [[Damage type#fire|fire damage]].
|-
|style="text-align: left; padding-right: 1ex; border: solid darkred; border-width: 0 1px 0 0"|barrel of acid
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|'''0'''
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|2
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|4
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|yes
|style="text-align: center; border: solid darkred; border-width: 0 0 0 1px"|Can be pushed. When destroyed, creates a radius 4 [[explosions|explosion]] dealing 6d6 [[Damage type#acid|acid damage]], sometimes leaving behind acid tiles.
|- style="background: #333;"
|style="text-align: left; padding-right: 1ex; border: solid darkred; border-width: 0 1px 0 0"|barrel of napalm
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|'''0'''
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|2
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|5
|style="text-align: center; border: solid darkred; border-width: 0 1px 0 1px"|yes
|style="text-align: center; border: solid darkred; border-width: 0 0 0 1px"|Can be pushed. When destroyed, creates a radius 4 [[explosions|explosion]] dealing 7d7 [[Damage type#fire|fire damage]], sometimes (often) leaving behind lava tiles.
|}

==Random levels==
The archetypical level in DoomRL is a randomly-generated one. It is produced in such a way that no two games are particularly alike. There are many special considerations within the game engine, although many of these are technical and unimportant from a gameplay perspective.

* [[Level type]]
* [[Level feeling]]
* [[Level event]]
* [[Monster Generation]]
* [[Item Generation]]
* [[Room Generation]]
* [[Fluids]]

== Special levels ==
In stark contrast to random levels, special levels are constant and many of them appear every game. As you gain more experience playing DoomRL, these become stepping stones used as a grip against the turbulent flow of random levels.

For obvious reasons, all of these pages are considered spoilers if you wish to learn how to beat them yourself. Some are particularly spoiler-heavy, though, and are indicated as such here.

* [[Phobos Base Entry]]
* [[Hell's Arena]]
* [[The Chained Court]]
* [[The Wall]]
* [[Phobos Anomaly]]
* [[Hell's Armory]]
* [[Halls of Carnage]]
* [[City of Skulls]]
* [[Spider's Lair]]
* [[Tower of Babel]]
* [[Unholy Cathedral]] (SPOILERS!!!)
* [[The Vaults]]
* [[The Mortuary]] (SPOILERS!!!)
* [[The Lava Pits]]
* [[Dis]] (MAJOR SPOILERS!!!)
* [[Hell Fortress]] (MAJOR SPOILERS!!!)

===Special level placement===
Some levels don't spawn on I'm Too Young To Die: Hell's Armory, Unholy Cathedral, The Vaults, and The Mortuary.

Special stairs are always placed on a random empty tile.

In 0.995, the generation of special levels is changed - all special levels (with respect to the I'm Too Young To Die restriction) are guaranteed to appear in the game. Also, the generation depth of special levels is now as follows:

{|
|'''Level'''
|'''Range'''
|-
|Hell's Arena
|2-3
|-
|The Chained Court
|4-5
|-
|The Wall
|7
|-
|Hell's Armory
|10
|-
|Halls of Carnage
|11-12
|-
|City of Skulls
|13
|-
|Spider's Lair
|14
|-
|Unholy Cathedral
|17
|-
|The Vaults
|18-19
|-
|The Mortuary
|20
|-
|The Lava Pits
|22
|}

Strategy:Contest pages

2012-02-02T20:44:46Z

Game Hunter: current contest moved back a day

This page contains all Strategy-based pages included in the strategy contest (found [http://forum.chaosforge.org/index.php/topic,4867.0.html here] on the Chaosforge forums), as well as any winners for them. It also contains information regarding the contest.

==Contest Rules==
Entries will be graded on the merit of the information given, rather than its sheer volume. While it is true that a large and informative entry will likely be marked higher than a small and informative entry (simply because it contains more amounts of useful information), '''the key factors that attribute to a successful entry are''':
*Detail - either in having many possible strategies, or explaining the various considerations of a given strategy
*Originality - creativity, regarding both the strategy itself and how it is presented
*Accuracy - up-to-date for the current public version, and valid as a strategy itself
*Comprehension - one with basic knowledge of game [[mechanics]] (and, if necessary, an accompanying Game Data page) should understand the strategy
*Focus - keep to the scope of the topic at hand

'''All entries should be emailed to [http://mailto:theuberhunter@gmail.com theuberhunter@gmail.com]''' using the following format:
*The subject line should read "[WIKICOMP#X] Strategy:" (minus quotes, where X is the competition number), followed by the topic
**example: [WIKICOMP#1] Strategy:Rocket launcher
*The entry itself can either be written in the body of the email, separate from the rest of the email's content, or as a document file attached to the email. For procedures on formatting, refer to the formatting guidelines just after the rules.
*Include a username somewhere in the email. Your forum name is recommended (and necessary, if you want to get your prize) but any name will do. If no username is given, it will default to the email address of the submission.

After submitting the email, a reply should be added to the forum topic, stating that (in so many words) you have entered a submission for the current contest. If there is more than one topic for the current contest, also name the topic (or topics) for which you wrote an entry (or entries). While this is not required to enter, it is necessary as validation so that the prize is handed out to the appropriate member. Alternatively, you are allowed to submit your entry through the forum topic, though this carries the risk of letting other contestants view your entry before the deadline has been reached.

Prizes will be determined on a per-topic basis. Some topics will be worth more (in terms of their prize) than others. '''The contest judge (Game Hunter) reserves the right not to award a prize for a given topic in a given contest if none of the entries are of sufficient quality to be worthy of the prize given.'''

A player can submit an entry for each topic during a contest, and can potentially receive the prize for each one. '''Multiple entries should be submitted separately: one email per topic.'''

Each contest will accept entries for about one week: '''the deadline will always be Midnight GMT of that day''' ([http://wwp.greenwichmeantime.com see here for the current GMT time]). After the deadline is reached, there will be, at most, a one-week period during which submissions will be examined and a winner for each topic will be determined. After the grading period, prizes will be handed out to winners.

Regardless of the winner, all entries will have their strategies added to the Wiki. These will initially be posted immediately after the contest ends, ordered by date. After all entries are graded and a winner is chosen, the winner's strategy entry will be placed at the top of the page (with the others left unmoved). This entry will then be used as the basis on which to add other components of strategy: the other entries will eventually be merged into this entry (and will be handled by Game_Hunter).

==Formatting Guidelines==
Entries are expected to be written in a format appropriate for Wiki reading. A good starting place for this is to use a very basic text program such as Notepad. You can also try to write your entry on the Wiki itself, using "Show Preview" to check for errors, then copy-paste it as your entry.

Basic etiquette is as follows:
*Do not use typical indentations under any circumstance. Indentations using the TAB key have no effect on the display here, and indentations created with spaces are meant for a different task. If you really want indentation, add a colon (:) where the indent would go.
*Do not use any program-specific stylizations. Wikipedia standards have [http://meta.wikimedia.org/wiki/Help:Editing their own procedures] for the styles you may want. You are free to use these in your entry if you believe they will improve the organization of what you are writing. (Here are [http://meta.wikimedia.org/wiki/Help:Wikitext_examples additional examples] if you need a full range of possibilities.)
**The exception of this format is that you should not use section-based formatting (for example, <nowiki>==Title==</nowiki>) as this is reserved for possible segmentation of the strategy page itself.
*Paragraphs should be of an appropriate length. If a paragraph is too short, attempt to merge it with another paragraph containing similar ideas. If a paragraph is too long, either split it into separate paragraphs or use a bullet-point format. This is often expected not just on Wikis but on any Internet forum as well.
*Remove any word-wrapping before submitting an entry. Otherwise the transfer to the Wiki will require a few thousand backspaces, because the copy-paste was messed up due to the way that word-wrapping handles spaces.

==Current Contest==
===Status===
Entry period: submissions will be accepted no later than February 4, 2012 at Midnight (GMT).

===Topics===
#[[Strategy:Arachnotron|Arachnotron]] (prize USD10)
#[[Strategy:BFG 9000|BFG 9000]] (prize USD10)
#[[Strategy:Juggler|Juggler]] (prize USD10)
#[[Strategy:Former commando|Former commando]] (prize USD10)

==Past Contests==
===November 9-16, 2011===
#[[Strategy:Rocket launcher|Rocket launcher]] (winner: [[User:GrimmC|GrimmC]])
#[[Strategy:Intuition|Intuition]] (winner: [[User:theduck101|theduck101]])
#[[Strategy:Demon|Demon]] (winner: [[User:Elephant|Elephant]])

===November 18-27, 2011===
#[[Strategy:Combat shotgun|Combat shotgun]] (winner: [[User:GrimmC|GrimmC]])
#[[Strategy:Shottyman|Shottyman]] (winner: [[User:theduck101|theduck101]])

===January 8-16, 2012===
#[[Strategy:Double shotgun|Double shotgun]] (winner: [[User:Kashi|Kashi]])
#[[Strategy:Reloader|Reloader]] (winner: [[User:AlterAsc|AlterAsc]])
#[[Strategy:Pain elemental|Pain elemental]] (winner: [[User:Tormuse|Tormuse]])

Modding:Item

2012-02-02T19:39:49Z

Game Hunter: updated for 0995

DoomRL has many kinds of items. Weapons, powerups, levers, and other things are all items. Items inherit from the [[Modding:Thing|Thing]] class which handles some basic properties in common with beings.

== Prototype ==
New items are created from item prototypes. Think of an item prototype as a recipe for creating new items. There can be multiple pistols, but they all came from the same prototype. Prototypes are declared by passing a table with the desired properties to the Items function. The available properties depend on the item type. [[#Engine Hooks|Engine hooks]] may also be included in the prototype. Mostly, the prototype's properties just describe items' initial properties (occasionally with different names). Items' properties can also mostly be changed after they are instantiated. Required fields are underlined. Sometimes required fields can safely be omitted, but this will generate a message in the log file. All item prototypes are stored in a global table called items. This table can be indexed by id or nid.

{{drltable|Item Prototype|3|{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|{{modarg|string}}|name|This is the item's name.
|{{modarg|string}}|id|This is the item's sid. It must be distinct from other string ids. (The numeric id is automatically generated and stored in the nid field of the prototype.) It defaults to the first word of the name in all lowercase.
|{{modarg|value list}}|overlay|This describes of color transformation of the item's sprite. It is only used in the graphical version. This will create overlay_red, overlay_blue, overlay_green, and overlay_alpha attributes for the prototype.
|{{modarg|Color}}|color|This is the item's color. The default is LIGHTGRAY.
|{{modarg|string}}|color_id|For the purpose of custom color bindings, this id will be used for the item. Multiple items (like levers) can have the same color_id to prevent them from being distinguished.
|{{modarg|integer}}|level|This is an [[Item Generation|item generation]] parameter. The default is 0.
|{{modarg|integer}}|weight|This is an [[Item Generation|item generation]] parameter.
|{{modarg|integer}}|sprite|This is the item's sprite. This field is only relevant to the graphical version; use 0 for no sprite.
|{{modarg|value list}}|coscolor|Some sprites (such as armor and boots) are color-neutral to begin: ''coscolor'' determines the color of the sprite in these cases. The list must be written in this form: {red,green,blue,alpha}, where all of these values range from 0.0 to 1.0.
|{{modarg|value list}}|glow|Creates a customized "glow" effect around the sprite. See ''coscolor'' for table specifications.
|{{modarg|Item Flag List}}|flags|The flags in this list will automatically be included in the item's flag set. The default is an empty list. Some flags may be added automatically. The prototype will automatically be given a flagSet property containing the flags in set format.
|{{modarg|ItemSet ID}}|set|If included, this item will belong to the given item set. This will modify the item's OnEquip and OnRemove hooks.
|{{modarg|string}}|firstmsg|If included, this message will be displayed when the an item with this prototype is picked up for the first time. This will modify the item's OnFirstPickup hook.
|{{modarg|integer}}|res_bullet|This is the item's res_bullet. The default is 0.
|{{modarg|integer}}|res_melee|This is the item's res_melee. The default is 0.
|{{modarg|integer}}|res_shrapnel|This is the item's res_shrapnel. The default is 0.
|{{modarg|integer}}|res_acid|This is the item's res_acid. The default is 0.
|{{modarg|integer}}|res_fire|This is the item's res_fire. The default is 0.
|{{modarg|integer}}|res_plasma|This is the item's res_plasma. The default is 0.
|{{modarg|ItemType}}|type|This is the item's itype. It also determines which other properties can be used in the prototype.
|}}
}}

=== Armor or Boots ===
These are the fields used by ITEMTYPE_ARMOR and ITEMTYPE_BOOTS.

{{drltable|Armor or Boots Prototype|3|{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|{{modarg|string}}|desc|This is the armor's description that is displayed in the inventory screen.
|{{modarg|integer}}|armor|This is the armor's armor property.
|{{modarg|integer}}|durability|This is the armor's maxdurability as well as its initial durability. The default is 100. (This should still be 100 for armors with no durability, as no durability is achieved by a flag.)
|{{modarg|integer}}|knockmod|This is the armor's knockmod. The default is 0.
|{{modarg|integer}}|movemod|This is the armor's movemod. The default is 0.
|{{modarg|string}}|ascii|This is the armor's picture. It should be a length one string. The default is "[" for body armor and ";" for boots.
|}}
}}

=== Consumable ===
These are the fields used by ITEMTYPE_PACK. This includes mods and relics.

{{drltable|Consumable Prototype|3|{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|{{modarg|string}}|desc|This is the pack's description that is displayed in the inventory screen.
|{{modarg|string}}|mod_letter|This is the shorthand letter by which the pack will be recognized as a mod. Do not fill this value unless this item is meant to be a mod pack.
|{{modarg|function}}|OnUse|Packs must provide an OnUse hook.
|{{modarg|string}}|ascii|This is the pack's picture. It should be a length one string. The default is "+".
|}}
}}

=== Powerup ===
These are the fields used by ITEMTYPE_POWER.

{{drltable|Powerup Prototype|3|{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|{{modarg|function}}|OnPickup|Powerups must provide an OnPickup hook.
|{{modarg|string}}|ascii|This is the powerup's picture. It should be a length one string. The default is "^".
|}}
}}

=== Ammo ===
These are the fields used by ITEMTYPE_AMMO.

{{drltable|Ammo Prototype|3|{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|{{modarg|string}}|desc|This is the ammo's description that is displayed in the inventory screen.
|{{modarg|integer}}|ammo|This is the ammo's initial ammo property.
|{{modarg|integer}}|ammomax|This is the ammo's ammomax property.
|{{modarg|string}}|ascii|This is the ammo's picture. It should be a length one string. The default is "|".
|}}
}}

=== Ammo Pack ===
These are the fields used by ITEMTYPE_AMMOPACK.

{{drltable|Ammo Pack Prototype|3|{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|{{modarg|string}}|desc|This is the ammo pack's description that is displayed in the inventory screen.
|{{modarg|integer}}|ammo|This is the ammo pack's initial ammo property.
|{{modarg|integer}}|ammomax|This is the ammo pack's ammomax property.
|{{modarg|string}}|ammo_id|This is the ammo pack's ammoid property.
|{{modarg|string}}|ascii|This is the ammo pack's picture. It should be a length one string. The default is "!".
|}}
}}

=== Ranged Weapon ===
These fields are used by ITEMTYPE_RANGED.

{{drltable|Ranged Weapon Prototype|3|{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|{{modarg|string}}|desc|This is the weapon's description that is displayed in the inventory screen.
|{{modarg|string}}|damage|This should be a string like "2d4"; the weapon's damage_dice and damage_sides will be parsed from this.
|{{modarg|DamageType}}|damagetype|This is the weapon's damagetype.
|{{modarg|string}}|psprite|This is the projectile sprite used with the weapon. It is only relevant in the graphical version.
|{{modarg|string}}|group|This is the weapon's group for purposes of kill counting. The used weapon groups are "weapon-melee", "weapon-pistol", "weapon-shotgun", "weapon-chain", "weapon-rocket", "weapon-plasma", and "weapon-bfg". The default is "weapon-other".
|{{modarg|string}}|ammo_id|This is the weapon's ammoID.
|{{modarg|integer}}|fire|This is the weapon's usetime. The default is 10.
|{{modarg|integer}}|acc|This is the weapon's acc. The default is 0.
|{{modarg|integer}}|ammomax|This is the weapon's ammomax and the weapon's initial ammo.
|{{modarg|integer}}|radius|This is the weapon's blastradius. The default is 0.
|{{modarg|integer}}|shots|This is the weapon's shots. The default is 0 (which will still give one shot).
|{{modarg|integer}}|shotcost|This is the weapon's shotcost. The default is 0 (which will still require one ammo).
|{{modarg|AltFire}}|altfire|This is the weapon's altfire. The default is ALT_NONE.
|{{modarg|AltReload}}|altreload|This is the weapon's altreload. The default is RELOAD_NONE.
|{{modarg|string}}|altfirename|This is the name the game uses for the weapon's alternate fire mode. Most of the AltFire constants provide defaults.
|{{modarg|string}}|altreloadname|This is the name the game uses for the weapon's alternate reload mode. Most of the AltReload constants provide defaults.
|{{modarg|string}}|sound_id|The sound_id will be used to look up sounds if there are no sounds defined for the weapon's actual id. By convention, this is set as the usual wielder's id when applicable.
|{{modarg|Missile ID}}|overcharge|This field is currently unused.
|{{modarg|Missile ID}} or {{modarg|Missile Prototype}}|missile|This is the weapon's missile. (It will be translated into an nid. To use a shotgun missile, the weapon must have the IF_SHOTGUN flag.) If this property is a table, it will be used to declare a new missile with the same id as the weapon.
|{{modarg|string}}|ascii|This is the weapon's picture. It should be a length one string. The default is "}".
|}}
}}

=== Natural Ranged Weapon ===
These fields are used by ITEMTYPE_NRANGED. Natural ranged weapons are usually defined inline in a {{modarg|Being}} definition.

{{drltable|Natural Ranged Weapon Prototype|3|{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|{{modarg|string}}|damage|This should be a string like "2d4"; the weapon's damage_dice and damage_sides will be parsed from this.
|{{modarg|DamageType}}|damagetype|This is the weapon's damagetype.
|{{modarg|string}}|group|This is the weapon's group for purposes of kill counting. The used weapon groups are "weapon-melee", "weapon-pistol", "weapon-shotgun", "weapon-chain", "weapon-rocket", "weapon-plasma", and "weapon-bfg". The default is "weapon-other".
|{{modarg|integer}}|fire|This is the weapon's usetime. The default is 10.
|{{modarg|integer}}|acc|This is the weapon's acc. The default is 0.
|{{modarg|integer}}|radius|This is the weapon's blastradius. The default is 0.
|{{modarg|integer}}|shots|This is the weapon's shots. The default is 0 (which will still give one shot).
|{{modarg|string}}|sound_id|The sound_id will be used to look up sounds if there are no sounds defined for the weapon's actual id. By convention, a natural weapon's soundID is the usual wielder's id.
|{{modarg|Missile ID}} or {{modarg|Missile Prototype}}|missile|This is the weapon's missile. (It will be translated into an nid. To use a shotgun missile, the weapon must have the IF_SHOTGUN flag.) If this property is a table, it will be used to declare a new missile with the same id as the weapon.
|{{modarg|string}}|ascii|This is the weapon's picture. It should be a length one string. The default is "?".
|}}
}}

=== Melee Weapon ===
These fields are used by ITEMTYPE_MELEE.

{{drltable|Melee Weapon Prototype|3|{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|{{modarg|string}}|desc|This is the weapon's description that is displayed in the inventory screen.
|{{modarg|string}}|damage|This should be a string like "2d4"; the weapon's damage_dice and damage_sides will be parsed from this.
|{{modarg|DamageType}}|damagetype|This is the weapon's damagetype.
|{{modarg|string}}|psprite|This is the projectile sprite used with the weapon. It is only relevant in the graphical version.
|{{modarg|string}}|group|This is the weapon's group for purposes of kill counting. The used weapon groups are "weapon-melee", "weapon-pistol", "weapon-shotgun", "weapon-chain", "weapon-rocket", "weapon-plasma", and "weapon-bfg". The default is "weapon-other".
|{{modarg|integer}}|fire|This is the weapon's usetime. The default is 10.
|{{modarg|integer}}|acc|This is the weapon's acc. The default is 0.
|{{modarg|integer}}|shotcost|This is the weapon's shotcost. The default is 0 (which will still require one ammo).
|{{modarg|AltFire}}|altfire|This is the weapon's altfire. The default is ALT_NONE.
|{{modarg|string}}|altfirename|This is the name the game uses for the weapon's alternate fire mode. Most of the AltFire constants provide defaults.
|{{modarg|Missile ID}} or {{modarg|Missile Prototype}}|missile|This is the missile used if for the throw alternate fire mode.
|{{modarg|Item ID}}|throw_id|In the case where the melee weapon can be thrown, this is the item that appears after the item is thrown. It defaults to the item itself.
|{{modarg|string}}|ascii|This is the weapon's picture. It should be a length one string. The default is "\".
|}}
}}

=== Lever ===
These fields are used by ITEMTYPE_LEVER. DoomRL levers usually also have a target_area custom property.

{{drltable|Lever Prototype|3|{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|{{modarg|string}}|desc|This is the full description of the lever used if the player has BF_LEVERSENSE2.
|{{modarg|string}}|good|This is the qualitative description of the lever used if the player has BF_LEVERSENSE1. By convention, this should be "beneficial", "neutral", or "dangerous".
|{{modarg|integer}}|fullchance|The level generation code will set the lever's target_area to the full map fullchance percent of the time. The default is 0. (To be fair, the level generation code won't generate custom levers.)
|{{modarg|string}}|warning|This message will be displayed by the level generation code if the fullchance roll succeeds.
|null|color_id|This field is required for levers. By convention, it is set to "lever".
|null|sound_id|If the particular lever doesn't have sound bindings, the game will use the sound ID to look for sound bindings. By default, this is "lever".
|{{modarg|string}}|ascii|This is the lever's picture. It should be a length one string. The default is "&".
|}}
}}

=== Teleporter ===
These fields are used by ITEMTYPE_TELE. The built-in teleport item has a custom target property. This can be set to any coord to control the destination.

{{drltable|Teleporter Prototype|3|{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|{{modarg|function}}|OnEnter|This hook is required for teleporters.
|{{modarg|string}}|ascii|This is the teleporter's picture. It should be a length one string. The default is "*".
|}}
}}

=== Flags ===
{{drltable|Item Flags|2|{{Table2Col
|es=background: #333;
|c1=font-family:monospace; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|IF_CHAMBEREMPTY|For IF_PUMPACTION weapons, this flag indicates whether ammo is in the chamber or not.
|IF_UNIQUE|This flag is set for unique items. Unique items add a player history message when picked up as well as doing a screen blink. Unique items are also not destroyable.
|IF_EXOTIC|This flag is set for exotic items. This is used by the game to compile the special items list.
|IF_MODIFIED|This flag is automatically set for items that have been modded.
|IF_HALFKNOCK|If a weapon with this flag is wielded, all knockback against the wielder will be halved.
|IF_GLOBE|This is a marker flag for items that are disallowed in Angel of Masochism.
|IF_CURSED|Items with this flag cannot be unequipped.
|IF_RECHARGE|Items with this flag regenerate ammo or durability as with a [[Nano Pack]].
|IF_CLEAVE|Items with this flag give the wielder the benefits of the [[Traits#Blademaster|Blademaster]] trait (as [[Butcher's Cleaver]]).
|IF_NOAMMO|Items with this flag don't consume ammo when fired. For the player, a weapon still must have ammo loaded to be fired.
|IF_NECROCHARGE|Items with this flag recharge as with IF_RECHARGE, but reduce the weilder's health by 1 for each point of recharge (as with [[Necroarmor]]).
|IF_PUMPACTION|Ranged weapons with this flag must be pumped after each shot as with the combat shotgun.
|IF_SINGLERELOAD|Ranged weapons with this flag only reload one ammo at a time (as with the missile launcher) instead of all at once.
|IF_PISTOL|This flag indicates whether the weapon counts as a pistol for the purposes of the [[Traits#Son of a Gun|Son of a Gun]] and [[Traits#Dualgunner|Dualgunner]] traits. (For kill counting, the weapon group is used instead.)
|IF_SHOTGUN|This flag causes a weapon's missile to be treated as a shotgun id rather than a missile id. Also, this flag is used to decide if the [[Traits#Shottyman|Shottyman]] trait should count the weapon as a shotgun. (For kill counting, the weapon group is used instead.)
|IF_SPREAD|Ranged weapons with this flag fire three shots at once (as the [[tristar blaster]] and [[mancubus]] natural weapon). In 0.9.9.4, this flag is a bit buggy.
|IF_SCATTER|For ranged weapons with this flag, each shot is aimed at a different cell near the real target (as with the [[BFG 10K]]).
|IF_MODABLE|Allows a unique item to be fully modded.
|IF_SINGLEMOD|Restricts the number of allowed mods on the item to one. (For unique items, this must be used along with IF_MODABLE.)
|IF_DUALSHOTGUN|For multi-shot weapons, this flag eliminates all delay between shots and causes the firing sound to play only once.
|IF_AIHEALPACK|This flag allows the default AI to pick up and use the item.
|IF_NOUNLOAD|Ranged weapons with this flag cannot be unloaded.
|IF_NUKERESIST|Items with this flag will not be destroyed by nuking.
|IF_NODROP|Items with this flag will not be dropped when the carrier/wearer dies.
|IF_AUTOHIT|Weapons with this flag never miss (as with items modified by a sniper weapon pack).
|IF_SETITEM|This flag is automatically set for items that specify a set.
|IF_NODURABILITY|Armors and boots with this flag have no durability (as with items modified by an Onyx Armor Pack).
|IF_NODESTROY|Armors with this flag cannot be destroyed by damage. Also, items on the ground with this flag will not be destroyed by explosions.
|IF_NONMODABLE|Items with this flag cannot be modded.
|IF_NOREPAIR|Armors and boots with this flag cannot be repaired by normal methods (ie item:fix). Directly setting item.durability bypasses this prohibition.
|IF_ASSEMBLED|This flag is automatically set on assemblies. Items with this flag cannot be used for the base of any other assembly.
|IF_DESTROY|Weapons with this flag will be destroyed after firing (with a default message). The flag is used for overcharged weapons.
|IF_BLADE|Weapons with this flag are considered blades for the purpose of activating the flags used for [[Traits#Malicious Blades|Malicious Blades]].
|IF_DESTRUCTIVE|Weapons with this flag deal double damage to cells (if they can hurt cells, see [[Modding:Cell|CF_FRAGILE]].)
|}}
}}

== Engine Hooks ==
These hooks can give greater flexibility for how items work. For some item types, a hook provides the primary function. Sometimes, the engine will add to explicitly defined hooks, but this shouldn't interfere with a modder's use of the hooks. However, modders should be careful when changing hooks.
{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="2" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|Item Hooks
{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|{{modarg|boolean}}|[[#item_OnCreate|OnCreate]]({{modarg|Item}} self)
|{{modarg|boolean}}|[[#item_OnPickup|OnPickup]]({{modarg|Item}} self, {{modarg|Being}} getter)
|{{modarg|boolean}}|[[#item_OnFirstPickup|OnFirstPickup]]({{modarg|Item}} self, {{modarg|Being}} getter)
|{{modarg|boolean}}|[[#item_OnPickupCheck|OnPickupCheck]]({{modarg|Item}} self, {{modarg|Being}} getter)
|{{modarg|boolean}}|[[#item_OnUse|OnUse]]({{modarg|Item}} self, {{modarg|Being}} user)
|{{modarg|boolean}}|[[#item_OnUseCheck|OnUseCheck]]({{modarg|Item}} self, {{modarg|Being}} user)
|{{modarg|boolean}}|[[#item_OnReload|OnReload]]({{modarg|Item}} self, {{modarg|Being}} reloader)
|{{modarg|boolean}}|[[#item_OnAltFire|OnAltFire]]({{modarg|Item}} self, {{modarg|Being}} firer)
|{{modarg|boolean}}|[[#item_OnAltReload|OnAltReload]]({{modarg|Item}} self, {{modarg|Being}} reloader)
|{{modarg|boolean}}|[[#item_OnEquip|OnEquip]]({{modarg|Item}} self, {{modarg|Being}} equipper)
|{{modarg|boolean}}|[[#item_OnEquipTick|OnEquipTick]]({{modarg|Item}} self, {{modarg|Being}} wearer)
|{{modarg|boolean}}|[[#item_OnEquipCheck|OnEquipCheck]]({{modarg|Item}} self, {{modarg|Being}} equipper)
|{{modarg|boolean}}|[[#item_OnRemove|OnRemove]]({{modarg|Item}} self, {{modarg|Being}} wearer)
|{{modarg|boolean}}|[[#item_OnKill|OnKill]]({{modarg|Item}} self, {{modarg|Being}} dier, {{modarg|Being}} wearer)
|{{modarg|boolean}}|[[#item_OnHitBeing|OnHitBeing]]({{modarg|Item}} self, {{modarg|Being}} attacker, {{modarg|Being}} target)
|{{modarg|boolean}}|[[#item_OnEnter|OnEnter]]({{modarg|Item}} self, {{modarg|Being}} enterer)
|{{modarg|boolean}}|[[#item_OnFire|OnFire]]({{modarg|Item}} self, {{modarg|Being}} firer)
|{{modarg|boolean}}|[[#item_OnFired|OnFired]]({{modarg|Item}} self, {{modarg|Being}} firer)
|}}
|}

{{Anchor|item_OnCreate}}
;OnCreate({{modarg|Item}} self)
:This hook is called when the item is created. For ammo, beware: the game creates and destroys ammo items liberally as a normal part of ammo management.
----
{{Anchor|item_OnPickup}}
;OnPickup({{modarg|Item}} self, {{modarg|Being}} getter)
:When an item is picked up, this hook is called with the being that is picking the item up. This is most commonly used to implement powerups.
----
{{Anchor|item_OnFirstPickup}}
;OnFirstPickup({{modarg|Item}} self, {{modarg|Being}} getter)
:When an item with a given id is picked up for the first time, the function is called. This only works for items that go into the inventory.
----
{{Anchor|item_OnPickupCheck}}
;OnPickupCheck({{modarg|Item}} self, {{modarg|Being}} getter) → '''boolean'''
:When a being tries to pick up an item, this function is called with the being that is trying to pick it up. If the return value is true, then the being is allowed to pick the item up, otherwise the being can't. For the player, both cases include the item in the player's previously found items. (This can affect OnFirstPickup.)
----
{{Anchor|item_OnUse}}
;OnUse({{modarg|Item}} self, {{modarg|Being}} user) → '''boolean'''
:This hook is called when levers are used and when packs are used with the being that it using the item. For packs, if the return value is true, the item is consumed, otherwise it is left in the inventory. For levers, the return value is ignored and it is safe not to have a return value.
----
{{Anchor|item_OnUseCheck}}
;OnUseCheck({{modarg|Item}} self, {{modarg|Being}} user) → '''boolean'''
:This hook is called called before OnUse for levers and packs. If the return value is false, then the being can't use the item, otherwise it can. For levers, this can control whether the lever statistic is increased.
----
{{Anchor|item_OnReload}}
;OnReload({{modarg|Item}} self, {{modarg|Being}} reloader) → '''boolean'''
:If it is declared, this hook is called when a weapon is reloaded. If the return value is false, then the normal reload procedure is aborted. This can be used to prevent reloading or to implement a custom reloading mechanism (like for the [[Acid Spitter]]). If true is returned, the weapon is reloaded normally afterwards.
----
{{Anchor|item_OnAltFire}}
;OnAltFire({{modarg|Item}} self, {{modarg|Being}} firer) → '''boolean'''
:This hook works exactly like the OnFire hook, except it is called when the weapon's alternate fire mode is used for weapons with ALT_SCRIPT altfire.
----
{{Anchor|item_OnAltReload}}
;OnAltReload({{modarg|Item}} self, {{modarg|Being}} reloader)
:If the weapon's altreload is RELOAD_SCRIPT, then this hook is called with when the weapon's alternate reload mode is used.
----
{{Anchor|item_OnEquip}}
;OnEquip({{modarg|Item}} self, {{modarg|Being}} equipper)
:This hook is called when the item is equipped in any equipment slot. Due to a bug, equipper is the active being. This is always correct during normal play, but modders must be careful when manually equipping items with this hook.
----
{{Anchor|item_OnEquipTick}}
;OnEquipTick({{modarg|Item}} self, {{modarg|Being}} wearer)
:While this item is equipped in any slot (including the prepared slot), this function is called on each of the being's actions. (Despite the name, it probably won't be called on every tick; it depends on the being's speed.)
----
{{Anchor|item_OnEquipCheck}}
;OnEquipCheck({{modarg|Item}} self, {{modarg|Being}} equipper) → '''boolean'''
:This function is called (before OnEquip) when the player tries to equip an item. If the return value is true, then the player is allowed to equip the item; otherwise the player isn't allowed to equip the item.
----
{{Anchor|item_OnRemove}}
;OnRemove({{modarg|Item}} self, {{modarg|Being}} wearer)
:This hook is called when a being unequips the item, or when the item is otherwise removed from the being's equipment. This includes armor being destroyed by damage. Like OnEquip, this is called with the active being which can cause problems especially if this hook is called for armor destruction.
----
{{Anchor|item_OnKill}}
;OnKill({{modarg|Item}} self, {{modarg|Being}} dier, {{modarg|Being}} wearer)
:When a being dies, this hook is called on all of the active being's equipment. This includes the prepared slot. (Weapons can check what slot they are in inside of this hook.)
----
{{Anchor|item_OnHitBeing}}
;OnHitBeing({{modarg|Item}} self, {{modarg|Being}} attacker, {{modarg|Being}} target) → '''boolean'''
:For weapons with no blastradius, this hook is called whenever a being is hit with the weapon. This hook is called before applying damage. If the return value is true, damage is applied as usual. Otherwise, the damage phase is skipped.
----
{{Anchor|item_OnEnter}}
;OnEnter({{modarg|Item}} self, {{modarg|Being}} enterer)
:This function is called whenever a being enters a cell that has the item lying on the floor. For the player, this supresses the usual "There is an item lying here" message. This is used in DoomRL to implement teleports.
----
{{Anchor|item_OnFire}}
;OnFire({{modarg|Item}} self, {{modarg|Being}} firer) → '''boolean'''
:This hook is called when a weapon is fired. This only works for normal firing, not alternative firing (see OnAltFire). This hook is called before a target is selected. If the return value is true, then the rest of the normal firing operation is aborted. If the return value is false, then it continues as usual.
----
{{Anchor|item_OnFired}}
;OnFired({{modarg|Item}} self, {{modarg|Being}} firer)
:This hook is called after a weapon is fired. This is after the entire usual firing procedure including damage, etc. Currently, this only works for the player.

== Properties ==
Items also have all the [[Modding:Thing|Thing]] properties in addition to those listed below. For items, the meaning of the resistance fields vary depending on the item type. For armor and boots, the resistances are applied only to attacks to the corresponding target. For other equipment, the resistance applies to all attacks. For non-equipment, the resistances aren't used. Also, some properties are only valid for armor, and some are only valid for weapons. For these purposes, armor are items with itype ITEMTYPE_ARMOR and ITEMTYPE_BOOTS and weapons are items with itype ITEMTYPE_AMMO, ITEMTYPE_MELEE, ITEMTYPE_NRANGED, ITEMTYPE_RANGED, and ITEMTYPE_AMMOPACK. Properties of the incorrect type are always indexable, but they may share a memory address with properties of the opposite type, so modders should only use this feature very carefully. The type of such properties is noted. Also, the meaning of many fields is slightly different depending on the itype; these differences are also described.

{{drltable|Item|3|{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|{{modarg|ItemType}}|itype|This determines the basic features of the item. ITEMTYPE_NONE has no features; it can't be picked up or used. ITEMTYPE_RANGED can be picked up and wielded as a ranged weapon. ITEMTYPE_NRANGED is like ITEMTYPE_RANGED, but it isn't designed to exist on the map. ITEMTYPE_ARMOR can be picked up and equipped as armor. ITEMTYPE_MELEE can be picked up and wielded as a melee weapon. ITEMTYPE_AMMO is always a new ammo type that can be picked up and stacked. ITEMTYPE_PACK items can be picked up and used. ITEMTYPE_POWER items are consumed when they are picked up. ITEMTYPE_BOOTS can be picked up and worn as boots. ITEMTYPE_TELE have no special features, but by convention they interact with OnEnter. ITEMTYPE_LEVER have special description routines, and they can be used while on the floor. ITEMTYPE_AMMOPACK can be picked up and wielded in the prepared slot. They provide reloading benefits. While it is possible to change an item's itype, this should almost never be done. If it is done, care must be taken to account for overlapping weapon and armor properties.
|{{modarg|byte}}|armor|For armor and boots, this is the amount of [[protection]] provided at full durability. Weapons in the main slot may also provide a (universal) protection bonus with this field.
|{{modarg|word}}|durability|For armor and boots, this is the current amount of durability of the item. This property is armor-specific.
|{{modarg|word}}|maxdurability|For armor and boots, this is the maximum amount of durability. Most effects won't raise the durability above maxdurability. This property is armor-specific.
|{{modarg|integer}}|movemod|For armor and boots, this percentage movement speed modifier is applied while the item is equipped. This property is armor-specific.
|{{modarg|integer}}|knockmod|For armor and boots, this percentage [[knockback]] modifier is applied while the item is equipped. This property is armor-specific.
|[[Modding:Item|Item ID]]|ammoid|This must always be a number id. For ranged weapons, this is the item id of the kind of ammo the weapon uses. For ammo packs, this is the kind of ammo provided by the pack. This property is weapon-specific.
|{{modarg|word}}|ammo|For ranged weapons, this is the amount of currently-loaded ammo. For ammo packs and ammo stacks, this is the amount of ammo inside. This property is weapon-specific.
|{{modarg|word}}|ammomax|For ranged weapons, this is the size of the magazine. For ammo stacks, this is the maximum stack size (unaffected by BF_BACKPACK). For ammo packs, this is the initial amount of ammo. This property is weapon-specific.
|{{modarg|word}}|acc|For ranged and melee weapons, this is an [[accuracy]] modifier applied to attacks with the weapon. This property is weapon-specific.
|{{modarg|word}}|damage_sides|For weapons, this is the number of dice rolled for damage (e.g. the X of XdY). This property is weapon-specific.
|{{modarg|word}}|damage_dice|For weapons, this is the number of sides on each die rolled for damage (e.g. the Y of XdY). This property is weapon-specific.
|{{modarg|integer}}|damage_add|For weapons, this is a flat bonus added to all damage rolls. This property is weapon-specific.
|{{modarg|Missile ID}}|missile|This must always be a number id. For ranged weapons, this is the missile used by the weapon. For melee weapons, this is the missile used by the throw alternate fire mode (if any). This property is weapon-specific.
|{{modarg|byte}}|blastradius|This is the [[Distance|radius]] of the explosion caused by a ranged weapon. This should be 0 for weapons with no explosion. This property is weapon-specific.
|{{modarg|byte}}|shots|This is the number of shots fired by a rapid-fire ranged weapon. This should be 0 (not 1) for single-shot weapons. This property is weapon-specific.
|{{modarg|byte}}|shotcost|This is the amount of ammo consumed by each shot with a ranged weapon. This should be 0 (not 1) for weapons that take only one ammo per shot. This property is weapon-specific.
|{{modarg|byte}}|reloadtime|This is the number of 0.1s intervals it takes (without modifiers) to reload a ranged weapon. This property is weapon-specific.
|{{modarg|byte}}|usetime|This is the number of 0.1s intervals it takes (without modifiers) to fire/use a weapon. This property is weapon-specific.
|{{modarg|DamageType}}|damagetype|This is the [[Damage type|type]] of the damage caused by a weapon. This property is weapon-specific.
|{{modarg|AltFire}}|altfire|This is the alternate fire mode of a weapon. For ALT_SCRIPT, the details depend on the OnAltFire hook. This property is weapon-specific.
|{{modarg|AltReload}}|altreload|This is the alternate reload mode of a ranged weapon. For RELOAD_SCRIPT, the details depend on the OnAltReload hook. This property is weapon-specific.
|{{modarg|string}}|desc|This is the string used to describe the item in the inventory list. For the description in the inventory sidebar, use .proto.desc. This property is read-only.
|{{modarg|Item Prototype}}|__proto|This is the item's prototype. You can access item prototype fields using this (e.g., item.__proto.color).
|}}
}}
== API ==

The [[Modding:Thing#API|Thing API]] can also be used with items.
{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="2" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|Item Interface
{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|{{modarg|Item}}|{{moddef|list|new|dot||Item ID|iid}}
|{{modarg|boolean}}|{{moddef|list|add_mod|cln||string|modletter}}
|{{modarg|boolean}}|{{moddef|list|can_mod|cln||string|modletter}}
|{{modarg|integer}}|{{moddef|list|get_mod|cln||string|modletter}}
|{{modarg|boolean}}|{{moddef|list|clear_mods|cln}}
|{{modarg|boolean}}|{{moddef|list|is_damaged|cln}}
|{{modarg|boolean}}|{{moddef|list|fix|cln||integer|amount}}
|{{modarg|table}}|{{moddef|list|get_mods|cln}}
|{{modarg|table}}|{{moddef|list|get_mod|ids|cln}}
|{{modarg|boolean}}|{{moddef|list|can_overcharge|cln}}
|{{modarg|boolean}}|{{moddef|list|check_mod_array|cln||string|nextmod|integer|techbonus}}
|}}
|}

{{moddef|desc|new|dot|Item|Item ID|iid}}
:This returns a newly allocated item create from the specified prototype. This item doesn't exist in the game yet; it must be dropped on the level, added to an inventory, or equipped.
----
{{moddef|desc|add_mod|cln|boolean|string|modletter}}
:Adds a mod to the item's mod list and sets the IF_MODIFIED flag. This does not apply any affects of the mod, it is only a primitive operation for accessing the mod list. ''modletter'' should be a single uppercase letter representing the mod. This will check modding restrictions (as [[#item_can_mod|can_mod]]) and return true on success, false on failure.
----
{{moddef|desc|can_mod|cln|boolean|string|modletter}}
:Determines if the given mod can be added to the item. ''modletter'' should be a single uppercase letter representing the mod. This will always use the player's techbonus. It also accounts for limits on the number of mods of a given type and various modability item flags.
----
{{moddef|desc|get_mod|cln|integer|string|modletter}}
:Counts the number of the given mod that have already been added to the item. ''modletter'' should be a single uppercase letter representing the mod.
----
{{moddef|desc|clear_mods|cln|boolean}}
:Clears the counts of all mods for the item. The does not undo the affects of the mods nor does it change any flags (including IF_MODIFIED).
----
{{moddef|desc|is_damaged|cln|boolean}}
:This determines if the item's durability is less than its maxdurability. For items with IF_NOREPAIR, this function always returns false. (So, in effect this function determines if the item needs to be repaired.)
----
{{moddef|desc|fix|cln|boolean|integer|amount}}
:This will increase the item's durability by amount, respecting maxdurability. It returns true is the item is no longer is_damaged. ''amount'' is optional; by default the item is completely repaired.
----
{{moddef|desc|get_mods|cln|table}}
:This will return a table that maps single character mod letters to the corresponding amount of mods that have been applied to the item. Mod letters that have not been applied are not included as keys.
----
{{moddef|list|get_mod|ids|cln|table}}
:As get_mods, but the table returned gives all mods in terms of their sID.
----
{{moddef|desc|can_overcharge|cln|boolean}}
:This will determine if the item can be overcharged. To be overcharged, an item can't already by overcharged (IF_DESTROY), and must be fully loaded. The ui part of overcharging is included. On success, IF_DESTROY and IF_NOUNLOAD are set, but other affects must be applied by the caller.
----
{{moddef|desc|check_mod_array|cln|boolean|string|nextmod|integer|techbonus}}
:This will check if the mod indicated by ''nextmod'' (the single uppercase character representing the mod) could form an assembly (given the provided techbonus). If so, the assembly is created on the item (if the player confirms the ui message) with all associated side effects. Returns true only if the assembly is actually created.

Talk:Bruiser brother

2012-02-01T18:27:18Z

Game Hunter: answer'd

==health==

As far as I know, this page was never changed to reflect the enemy's health change since the three-episode restructure. [[User:GrimmC|GrimmC]] 23:01, 31 January 2012 (CET)
*Took care of the HP and fixed up the other stats while I was at it. Looking at these, however, they're way too easy for the experience receieved (they're even easier than Barons on ITYTD) so that'll need to be toned down in the next release. [[User:Game Hunter|Game Hunter]] 19:27, 1 February 2012 (CET)

Bruiser brother

2012-02-01T18:25:30Z

Game Hunter: updated stats

{{infostrat switch}}
{{Monsters|
monster_name=Bruiser brother|
monster_looks=B|
monster_hp=60+3×difficulty2 = 63,72,87,108,135|
monster_ac=2|
monster_acc=+5 melee, +5 ranged|
monster_melee=1d3+8 = 9-11 = 10 avg|
monster_projectile=4d5 = 4-20 = 12 avg: [[damage type#acid|acid damage]], [[explosions|radius]] 2|
monster_speed=100%|
monster_dlvl=[[Phobos Hellgate]], or 50 and lower on A100|
monster_xp=608|
monster_inventory=None|
monster_pickup=Yes|
monster_doors=Yes|
monster_atkchance=40|
monster_abilities=Takes no damage from [[fluids]]. Has 50% acid [[resistance]].|
monster_description=''Tough as a dump truck and nearly as big, these Goliaths are the worst thing on two legs since Tyrannosaurus rex.''|
monster_other=Hunts player precisely: will run through any fluid to reach player.}}

Modding:Constants

2012-01-31T21:16:44Z

Game Hunter: removed all object-specific flags (they have been relocated to their respective document)

Constants and Enumerations are common in any game and DoomRL is no exception. Internally, as most programmers are aware, these are integers. But to modders they are all important magic values, looked up here.

== Engine Enums ==

==== ItemType ====

Every item has a type that determines how the engine treats it.

{| style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
|colspan=2 style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''TItemType'''
|-
|style="vertical-align:top; padding-right: 2ex;"|ITEMTYPE_NONE
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|ITEMTYPE_RANGED
|-
|style="vertical-align:top; padding-right: 2ex;"|ITEMTYPE_NRANGED
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|ITEMTYPE_ARMOR
|-
|style="vertical-align:top; padding-right: 2ex;"|ITEMTYPE_MELEE
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|ITEMTYPE_AMMO
|-
|style="vertical-align:top; padding-right: 2ex;"|ITEMTYPE_PACK
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|ITEMTYPE_POWER
|-
|style="vertical-align:top; padding-right: 2ex;"|ITEMTYPE_BOOTS
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|ITEMTYPE_TELE
|-
|style="vertical-align:top; padding-right: 2ex;"|ITEMTYPE_LEVER
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|ITEMTYPE_AMMOPACK
|}

==== BodyTarget ====

Sources of damage must specify a body target to determine which sources of armor are used. Inherent armor bonuses always apply.

{| style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
|colspan=2 style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''TBodyTarget'''
|-
|style="vertical-align:top; padding-right: 2ex;"|TARGET_INTERNAL
|Protection from boots and armor will be ignored.
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|TARGET_TORSO
|Protection from armor counts but protection from boots does not.
|-
|style="vertical-align:top; padding-right: 2ex;"|TARGET_FEET
|Protection from boots counts but protection from armor does not.
|}

==== EqSlot ====

It is preferred to use the (equivalent) [[#Equip Slots|slot]] constants.

{| style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
|colspan=2 style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''TEqSlot'''
|-
|style="vertical-align:top; padding-right: 2ex;"|EFTORSO
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|EFWEAPON
|-
|style="vertical-align:top; padding-right: 2ex;"|EFBOOTS
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|EFWEAPON2
|}

==== StatusEffect ====

[[Modding:Affect|Affects]] specify one of these status effects that will apply a color scheme to all the tiles on the HUD.

{| style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
|colspan=2 style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''TStatusEffect'''
|-
|style="vertical-align:top; padding-right: 2ex;"|STATUSNORMAL
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|STATUSINVERT
|-
|style="vertical-align:top; padding-right: 2ex;"|STATUSRED
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|STATUSGREEN
|}

==== DamageType ====

Sources of damage usually specify a damage type that determines how the damage regards protection, resistances, gibbing, and other things. For details on the differences between the damage types, look [[Damage type|here]].

{| style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
|colspan=2 style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''TDamageType'''
|-
|style="vertical-align:top; padding-right: 2ex;"|DAMAGE_BULLET
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|DAMAGE_MELEE
|-
|style="vertical-align:top; padding-right: 2ex;"|DAMAGE_SHARPNEL [sic]
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|DAMAGE_ACID
|-
|style="vertical-align:top; padding-right: 2ex;"|DAMAGE_FIRE
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|DAMAGE_PLASMA
|-
|style="vertical-align:top; padding-right: 2ex;"|DAMAGE_IGNOREARMOR
|}

==== AltFire ====
{| style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
|colspan=2 style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''TAltFire'''
|-
|style="vertical-align:top; padding-right: 2ex;"|ALT_NONE
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|ALT_CHAIN
|-
|style="vertical-align:top; padding-right: 2ex;"|ALT_THROW
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|ALT_SCRIPT
|-
|style="vertical-align:top; padding-right: 2ex;"|ALT_AIMED
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|ALT_SINGLE
|-
|style="vertical-align:top; padding-right: 2ex;"|ALT_WHIRLWIND
|}

==== AltReload ====
{| style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
|colspan=2 style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''TAltReload'''
|-
|style="vertical-align:top; padding-right: 2ex;"|RELOAD_NONE
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|RELOAD_SCRIPT
|-
|style="vertical-align:top; padding-right: 2ex;"|RELOAD_FULL
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|RELOAD_DUAL
|-
|style="vertical-align:top; padding-right: 2ex;"|RELOAD_SINGLE
|}

==== ExplosionFlag ====
{| style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
|colspan=3 style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''TExplosionFlag'''
|-
|style="vertical-align:top; padding-right: 2ex;"|EFSELFHALF
|Deals half damage to the active being.
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|EFSELFKNOCKBACK
|Gives extra knockback to the active being.
|-
|style="vertical-align:top; padding-right: 2ex;"|EFSELFSAFE
|Deals no damage to the active being.
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|EFAFTERBLINK
|Blinks the screen after the explosion finishes.
|-
|style="vertical-align:top; padding-right: 2ex;"|EFCHAIN
|Causes secondary explosions (as the [[BFG 9000]]).
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|EFHALFKNOCK
|Causes half the usual knockback.
|-
|style="vertical-align:top; padding-right: 2ex;"|EFNOKNOCK
|Doesn't cause knockback.
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|EFRANDOMCONTENT
|Transmutes some cells in the explosion to the explosion's content cell; the rules is to transmute when damage is greater than 20.
|}

====LightFlag====
{| style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
|colspan=2 style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''TLightFlag'''
|-
|style="vertical-align:top; padding-right: 2ex;"|LFEXPLORED
|This flag is set for explored cells. It can be modified to create computer map-like effects or Angel of Darkness-like effects.
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|LFVISIBLE
|This flag is set for cells in the player's current LOS. This flag is automatically recalculated on every player action. It may be useful to manually modify this flag if LOS needs to be updated more often.
|-
|style="vertical-align:top; padding-right: 2ex;"|LFLIGHTED
|This flag is always set on the same cells as LFVISIBLE; both flags must be set for a cell to be visible.
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|LFDAMAGE
|This is a book-keeping flag for shotgun area-of-effect. Cells are set with this flag if they are calculated as in the shotgun blast but haven't yet been processed.
|-
|style="vertical-align:top; padding-right: 2ex;"|LFFRESH
|This is a book-keeping flag for explosions. New corpses are set with this flag to keep them from being immediately destroyed. This flag can be set to make any cell indestructible, but it may be cleared by the engine.
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|LFNOSPAWN
|Cells with this flag are counted as non-empty by the EF_NOSPAWN empty flag.
|}

== Constants ==

==== Maximums ====
{| style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
|colspan=2 style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Maximums'''
|-
|style="vertical-align:top; padding-right: 2ex;"|MAXX || 78
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|MAXY || 20
|-
|style="vertical-align:top; padding-right: 2ex;"|BOSS_LEVEL || 25
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|MAXDEPTH || 26
|-
|style="vertical-align:top; padding-right: 2ex;"|MAXAFFECT || 5
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|MAX_INV_SIZE || 22
|-
|style="vertical-align:top; padding-right: 2ex;"|MAX_EQ_SIZE || 4
|}

==== Cellsets ====
{| style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
|colspan=2 style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Cellsets'''
|-
|style="vertical-align:top; padding-right: 2ex;"|CELLSET_WALLS
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|CELLSET_FLOORS
|-
|style="vertical-align:top; padding-right: 2ex;"|CELLSET_CORPSES
|}

==== Challenges ====
{| style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
|colspan=2 style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Challenges'''
|-
|style="vertical-align:top; padding-right: 2ex;"|CHALLENGE_BERSERK
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|CHALLENGE_MARKSMANSHIP
|-
|style="vertical-align:top; padding-right: 2ex;"|CHALLENGE_SHOTGUNNERY
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|CHALLENGE_LIGHTTRAVEL
|-
|style="vertical-align:top; padding-right: 2ex;"|CHALLENGE_IMPATIENCE
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|CHALLENGE_HASTE
|-
|style="vertical-align:top; padding-right: 2ex;"|CHALLENGE_PURITY
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|CHALLENGE_REDALERT
|-
|style="vertical-align:top; padding-right: 2ex;"|CHALLENGE_CARNAGE
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|CHALLENGE_MASOCHISM
|-
|style="vertical-align:top; padding-right: 2ex;"|CHALLENGE_100
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|CHALLENGE_PACIFISM
|-
|style="vertical-align:top; padding-right: 2ex;"|CHALLENGE_HUMANITY
|}

==== Difficulty ====
{| style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
|colspan=2 style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Difficulty'''
|-
|style="vertical-align:top; padding-right: 2ex;"|DIFF_EASY
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|DIFF_MEDIUM
|-
|style="vertical-align:top; padding-right: 2ex;"|DIFF_HARD
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|DIFF_VERYHARD
|-
|style="vertical-align:top; padding-right: 2ex;"|DIFF_NIGHTMARE
|}

==== PlayerRank ====
{| style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
|colspan=2 style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''PlayerRank'''
|-
|style="vertical-align:top; padding-right: 2ex;"|RANKEXP
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|RANKSKILL
|}

==== Player Statistics ====
{| style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
|colspan=2 style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Player Statistics'''
|-
|style="vertical-align:top; padding-right: 2ex;"|RANK_KILLTOTAL
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|RANK_KILLMELEE
|-
|style="vertical-align:top; padding-right: 2ex;"|RANK_KILLPISTOL
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|RANK_LEVEL
|-
|style="vertical-align:top; padding-right: 2ex;"|RANK_BADGE
|}

==== Equip Slots ====
{| style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
|colspan=2 style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Equip Slots'''
|-
|style="vertical-align:top; padding-right: 2ex;"|SLOT_ARMOR
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|SLOT_WEAPON
|-
|style="vertical-align:top; padding-right: 2ex;"|SLOT_BOOTS
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|SLOT_PREPARED
|}

==== Colors ====
Usually, it is possible to specify a foreground color and a background color. Since DoomRL uses 4 bit color, the lowest 4 bits determine the foreground color, and the next 4 bits determine the background color (zero is black). Occasionally, one of these may conflict with one of the special color constants.

Also, note that the exact color the end-user sees may depend on his system settings.

For the basic 16 colors, the valkyrie string coloring escape is noted.

{| style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
|colspan=4 style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Colors'''
|-
|style="vertical-align:top; padding-right: 2ex;"|BLACK
|width="100" style="background: black;"|
|@D
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|BLUE
|width="100" style="background: navy;"|
|@b
|-
|style="vertical-align:top; padding-right: 2ex;"|GREEN
|width="100" style="background: green;"|
|@g
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|CYAN
|width="100" style="background: teal;"|
|@c
|-
|style="vertical-align:top; padding-right: 2ex;"|RED
|width="100" style="background: maroon;"|
|@r
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|MAGENTA
|width="100" style="background: purple;"|
|@v
|-
|style="vertical-align:top; padding-right: 2ex;"|BROWN
|width="100" style="background: olive;"|
|@n or @N
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|LIGHTGRAY
|width="100" style="background: silver;"|
|@l
|-
|style="vertical-align:top; padding-right: 2ex;"|DARKGRAY
|width="100" style="background: gray;"|
|@d
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|LIGHTBLUE
|width="100" style="background: blue;"|
|@B
|-
|style="vertical-align:top; padding-right: 2ex;"|LIGHTGREEN
|width="100" style="background: lime;"|
|@G
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|LIGHTCYAN
|width="100" style="background: aqua;"|
|@C
|-
|style="vertical-align:top; padding-right: 2ex;"|LIGHTRED
|width="100" style="background: red;"|
|@R
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|LIGHTMAGENTA
|width="100" style="background: fuchsia;"|
|@V
|-
|style="vertical-align:top; padding-right: 2ex;"|YELLOW
|width="100" style="background: yellow;"|
|@y or @Y
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|WHITE
|width="100" style="background: white;"|
|@L
|-
|style="vertical-align:top; padding-right: 2ex;"|MULTIBLUE
|
|Randomly chosen from BLUE, LIGHTBLUE, and WHITE. Only works for missiles.
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|MULTIYELLOW
|
|Randomly chosen from YELLOW, LIGHTGREEN, and WHITE. Only works for missiles.
|-
|style="vertical-align:top; padding-right: 2ex;"|MULTIPORTAL
|
|Cycles between LIGHTMAGENTA, MAGENTA, and WHITE. Only works for things displayed in the map.
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|COLOR_WATER
|
|Alternates between BLUE and LIGHTBLUE. Only works for things displayed in the map.
|-
|style="vertical-align:top; padding-right: 2ex;"|COLOR_ACID
|
|Alternates between GREEN and LIGHTGREEN. Only works for things displayed in the map.
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|COLOR_LAVA
|
|Alternates between RED and YELLOW. Only works for things displayed in the map.
|}

== Flags ==

==== Generic Flags ====
{| style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
|colspan=3 style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Generic Flags'''
|-
|style="vertical-align:top; padding-right: 2ex;"|F_OVERLAY
|This flag is related to the graphical version.
|}

==== Empty Flags ====
Empty flags are used with various functions to control the selection of random coords.

{| style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
|colspan=2 style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Empty Flags'''
|-
|style="vertical-align:top; padding-right: 2ex;"|EF_NOITEMS
|Excludes cells that contain an item.
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|EF_NOBEINGS
|Excludes cells that contain a being.
|-
|style="vertical-align:top; padding-right: 2ex;"|EF_NOBLOCK
|Excludes cells that block movement (CF_BLOCKMOVE).
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|EF_NOVISION
|Excludes cells that block vision (CF_BLOCKLOS).
|-
|style="vertical-align:top; padding-right: 2ex;"|EF_NOSTAIRS
|Excludes stairs (cells with an OnExit hook).
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|EF_NOTELE
|Excludes cells with a teleporter (an item with ITEMTYPE_TELE).
|-
|style="vertical-align:top; padding-right: 2ex;"|EF_NOHARM
|Excludes hazardous cells (CF_HAZARD).
|- style="background: #333;"
|style="vertical-align:top; padding-right: 2ex;"|EF_NOSAFE
|Excludes cells that are too near to the player (currently the threshold is less than or equal to distance of 5).
|-
|style="vertical-align:top; padding-right: 2ex;"|EF_NOSPAWN
|Excludes cells with LF_NOSPAWN.
|}

Modding:Missile

2012-01-31T21:15:54Z

Game Hunter: moved missile flags

Missiles are created whenever a [[Modding:Item#Ranged Weapon|ranged weapon]] fires a shot. Some of the effects of the missile (like damage) depend on the weapon that fired it. Most of the missile properties are related to animation, although some have a game effect. Some weapons fire shotgun blasts instead of missiles. Shotgun blasts (called shotguns) are separate objects with their own IDs. A weapon will interpret its missile as a shotgun if it has the IF_SHOTGUN flag.

== Missile Prototype ==
Missile prototypes are declared using the global Missile function. They are stored in a global table called missiles which can be indexed by string or numeric id. Required properties are underlined.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|(Projectile) Missile Prototype
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''string'''|id|This is the missile's string id. By convention, it should be all lowercase and shouldn't have any whitespace. (A numeric id called nid is assigned automatically.) For [[Modding:Item#Ranged Weapon|inline missile definitions]], this field is created automatically.
|'''string'''|soundID|If the missile doesn't have a sound bindings and this field exists, it will be used to look for sound bindings in a different place. Missiles are responsible for the .explode sound binding. By convention, this is the same as the ID of the weapon that fires the missile (if the weapon has a different id to begin with which isn't the case for inline definitions).
|'''string'''|ascii|This is the single character used to represent the missile animation. "-", the default, is automatically rotated as is commonly seen in DoomRL.
|[[Modding:Constants#Colors|Color]]|color|This is the color used to draw the missile animation.
|'''integer'''|delay|This is the number of milliseconds to pause after each stage of the missile animation. Typical values used by DoomRL are in the range of 10 to 50.
|'''integer'''|miss_base|When this missile is fired at the player, this is the base [[Dodging|dodge chance]].
|'''integer'''|miss_dist|When this missile is fired at the player, this is the amount that the dodge chance increases per unit of distance.
|'''string'''|firedesc|If this field is a non-empty string, this message will be used instead of the usual one when an enemy fires this weapon. The @1 escape will be replaced with the enemy's name (with appropriate article and capitalization).
|'''string'''|hitdesc|If this field is a non-empty string, this message will be used instead of the usual one when an enemy hits with this weapon.
|'''integer'''|maxrange|This field is currently unused. The default is 10.
|'''integer'''|range|If this field is non-zero, the player's targeting is restricted by this range when firing a weapon with this missile. Even if this value is large, targeting is still restricted by the player's vision. The default is 0.
|[[Modding:Constants#Missile Flags|Missile Flag]] '''list'''|flags|This flags in this list are included in the missile's flag set. This is automatically translated into set format in a property called flagSet. The default is the empty list.
|'''integer'''|expl_delay|If this missile causes an explosion (determined by the weapon that fired it), this is the pause in milliseconds after each stage of the explosion animation. The default is 40.
|[[Modding:Constants#Colors|Color]]|expl_color|This is the color of the explosion animation. Since explosions are mulicolored, not all colors are allowed here. See [[Modding:Level#level_explosion|Level.explosion]] for details. The default is RED.
|[[Modding:Constants#ExplosionFlag|ExplosionFlag]] '''list'''|expl_flags|This is a list of explosion flags that are applied to explosions created by this missile. This is automatically translated into set format in a property called expl_flagSet. The default is the empty list.
|[[Modding:Cell|Cell ID]]|content|If this field is declared, then an explosion will have a chance of transmuting cells into this cell (as described [[Explosions|here]]). This is automatically translated into a numeric id.
|}}
|}

=== Flags ===
{{drltable|Projectile Missile Flags|2|{{Table2Col
|es=background: #333;
|c1=font-family:monospace; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|MF_RAY|This flag changes the missile's animation. The delay is ignored and all cells in the path are drawn with the projectile (as with the [[Shambler|Shambler's]] ranged attack).
|MF_HARD|This flag causes the missile to continue after hitting a being (as with the [[Railgun]]).
|MF_EXACT|This flag causes the missile to stop at the targeted square (as with the [[Revenant's Launcher]]).
|MF_IMMIDATE|This flag causes the missile to always hit the targetted square (although it may still miss a being standing on that square). The missile does not respect line of fire -- it will go through walls (although AI controlled beings using such a missile will still respect line-of-sight). The animation for the missile will only display over the targeted cell. ([[Arch-vile|Arch-viles']] natural weapon uses this flag.)
|}}
}}

== Shotgun Prototype ==
Shotgun prototypes are declared using the global Shotgun function. They are stored in a global table called shotguns which can be indexed by string or numeric ID. Required properties are underlined.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|Shotgun (Missile) Prototype
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''string'''|id|This is the shotgun's string id. By convention, it should be all lowercase with no spaces. (A numeric id called nid is automatically created.)
|'''integer'''|range|This is the shotgun's [[Shotguns|range]].
|'''integer'''|spread|This is the shotgun's [[Shotguns|spread]].
|'''integer'''|reduce|This is the percentage of the shotgun's damage that decays per unit of distance.
|}}
|}

Modding:Item

2012-01-31T21:13:36Z

Game Hunter: moved and updated item flags

DoomRL has many kinds of items. Weapons, powerups, levers, and other things are all items. Items inherit from the [[Modding:Thing|Thing]] class which handles some basic properties in common with beings.

== Prototype ==
New items are created from item prototypes. Think of an item prototype as a recipe for creating new items. There can be multiple pistols, but they all came from the same prototype. Prototypes are declared by passing a table with the desired properties to the Items function. The available properties depend on the item type. [[#Engine Hooks|Engine hooks]] may also be included in the prototype. Mostly, the prototype's properties just describe items' initial properties (occasionally with different names). Items' properties can also mostly be changed after they are instantiated. Required fields are underlined. Sometimes required fields can safely be omitted, but this will generate a message in the log file. All item prototypes are stored in a global table called items. This table can be indexed by id or nid.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Item Prototype'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''string'''|name|This is the item's name.
|'''string'''|id|This is the item's sid. It must be distinct from other string ids. (The numeric id is automatically generated and stored in the nid field of the prototype.) It defaults to the first word of the name in all lowercase.
|'''integer''' '''list'''|overlay|This describes of color transformation of the item's sprite. It is only used in the graphical version. This will create overlay_red, overlay_blue, overlay_green, and overlay_alpha attributes for the prototype.
|[[Modding:Constants#Colors|Color]]|color|This is the item's color. The default is LIGHTGRAY.
|'''integer'''|level|This is an [[Item Generation|item generation]] parameter. The default is 0.
|'''integer'''|weight|This is an [[Item Generation|item generation]] parameter.
|'''integer'''|sprite|This is the item's sprite. This field is only relevant to the graphical version; use 0 for no sprite.
|[[Modding:Constants#Item Flags|Item Flag]] '''list'''|flags|The flags in this list will automatically be included in the item's flag set. The default is an empty list. Some flags may be added automatically. The prototype will automatically be given a flagSet property containing the flags in set format.
|[[Modding:ItemSet|ItemSet ID]]|set|If included, this item will belong to the given item set. This will modify the item's OnEquip and OnRemove hooks.
|'''string'''|firstmsg|If included, this message will be displayed when the an item with this prototype is picked up for the first time. This will modify the item's OnFirstPickup hook.
|'''integer'''|slevel|This property is unused.
|'''string'''|color_id|For the purpose of custom color bindings, this id will be used for the item. Multiple items (like levers) can have the same color_id to prevent them from being distinguished.
|'''integer'''|res_bullet|This is the item's res_bullet. The default is 0.
|'''integer'''|res_melee|This is the item's res_melee. The default is 0.
|'''integer'''|res_shrapnel|This is the item's res_shrapnel. The default is 0.
|'''integer'''|res_acid|This is the item's res_acid. The default is 0.
|'''integer'''|res_fire|This is the item's res_fire. The default is 0.
|'''integer'''|res_plasma|This is the item's res_plasma. The default is 0.
|[[Modding:Constants#ItemType|ItemType]]|type|This is the item's itype. It also determines which other properties can be used in the prototype.
|}}
|}

=== Armor or Boots ===
These are the fields used by ITEMTYPE_ARMOR and ITEMTYPE_BOOTS.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Armor or Boots Prototype'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''string'''|desc|This is the armor's description that is displayed in the inventory screen.
|'''integer'''|armor|This is the armor's armor property.
|'''integer'''|durability|This is the armor's maxdurability as well as its initial durability. The default is 100. (This should still be 100 for armors with no durability, as no durability is achieved by a flag.)
|'''integer'''|knockmod|This is the armor's knockmod. The default is 0.
|'''integer'''|movemod|This is the armor's movemod. The default is 0.
|'''string'''|ascii|This is the armor's picture. It should be a length one string. The default is "[" for body armor and ";" for boots.
|}}
|}

=== Consumable ===
These are the fields used by ITEMTYPE_PACK. This includes mods and relics.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Consuamble Prototype'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''string'''|desc|This is the pack's description that is displayed in the inventory screen.
|'''function'''|OnUse|Packs must provide an OnUse hook.
|'''string'''|ascii|This is the pack's picture. It should be a length one string. The default is "+".
|}}
|}

=== Powerups ===
These are the fields used by ITEMTYPE_POWER.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Powerups Prototype'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''function'''|OnPickup|Powerups must provide an OnPickup hook.
|'''string'''|ascii|This is the powerup's picture. It should be a length one string. The default is "^".
|}}
|}

=== Ammo ===
These are the fields used by ITEMTYPE_AMMO.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Ammo Prototype'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''string'''|desc|This is the ammo's description that is displayed in the inventory screen.
|'''integer'''|ammo|This is the ammo's initial ammo property.
|'''integer'''|ammomax|This is the ammo's ammomax property.
|'''string'''|ascii|This is the ammo's picture. It should be a length one string. The default is "|".
|}}
|}

=== Ammo Pack ===
These are the fields used by ITEMTYPE_AMMOPACK.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Ammo Pack Prototype'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''string'''|desc|This is the ammo pack's description that is displayed in the inventory screen.
|'''integer'''|ammo|This is the ammo pack's initial ammo property.
|'''integer'''|ammomax|This is the ammo pack's ammomax property.
|'''string'''|ammoID|This is the ammo pack's ammoid property.
|'''string'''|ascii|This is the ammo pack's picture. It should be a length one string. The default is "!".
|}}
|}

=== Ranged Weapon ===
These fields are used by ITEMTYPE_RANGED.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Ranged Weapon Prototype'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''string'''|desc|This is the weapon's description that is displayed in the inventory screen.
|'''string'''|damage|This should be a string like "2d4"; the weapon's damage_dice and damage_sides will be parsed from this.
|[[Modding:Constants#DamageType|DamageType]]|damagetype|This is the weapon's damagetype.
|'''string'''|group|This is the weapon's group for purposes of kill counting. The used weapon groups are "weapon-melee", "weapon-pistol", "weapon-shotgun", "weapon-chain", "weapon-rocket", "weapon-plasma", and "weapon-bfg". The default is "weapon-other".
|'''string'''|ammoID|This is the weapon's ammoID.
|'''integer'''|fire|This is the weapon's usetime. The default is 10.
|'''integer'''|acc|This is the weapon's acc. The default is 0.
|'''integer'''|ammomax|This is the weapon's ammomax and the weapon's initial ammo.
|'''integer'''|radius|This is the weapon's blastradius. The default is 0.
|'''integer'''|shots|This is the weapon's shots. The default is 0 (which will still give one shot).
|'''integer'''|shotcost|This is the weapon's shotcost. The default is 0 (which will still require one ammo).
|[[Modding:Constants#AltFire|AltFire]]|altfire|This is the weapon's altfire. The default is ALT_NONE.
|[[Modding:Constants#AltReload|AltReload]]|altreload|This is the weapon's altreload. The default is RELOAD_NONE.
|'''string'''|altfirename|This is the name the game uses for the weapon's alternate fire mode. Most of the AltFire constants provide defaults.
|'''string'''|altreloadname|This is the name the game uses for the weapon's alternate reload mode. Most of the AltReload constants provide defaults.
|[[Modding:Missile|Missile ID]]|overcharge|This field is currently unused.
|[[Modding:Missile|Missile ID]] or [[Modding:Missile|Missile Prototype]]|missile|This is the weapon's missile. (It will be translated into an nid. To use a shotgun missile, the weapon must have the IF_SHOTGUN flag.) If this property is a table, it will be used to declare a new missile with the same id as the weapon.
|'''string'''|ascii|This is the weapon's picture. It should be a length one string. The default is "}".
|}}
|}

=== Natural Ranged Weapon ===
These fields are used by ITEMTYPE_NRANGED. Natural ranged weapons are usually defined inline in a [[Modding:Being|being]] definition.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Natural Ranged Weapon Prototype'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''string'''|damage|This should be a string like "2d4"; the weapon's damage_dice and damage_sides will be parsed from this.
|[[Modding:Constants#DamageType|DamageType]]|damagetype|This is the weapon's damagetype.
|'''string'''|group|This is the weapon's group for purposes of kill counting. The used weapon groups are "weapon-melee", "weapon-pistol", "weapon-shotgun", "weapon-chain", "weapon-rocket", "weapon-plasma", and "weapon-bfg". The default is "weapon-other".
|'''integer'''|fire|This is the weapon's usetime. The default is 10.
|'''integer'''|acc|This is the weapon's acc. The default is 0.
|'''integer'''|radius|This is the weapon's blastradius. The default is 0.
|'''integer'''|shots|This is the weapon's shots. The default is 0 (which will still give one shot).
|'''string'''|soundID|The soundID will be used to look up sounds if there are no sounds defined for the weapon's actual id. By convention, a natural weapon's soundID is the usual wielder's id.
|[[Modding:Missile|Missile ID]] or [[Modding:Missile|Missile Prototype]]|missile|This is the weapon's missile. (It will be translated into an nid. To use a shotgun missile, the weapon must have the IF_SHOTGUN flag.) If this property is a table, it will be used to declare a new missile with the same id as the weapon.
|'''string'''|ascii|This is the weapon's picture. It should be a length one string. The default is "?".
|}}
|}

=== Melee Weapon ===
These fields are used by ITEMTYPE_MELEE.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Melee Prototype'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''string'''|desc|This is the weapon's description that is displayed in the inventory screen.
|'''string'''|damage|This should be a string like "2d4"; the weapon's damage_dice and damage_sides will be parsed from this.
|[[Modding:Constants#DamageType|DamageType]]|damagetype|This is the weapon's damagetype.
|'''string'''|group|This is the weapon's group for purposes of kill counting. The used weapon groups are "weapon-melee", "weapon-pistol", "weapon-shotgun", "weapon-chain", "weapon-rocket", "weapon-plasma", and "weapon-bfg". The default is "weapon-other".
|'''integer'''|fire|This is the weapon's usetime. The default is 10.
|'''integer'''|acc|This is the weapon's acc. The default is 0.
|'''integer'''|shotcost|This is the weapon's shotcost. The default is 0 (which will still require one ammo).
|[[Modding:Constants#AltFire|AltFire]]|altfire|This is the weapon's altfire. The default is ALT_NONE.
|'''string'''|altfirename|This is the name the game uses for the weapon's alternate fire mode. Most of the AltFire constants provide defaults.
|[[Modding:Missile|Missile ID]] or [[Modding:Missile|Missile Prototype]]|missile|This is the missile used if for the throw alternate fire mode.
|'''string'''|ascii|This is the weapon's picture. It should be a length one string. The default is "\".
|}}
|}

=== Lever ===
These fields are used by ITEMTYPE_LEVER. DoomRL levers usually also have a target_area custom property.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Lever Prototype'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''string'''|desc|This is the full description of the lever used if the player has BF_LEVERSENSE2.
|'''string'''|good|This is the qualitative description of the lever used if the player has BF_LEVERSENSE1. By convention, this should be "beneficial", "neutral", or "dangerous".
|'''integer'''|fullchance|The level generation code will set the lever's target_area to the full map fullchance percent of the time. The default is 0. (To be fair, the level generation code won't generate custom levers.)
|'''string'''|warning|This message will be displayed by the level generation code if the fullchance roll succeeds.
|null|color_id|This field is required for levers. By convention, it is set to "lever".
|null|soundID|If the particular lever doesn't have sound bindings, the game will use the sound ID to look for sound bindings. By default, this is "lever".
|'''string'''|ascii|This is the lever's picture. It should be a length one string. The default is "&".
|}}
|}

=== Teleporter ===
These fields are used by ITEMTYPE_TELE. The built-in teleport item has a custom target property. This can be set to any coord to control the destination.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Teleporter Prototype'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''function'''|OnEnter|This hook is required for teleporters.
|'''string'''|ascii|This is the teleporter's picture. It should be a length one string. The default is "*".
|}}
|}

=== Flags ===
{{drltable|Item Flags|2|{{Table2Col
|es=background: #333;
|c1=font-family:monospace; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|IF_CHAMBEREMPTY|For IF_PUMPACTION weapons, this flag indicates whether ammo is in the chamber or not.
|IF_UNIQUE|This flag is set for unique items. Unique items add a player history message when picked up as well as doing a screen blink. Unique items are also not destroyable.
|IF_EXOTIC|This flag is set for exotic items. This is used by the game to compile the special items list.
|IF_MODIFIED|This flag is automatically set for items that have been modded.
|IF_HALFKNOCK|If a weapon with this flag is wielded, all knockback against the wielder will be halved.
|IF_GLOBE|This is a marker flag for items that are disallowed in Angel of Masochism.
|IF_CURSED|Items with this flag cannot be unequipped.
|IF_RECHARGE|Items with this flag regenerate ammo or durability as with a [[Nano Pack]].
|IF_CLEAVE|Items with this flag give the wielder the benefits of the [[Traits#Blademaster|Blademaster]] trait (as [[Butcher's Cleaver]]).
|IF_NOAMMO|Items with this flag don't consume ammo when fired. For the player, a weapon still must have ammo loaded to be fired.
|IF_NECROCHARGE|Items with this flag recharge as with IF_RECHARGE, but reduce the weilder's health by 1 for each point of recharge (as with [[Necroarmor]]).
|IF_PUMPACTION|Ranged weapons with this flag must be pumped after each shot as with the combat shotgun.
|IF_SINGLERELOAD|Ranged weapons with this flag only reload one ammo at a time (as with the missile launcher) instead of all at once.
|IF_PISTOL|This flag indicates whether the weapon counts as a pistol for the purposes of the [[Traits#Son of a Gun|Son of a Gun]] and [[Traits#Dualgunner|Dualgunner]] traits. (For kill counting, the weapon group is used instead.)
|IF_SHOTGUN|This flag causes a weapon's missile to be treated as a shotgun id rather than a missile id. Also, this flag is used to decide if the [[Traits#Shottyman|Shottyman]] trait should count the weapon as a shotgun. (For kill counting, the weapon group is used instead.)
|IF_SPREAD|Ranged weapons with this flag fire three shots at once (as the [[tristar blaster]] and [[mancubus]] natural weapon). In 0.9.9.4, this flag is a bit buggy.
|IF_SCATTER|For ranged weapons with this flag, each shot is aimed at a different cell near the real target (as with the [[BFG 10K]]).
|IF_MODABLE|Allows a unique item to be fully modded.
|IF_SINGLEMOD|Restricts the number of allowed mods on the item to one. (For unique items, this must be used along with IF_MODABLE.)
|IF_DUALSHOTGUN|For multi-shot weapons, this flag eliminates all delay between shots and causes the firing sound to play only once.
|IF_AIHEALPACK|This flag allows the default AI to pick up and use the item.
|IF_NOUNLOAD|Ranged weapons with this flag cannot be unloaded.
|IF_NUKERESIST|Items with this flag will not be destroyed by nuking.
|IF_NODROP|Items with this flag will not be dropped when the carrier/wearer dies.
|IF_AUTOHIT|Weapons with this flag never miss (as with items modified by a sniper weapon pack).
|IF_SETITEM|This flag is automatically set for items that specify a set.
|IF_NODURABILITY|Armors and boots with this flag have no durability (as with items modified by an Onyx Armor Pack).
|IF_NODESTROY|Armors with this flag cannot be destroyed by damage. Also, items on the ground with this flag will not be destroyed by explosions.
|IF_NONMODABLE|Items with this flag cannot be modded.
|IF_NOREPAIR|Armors and boots with this flag cannot be repaired by normal methods (ie item:fix). Directly setting item.durability bypasses this prohibition.
|IF_ASSEMBLED|This flag is automatically set on assemblies. Items with this flag cannot be used for the base of any other assembly.
|IF_DESTROY|Weapons with this flag will be destroyed after firing (with a default message). The flag is used for overcharged weapons.
|IF_BLADE|Weapons with this flag are considered blades for the purpose of activating the flags used for [[Traits#Malicious Blades|Malicious Blades]].
|IF_DESTRUCTIVE|Weapons with this flag deal double damage to cells (if they can hurt cells, see [[Modding:Cell|CF_FRAGILE]].)
|}}
}}

== Engine Hooks ==
These hooks can give greater flexibility for how items work. For some item types, a hook provides the primary function. Sometimes, the engine will add to explicitly defined hooks, but this shouldn't interfere with a modder's use of the hooks. However, modders should be careful when changing hooks.
{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="2" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|Item Hooks
{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|'''void'''|[[#item_OnCreate|OnCreate]]([[Modding:Item|Item]] self)
|'''void'''|[[#item_OnPickup|OnPickup]]([[Modding:Item|Item]] self, [[Modding:Being|Being]] getter)
|'''void'''|[[#item_OnFirstPickup|OnFirstPickup]]([[Modding:Item|Item]] self, [[Modding:Being|Being]] getter)
|'''boolean'''|[[#item_OnPickupCheck|OnPickupCheck]]([[Modding:Item|Item]] self, [[Modding:Being|Being]] getter)
|'''boolean'''|[[#item_OnUse|OnUse]]([[Modding:Item|Item]] self, [[Modding:Being|Being]] user)
|'''boolean'''|[[#item_OnUseCheck|OnUseCheck]]([[Modding:Item|Item]] self, [[Modding:Being|Being]] user)
|'''boolean'''|[[#item_OnReload|OnReload]]([[Modding:Item|Item]] self, [[Modding:Being|Being]] reloader)
|'''boolean'''|[[#item_OnAltFire|OnAltFire]]([[Modding:Item|Item]] self, [[Modding:Being|Being]] firer)
|'''void'''|[[#item_OnAltReload|OnAltReload]]([[Modding:Item|Item]] self, [[Modding:Being|Being]] reloader)
|'''void'''|[[#item_OnEquip|OnEquip]]([[Modding:Item|Item]] self, [[Modding:Being|Being]] equipper)
|'''void'''|[[#item_OnEquipTick|OnEquipTick]]([[Modding:Item|Item]] self, [[Modding:Being|Being]] wearer)
|'''boolean'''|[[#item_OnEquipCheck|OnEquipCheck]]([[Modding:Item|Item]] self, [[Modding:Being|Being]] equipper)
|'''void'''|[[#item_OnRemove|OnRemove]]([[Modding:Item|Item]] self, [[Modding:Being|Being]] wearer)
|'''void'''|[[#item_OnKill|OnKill]]([[Modding:Item|Item]] self, [[Modding:Being|Being]] dier, [[Modding:Being|Being]] wearer)
|'''boolean'''|[[#item_OnHitBeing|OnHitBeing]]([[Modding:Item|Item]] self, [[Modding:Being|Being]] attacker, [[Modding:Being|Being]] target)
|'''void'''|[[#item_OnEnter|OnEnter]]([[Modding:Item|Item]] self, [[Modding:Being|Being]] enterer)
|'''boolean'''|[[#item_OnFire|OnFire]]([[Modding:Item|Item]] self, [[Modding:Being|Being]] firer)
|'''void'''|[[#item_OnFired|OnFired]]([[Modding:Item|Item]] self, [[Modding:Being|Being]] firer)
|}}
|}

{{Anchor|item_OnCreate}}
;OnCreate([[Modding:Item|Item]] self)
:This hook is called when the item is created. For ammo, beware: the game creates and destroys ammo items liberally as a normal part of ammo management.
----
{{Anchor|item_OnPickup}}
;OnPickup([[Modding:Item|Item]] self, [[Modding:Being|Being]] getter)
:When an item is picked up, this hook is called with the being that is picking the item up. This is most commonly used to implement powerups.
----
{{Anchor|item_OnFirstPickup}}
;OnFirstPickup([[Modding:Item|Item]] self, [[Modding:Being|Being]] getter)
:When an item with a given id is picked up for the first time, the function is called. This only works for items that go into the inventory.
----
{{Anchor|item_OnPickupCheck}}
;OnPickupCheck([[Modding:Item|Item]] self, [[Modding:Being|Being]] getter) → '''boolean'''
:When a being tries to pick up an item, this function is called with the being that is trying to pick it up. If the return value is true, then the being is allowed to pick the item up, otherwise the being can't. For the player, both cases include the item in the player's previously found items. (This can affect OnFirstPickup.)
----
{{Anchor|item_OnUse}}
;OnUse([[Modding:Item|Item]] self, [[Modding:Being|Being]] user) → '''boolean'''
:This hook is called when levers are used and when packs are used with the being that it using the item. For packs, if the return value is true, the item is consumed, otherwise it is left in the inventory. For levers, the return value is ignored and it is safe not to have a return value.
----
{{Anchor|item_OnUseCheck}}
;OnUseCheck([[Modding:Item|Item]] self, [[Modding:Being|Being]] user) → '''boolean'''
:This hook is called called before OnUse for levers and packs. If the return value is false, then the being can't use the item, otherwise it can. For levers, this can control whether the lever statistic is increased.
----
{{Anchor|item_OnReload}}
;OnReload([[Modding:Item|Item]] self, [[Modding:Being|Being]] reloader) → '''boolean'''
:If it is declared, this hook is called when a weapon is reloaded. If the return value is false, then the normal reload procedure is aborted. This can be used to prevent reloading or to implement a custom reloading mechanism (like for the [[Acid Spitter]]). If true is returned, the weapon is reloaded normally afterwards.
----
{{Anchor|item_OnAltFire}}
;OnAltFire([[Modding:Item|Item]] self, [[Modding:Being|Being]] firer) → '''boolean'''
:This hook works exactly like the OnFire hook, except it is called when the weapon's alternate fire mode is used for weapons with ALT_SCRIPT altfire.
----
{{Anchor|item_OnAltReload}}
;OnAltReload([[Modding:Item|Item]] self, [[Modding:Being|Being]] reloader)
:If the weapon's altreload is RELOAD_SCRIPT, then this hook is called with when the weapon's alternate reload mode is used.
----
{{Anchor|item_OnEquip}}
;OnEquip([[Modding:Item|Item]] self, [[Modding:Being|Being]] equipper)
:This hook is called when the item is equipped in any equipment slot. Due to a bug, equipper is the active being. This is always correct during normal play, but modders must be careful when manually equipping items with this hook.
----
{{Anchor|item_OnEquipTick}}
;OnEquipTick([[Modding:Item|Item]] self, [[Modding:Being|Being]] wearer)
:While this item is equipped in any slot (including the prepared slot), this function is called on each of the being's actions. (Despite the name, it probably won't be called on every tick; it depends on the being's speed.)
----
{{Anchor|item_OnEquipCheck}}
;OnEquipCheck([[Modding:Item|Item]] self, [[Modding:Being|Being]] equipper) → '''boolean'''
:This function is called (before OnEquip) when the player tries to equip an item. If the return value is true, then the player is allowed to equip the item; otherwise the player isn't allowed to equip the item.
----
{{Anchor|item_OnRemove}}
;OnRemove([[Modding:Item|Item]] self, [[Modding:Being|Being]] wearer)
:This hook is called when a being unequips the item, or when the item is otherwise removed from the being's equipment. This includes armor being destroyed by damage. Like OnEquip, this is called with the active being which can cause problems especially if this hook is called for armor destruction.
----
{{Anchor|item_OnKill}}
;OnKill([[Modding:Item|Item]] self, [[Modding:Being|Being]] dier, [[Modding:Being|Being]] wearer)
:When a being dies, this hook is called on all of the active being's equipment. This includes the prepared slot. (Weapons can check what slot they are in inside of this hook.)
----
{{Anchor|item_OnHitBeing}}
;OnHitBeing([[Modding:Item|Item]] self, [[Modding:Being|Being]] attacker, [[Modding:Being|Being]] target) → '''boolean'''
:For weapons with no blastradius, this hook is called whenever a being is hit with the weapon. This hook is called before applying damage. If the return value is true, damage is applied as usual. Otherwise, the damage phase is skipped.
----
{{Anchor|item_OnEnter}}
;OnEnter([[Modding:Item|Item]] self, [[Modding:Being|Being]] enterer)
:This function is called whenever a being enters a cell that has the item lying on the floor. For the player, this supresses the usual "There is an item lying here" message. This is used in DoomRL to implement teleports.
----
{{Anchor|item_OnFire}}
;OnFire([[Modding:Item|Item]] self, [[Modding:Being|Being]] firer) → '''boolean'''
:This hook is called when a weapon is fired. This only works for normal firing, not alternative firing (see OnAltFire). This hook is called before a target is selected. If the return value is true, then the rest of the normal firing operation is aborted. If the return value is false, then it continues as usual.
----
{{Anchor|item_OnFired}}
;OnFired([[Modding:Item|Item]] self, [[Modding:Being|Being]] firer)
:This hook is called after a weapon is fired. This is after the entire usual firing procedure including damage, etc. Currently, this only works for the player.

== Properties ==
Items also have all the [[Modding:Thing|Thing]] properties in addition to those listed below. For items, the meaning of the resistance fields vary depending on the item type. For armor and boots, the resistances are applied only to attacks to the corresponding target. For other equipment, the resistance applies to all attacks. For non-equipment, the resistances aren't used. Also, some properties are only valid for armor, and some are only valid for weapons. For these purposes, armor are items with itype ITEMTYPE_ARMOR and ITEMTYPE_BOOTS and weapons are items with itype ITEMTYPE_AMMO, ITEMTYPE_MELEE, ITEMTYPE_NRANGED, ITEMTYPE_RANGED, and ITEMTYPE_AMMOPACK. Properties of the incorrect type are always indexable, but they may share a memory address with properties of the opposite type, so modders should only use this feature very carefully. The type of such properties is noted. Also, the meaning of many fields is slightly different depending on the itype; these differences are also described.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Item'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|[[Modding:Constants#ItemType|ItemType]]|itype|This determines the basic features of the item. ITEMTYPE_NONE has no features; it can't be picked up or used. ITEMTYPE_RANGED can be picked up and wielded as a ranged weapon. ITEMTYPE_NRANGED is like ITEMTYPE_RANGED, but it isn't designed to exist on the map. ITEMTYPE_ARMOR can be picked up and equipped as armor. ITEMTYPE_MELEE can be picked up and wielded as a melee weapon. ITEMTYPE_AMMO is always a new ammo type that can be picked up and stacked. ITEMTYPE_PACK items can be picked up and used. ITEMTYPE_POWER items are consumed when they are picked up. ITEMTYPE_BOOTS can be picked up and worn as boots. ITEMTYPE_TELE have no special features, but by convention they interact with OnEnter. ITEMTYPE_LEVER have special description routines, and they can be used while on the floor. ITEMTYPE_AMMOPACK can be picked up and wielded in the prepared slot. They provide reloading benefits. While it is possible to change an item's itype, this should almost never be done. If it is done, care must be taken to account for overlapping weapon and armor properties.
|'''Byte'''|armor|For armor and boots, this is the amount of [[protection]] provided at full durability. Weapons in the main slot may also provide a (universal) protection bonus with this field.
|'''Word'''|durability|For armor and boots, this is the current amount of durability of the item. This property is armor-specific.
|'''Word'''|maxdurability|For armor and boots, this is the maximum amount of durability. Most effects won't raise the durability above maxdurability. This property is armor-specific.
|'''Integer'''|movemod|For armor and boots, this percentage movement speed modifier is applied while the item is equipped. This property is armor-specific.
|'''Integer'''|knockback|For armor and boots, this percentage [[knockback]] modifier is applied while the item is equipped. This property is armor-specific.
|[[Modding:Item|Item ID]]|ammoid|This must always be a number id. For ranged weapons, this is the item id of the kind of ammo the weapon uses. For ammo packs, this is the kind of ammo provided by the pack. This property is weapon-specific.
|'''Word'''|ammo|For ranged weapons, this is the amount of currently-loaded ammo. For ammo packs and ammo stacks, this is the amount of ammo inside. This property is weapon-specific.
|'''Word'''|ammomax|For ranged weapons, this is the size of the magazine. For ammo stacks, this is the maximum stack size (unaffected by BF_BACKPACK). For ammo packs, this is the initial amount of ammo. This property is weapon-specific.
|'''Word'''|acc|For ranged and melee weapons, this is an [[accuracy]] modifier applied to attacks with the weapon. This property is weapon-specific.
|'''Word'''|damage_sides|For weapons, this is the number of dice rolled for damage (e.g. the X of XdY). This property is weapon-specific.
|'''Word'''|damage_dice|For weapons, this is the number of sides on each die rolled for damage (e.g. the Y of XdY). This property is weapon-specific.
|'''Integer'''|damage_add|For weapons, this is a flat bonus added to all damage rolls. This property is weapon-specific.
|[[Modding:Missile|Missile ID]]|missile|This must always be a number id. For ranged weapons, this is the missile used by the weapon. For melee weapons, this is the missile used by the throw alternate fire mode (if any). This property is weapon-specific.
|'''Byte'''|blastradius|This is the [[Distance|radius]] of the explosion caused by a ranged weapon. This should be 0 for weapons with no explosion. This property is weapon-specific.
|'''Byte'''|shots|This is the number of shots fired by a rapid-fire ranged weapon. This should be 0 (not 1) for single-shot weapons. This property is weapon-specific.
|'''Byte'''|shotcost|This is the amount of ammo consumed by each shot with a ranged weapon. This should be 0 (not 1) for weapons that take only one ammo per shot. This property is weapon-specific.
|'''Byte'''|reloadtime|This is the number of 0.1s intervals it takes (without modifiers) to reload a ranged weapon. This property is weapon-specific.
|'''Byte'''|usetime|This is the number of 0.1s intervals it takes (without modifiers) to fire/use a weapon. This property is weapon-specific.
|[[Modding:Constants#DamageType|DamageType]]|damagetype|This is the [[Damage type|type]] of the damage caused by a weapon. This property is weapon-specific.
|[[Modding:Constants#AltFire|AltFire]]|altfire|This is the alternate fire mode of a weapon. For ALT_SCRIPT, the details depend on the OnAltFire hook. This property is weapon-specific.
|[[Modding:Constants#AltReload|AltReload]]|altreload|This is the alternate reload mode of a ranged weapon. For RELOAD_SCRIPT, the details depend on the OnAltReload hook. This property is weapon-specific.
|'''string'''|desc|This is the string used to describe the item in the inventory list. For the description in the inventory sidebar, use .proto.desc. This property is read-only.
|[[Modding:Item|Item Prototype]]|proto|This is the item's prototype.
|}}
|}
== API ==

The [[Modding:Thing#API|Thing API]] can also be used with items.
{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="2" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|Item Interface
{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|[[Modding:Item|Item]]|item.[[#item_new|new]]([[Modding:Item|Item ID]] id)
|'''boolean'''|[[Modding:Item|Item]]:[[#item_add_mod|add_mod]]('''string''' modletter)
|'''boolean'''|[[Modding:Item|Item]]:[[#item_can_mod|can_mod]]('''string''' modletter)
|'''integer'''|[[Modding:Item|Item]]:[[#item_get_mod|get_mod]]('''string''' modletter)
|'''void'''|[[Modding:Item|Item]]:[[#item_clear_mods|clear_mods]]()
|'''boolean'''|[[Modding:Item|Item]]:[[#item_is_damaged|is_damaged]]()
|'''boolean'''|[[Modding:Item|Item]]:[[#item_fix|fix]]('''integer''' amount)
|'''table'''|[[Modding:Item|Item]]:[[#item_get_mods|get_mods]]()
|'''boolean'''|[[Modding:Item|Item]]:[[#item_can_overcharge|can_overcharge]]()
|'''boolean'''|[[Modding:Item|Item]]:[[#item_check_mod_array|check_mod_array]]('''string''' nextmod, '''integer''' techbonus)
|}}
|}

{{Anchor|item_new}}
;item.new([[Modding:Item|Item ID]] id) → [[Modding:Item|Item]]
:This returns a newly allocated item create from the specified prototype. This item doesn't exist in the game yet; it must be dropped on the level, added to an inventory, or equipped.
----
{{Anchor|item_add_mod}}
;[[Modding:Item|Item]]:add_mod('''string''' modletter) → '''boolean'''
:Adds a mod to the item's mod list and sets the IF_MODIFIED flag. This does not apply any affects of the mod, it is only a primitive operation for accessing the mod list. ''modletter'' should be a single uppercase letter representing the mod. This will check modding restrictions (as [[#item_can_mod|can_mod]]) and return true on success, false on failure.
----
{{Anchor|item_can_mod}}
;[[Modding:Item|Item]]:can_mod('''string''' modletter) → '''boolean'''
:Determines if the given mod can be added to the item. ''modletter'' should be a single uppercase letter representing the mod. This will always use the player's techbonus. It also accounts for limits on the number of mods of a given type and various modability item flags.
----
{{Anchor|item_get_mod}}
;[[Modding:Item|Item]]:get_mod('''string''' modletter) → '''integer'''
:Counts the number of the given mod that have already been added to the item. ''modletter'' should be a single uppercase letter representing the mod.
----
{{Anchor|item_clear_mods}}
;[[Modding:Item|Item]]:clear_mods()
:Clears the counts of all mods for the item. The does not undo the affects of the mods nor does it change any flags (including IF_MODIFIED).
----
{{Anchor|item_is_damaged}}
;[[Modding:Item|Item]]:is_damaged() → '''boolean'''
:This determines if the item's durability is less than its maxdurability. For items with IF_NOREPAIR, this function always returns false. (So, in effect this function determines if the item needs to be repaired.)
----
{{Anchor|item_fix}}
;[[Modding:Item|Item]]:fix('''integer''' amount) → '''boolean'''
:This will increase the item's durability by amount, respecting maxdurability. It returns true is the item is no longer is_damaged. ''amount'' is optional; by default the item is completely repaired.
----
{{Anchor|item_get_mods}}
;[[Modding:Item|Item]]:get_mods() → '''table'''
:This will return a table that maps single character mod letters to the corresponding amount of mods that have been applied to the item. Mod letters that have not been applied are not included as keys.
----
{{Anchor|item_can_overcharge}}
;[[Modding:Item|Item]]:can_overcharge() → '''boolean'''
:This will determine if the item can be overcharged. To be overcharged, an item can't already by overcharged (IF_DESTROY), and must be fully loaded. The ui part of overcharging is included. On success, IF_DESTROY and IF_NOUNLOAD are set, but other affects must be applied by the caller.
----
{{Anchor|item_check_mod_array}}
;[[Modding:Item|Item]]:check_mod_array('''string''' nextmod, '''integer''' techbonus) → '''boolean'''
:This will check if the mod indicated by ''nextmod'' (the single uppercase character representing the mod) could form an assembly (given the provided techbonus). If so, the assembly is created on the item (if the player confirms the ui message) with all associated side effects. Returns true only if the assembly is actually created.

Modding:being (0.9.9.7)

2012-01-31T21:06:31Z

Game Hunter: quick format fix

If it bleeds, it leads. Beings inherit from the [[Modding:Thing|Thing]] base class which handles some basic properties in common with items. In addition the [[Modding:Player|Player]] inherits this class, so anything you can do to creatures can be done to the player as well.

== Prototype ==

New beings are created from being prototypes. Think of a being prototype as a recipe for creating new beings. There can be multiple former humans, but they all came from the same prototype. Prototypes are declared by passing a table with the desired properties to the Beings function. [[#Engine Hooks|Engine hooks]] may also be included in the prototype. Mostly, the prototype's properties just describe beings' initial properties (occasionally with different names). Beings' properties can also mostly be changed after they are instantiated. Required fields are underlined. Sometimes required fields can safely be omitted, but this will generate a message in the log file. All being prototypes are stored in a global table called beings. This table can be indexed by id or nid.
{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Being Prototype'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''string'''|name|This is the being's name.
|'''string'''|name_plural|This is the being's name_plural. By default, this is the name with an "s" appended.
|'''string'''|ascii|This is the being's picture. It should be a single character string.
|'''string'''|id|This is the being's sid. It must be distinct from other string ids. (The numeric id is automatically assigned to a field called nid.) Only the first 20 characters will be used. The default is the first word of the name in all lowercase.
|'''integer''' '''list'''|overlay|This field is only used in the graphical version. It describes a color transformation to be applied to the being's sprite. This will create overlay_red, overlay_green, overlay_blue, and overlay_alpha fields in the being prototype.
|'''integer'''|XP|This is the being's expvalue. By default, it is <font-family: monospace>3xD2+20, where D is the being's danger (see below).
|[[Modding:Cell|Cell ID]]|corpse|The determines the corpse left by the being. If the value is true, a new corpse cell will automatically be created. Otherwise this field is interpretted as a cell id. After a being is declared, this field will have been translated to a number. The default is true.
|[[Modding:Item|Item Prototype]]|weapon|If this field is included, a new item will be declared and automatically equipped for beings generated from this prototype. The item prototype will automatically be a natural ranged weapon, have an id assigned, have zero weight, have no sprite, and have the IF_NODROP and IF_NOAMMO flags.
|'''integer'''|sprite|This is the being's sprite. (Use 0 for no sprite.)
|[[Modding:Constants#Colors|Color]]|color|This is the being's color.
|'''integer'''|toDam|This is the being's toDam. (This bonus only applies to melee attacks.) The default is 0.
|'''integer'''|toHit|This is the being's toHit. The default is 0.
|'''integer'''|speed|This is the being's speed. (Remember, the maximum allowed speed is 255.) The default is 100.
|'''integer'''|armor|This is the being's armor. The default is 0.
|'''integer'''|danger|This is a [[Monster Generation|monster generation]] parameter.
|'''integer'''|weight|This is a [[Monster Generation|monster generation]] parameter.
|'''integer'''|minLev|This is a [[Monster Generation|monster generation]] parameter.
|'''integer'''|maxLev|This is a [[Monster Generation|monster generation]] parameter. The default is 200.
|'''integer'''|HP|This is the being's hpmax and starting hp. The default is 10.
|'''integer'''|bulk|This parameter is unused. The default is 100.
|'''integer'''|group|Monsters from different groups will fight each other if they use the default AI. Oddly, the default is "weapon-other" which, as a string, translates to 0. The player is in group 1.
|'''integer'''|attackchance|This is the being's attackchance The default is 75.
|'''integer'''|toHitMelee|This is the being's toHitMelee. The default is 0.
|[[Modding:Constants#Being Flags|Being Flag]] '''list'''|flags|The flags in this list will be included in the being's flag set. Upon instantiation, a flagSet property is added to the prototype will include these flags (and possibly some automatic flags) in set format. The default is an empty list.
|'''string'''|sound_id|If included and the being doesn't have sound bindings configured, then it will look for sound bindings under its sound_id.
|[[Modding:AI|AI ID]]|ai_type|This determines the being's AI. By default, the old pascal AI is used. (The pascal AI doesn't have an id.)
|'''integer'''|vision|This is the being's vision. The default is 9. (The player also has vision 9 by default.)
|'''integer'''|res_bullet|This is the being's res_bullet. The default is 0.
|'''integer'''|res_melee|This is the being's res_melee. The default is 0.
|'''integer'''|res_shrapnel|This is the being's res_shrapnel. The default is 0.
|'''integer'''|res_acid|This is the being's res_acid. The default is 0.
|'''integer'''|res_fire|This is the being's res_fire. The default is 0.
|'''integer'''|res_plasma|This is the being's res_plasma. The default is 0.
|'''string'''|desc|This is the description of the being displayed in the more information view.
|'''string'''|kill_desc|If included, this being will have a special kill description in the mortem.
|'''string'''|kill_desc_melee|As kill_desc, but for melee kills.
|}}
|}
=== Flags ===
==== Being Flags ====
{{drltable|Being Flags|2|{{Table2Col
|es=background: #333;
|c1=font-family:monospace; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|BF_INV|Stops the being from taking any damage. (Directly setting the being's HP can circumvent this. Does not work well with the being's HP set to zero.)
|BF_BERSERK|Gives the damage reduction and melee damage bonus of [[Effects#Berserk|berserk]]. (The speed bonus is not included.)
|BF_ENVIROSAFE|Beings with this flag are immune to damage from acid and lava tiles. (New hazardous tiles will have to check for this flag to respect it.)
|BF_BACKPACK|Gives the ammo-stacking benefits of the [[Backpack]] powerup.
|BF_POWERBONUS|Extends the duration of powerups as the [[Marine]] class bonus. New powerups will have to check for this flag (or use the provided helper function) to respect it.
|BF_STAIRSENSE|For the player, reveals the stairs tile(s) as the [[Scout]] class bonus.
|BF_INSTAUSE|Allows consumable items to be used in 0.1s instead of the usual 1.0s, as the [[Technician]] class bonus.
|BF_MAPEXPERT|Makes computer maps work like tracking maps, as the [[Technician]] class bonus.
|BF_MODEXPERT|Allows the being to mod unique items.
|BF_QUICKSWAP|Gives the benefits of the Juggler trait.
|BF_BERSERKER|Gives the benefits of the [[Traits#Berserker|Berserker]] trait.
|BF_DUALGUN|Gives the benefits of the dualgunner trait.
|BF_MASTERDODGE|Gives the benefits of the [[Traits#Dodgemaster|Dodgemaster]] trait.
|BF_SHOTTYMAN|Gives the benefits of the [[Traits#Shottyman|Shottyman]] trait.
|BF_POWERSENSE|For the player, shows the locations of all powerups (as the first level of the [[Traits#Intuition|Intuition]] trait).
|BF_BEINGSENSE|For the player, shows the locations of enemies (as the second level of the Intuition trait).
|BF_LEVERSENSE1|For the player, gives partial information about levers (as the first level of the Intuition trait).
|BF_LEVERSENSE2|For the player, shows the exact effect of levers (as the second level of the Intuition trait).
|BF_VAMPYRE|Gives the benefits of the [[Traits#Vampyre|Vampyre]] trait.
|BF_BULLETDANCE|Gives the benefits of the [[Traits#Bullet Dance|Bullet Dance]] trait.
|BF_ARMYDEAD|Gives the benefits of the [[Traits#Army of the Dead|Army of the Dead]] trait.
|BF_AMMOCHAIN|Gives the benefits of the [[Traits#Ammochain|Ammochain]] trait.
|BF_MEDPLUS|Allows med-packs to heal beyond 100% health (part of the [[Survivalist]] trait).
|BF_HARDY|Allows protection to reduce damage all the way to zero (part of the [[Survivalist]] trait).
|BF_CLEAVE|Gives the benefits of the [[Traits#Blademaster|Blademaster]] trait.
|BF_GUNKATA|Gives the benefits of the [[Traits#Gun Kata|Gun Kata]] trait.
|BF_SHOTTYHEAD|Gives the benefits of the [[Traits#Shottyhead|Shottyhead]] trait.
|BF_NORUNPENALTY|Gives the benefits of the [[Traits#Running Man|Running Man]] trait.
|BF_DUALBLADE|If both weapons in the being's equipment slots have IF_BLADE, this flag allows both weapons to attack in the same turn, each at half the attack time (part of the [[Traits#Malicious Blades|Malicious Blades]] trait).
|BF_BLADEDEFEND|If the weapon in the being's prepared slot has IF_BLADE, this flag grants the being with resistances as [[Traits#Malicious Blades|Malicious Blades]].
|BF_PISTOLMAX|Gives the benefits of the [[Sharpshooter]] trait.
|BF_FIREANGEL|Gives the benefits of the [[Traits#Fireangel|Fireangel]] trait.
|BF_ENTRENCHMENT|Gives the benefits of the [[Traits#Entrenchment|Entrenchment]] trait.
|BF_SCAVENGER|Gives the benefits of the [[Scavenger]] trait (useless on anything other than the player).
|BF_IMPATIENT|This flag causes packs to be automatically used when picked up as [[Angel of Impatience]].
|BF_DARKNESS|For the player, stops exploration from being recorded as in [[Angel of Darkness]].
|BF_MAXDAMAGE|Beings with this flag always roll maximum damage as in [[Angel of Max Carnage]].
|BF_NOHEAL|This is a marker flag that stops healing effects from working as in [[Angel of Masochism]]. New sources of healing will have to check for this flag in order to respect it.
|BF_SESSILE|Beings with this flag cannot move.
|BF_NOMELEE|This flag stops the being from doing any type of melee attack.
|BF_REGENERATE|Beings with this flag regenerate one health per second if they have less than 20 health remaining.
|BF_SELFIMMUNE|Makes the being immune to its own attacks.
|BF_KNOCKIMMUNE|Makes the being immune to [[knockback]].
|BF_UNIQUENAME|This flag makes the game treat the being's name as a proper noun.
|BF_ENTERBOSS1|This is a flag for the player that helps determine which victory message to use in the mortem.
|BF_KILLBOSS1|This is a flag for the player that helps determine which victory message to use in the mortem.
|BF_ENTERBOSS2|This is a flag for the player that helps determine which victory message to use in the mortem.
|BF_KILLBOSS2|This is a flag for the player that helps determine which victory message to use in the mortem.
|BF_CHARGE|This is a flag for the AI. Beings with this flag are willing to walk through hazardous cells to reach the player. (This applies to the default AI, and the direct_seek method.)
|BF_HUNTING|This is a flag for the default AI. Beings with this flag will search out the player even if he is not in their line of sight.
|BF_OPENDOORS|This is a flag for the default AI. Beings with this flag will open doors.
|BF_NODROP|Beings with this flag will not drop their inventory or equipment when they die.
|BF_NOEXP|Beings with this flag will not award experience to the player.
|BF_BOSS|Killing this monster will cause the same message as killing the final boss as well as its death explosion and ending the game.
|BF_JC|When used with BF_BOSS, changes the explosion to blue and changes the message to indicate that JC was killed instead of the cyberdemon.
|}}
}}
== Engine Hooks ==
Specifying one or more of these hooks in the prototype will allow for greater customization.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="2" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Being Hooks'''
{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|'''void'''|[[#being_OnCreate|OnCreate]]([[Modding:Being|Being]] self)
|'''void'''|[[#being_OnAction|OnAction]]([[Modding:Being|Being]] self)
|'''void'''|[[#being_OnDie|OnDie]]([[Modding:Being|Being]] self, '''boolean''' overkill)
|}}
|}

{{Anchor|being_OnCreate}}
;OnCreate([[Modding:Being|Being]] self)
:This is called when the being is created.
----
{{Anchor|being_OnAction}}
;OnAction([[Modding:Being|Being]] self)
:This is called at the beginning of each of the being's turns. (Note that turns are only differentiated if time elapses in between.)
----
{{Anchor|being_OnDie}}
;OnDie([[Modding:Being|Being]] self, '''boolean''' overkill)
:This is called when the being dies. ''overkill'' is true if the being was gibbed.

== Properties ==
Beings also have all the [[Modding:Thing|Thing]] properties in addition to those listed below. For beings, the resistance fields are inherent resistances that apply to all attacks.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|Being
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''Byte'''|attackchance|This is how likely (in percent) a monster is to use a ranged attack on its turn. The exact interpretation may depend on the AI. This property is read-only.
|'''Integer'''|hp|This is the being's current [[health]].
|'''Word'''|hpmax|This is the being's maximum health.
|'''Byte'''|vision|This is the being's vision radius. (It is up to the AI to respect this radius.)
|'''LongInt'''|scount|This is the being's speed count or energy. It counts up by the being's speed every 0.1s, and when it reaches 5000, the being gets to act. For details, see [[Time#Fractional Time|here]].
|'''ShortInt'''|tohit|This [[accuracy]] modifier is applied to all of the being's attacks.
|'''ShortInt'''|todam|This damage modifier is applied to all the being's melee attacks.
|'''ShortInt'''|todamall|This damage modifier is applied to all the being's attacks.
|'''ShortInt'''|tohitmelee|This accuracy modifier is applied to the being's melee attacks.
|'''Byte'''|speed|This is the rate at which the being's scount increases. It affects the speed of all actions.
|'''Byte'''|armor|This is the being's natural armor. It appears as [[protection]] against all attacks.
|'''Word'''|expvalue|This is the amount of [[experience]] that is awarded to the player when the being dies.
|'''ShortInt'''|techbonus|This usually corresponds to [[Whizkid]] levels; it affects the number of mods that can be applied and the level of assemblies that can be constructed.
|'''ShortInt'''|pistolbonus|This usually corresponds to [[Son of a Gun]] levels; it affects pistol firing time and damage.
|'''ShortInt'''|rapidbonus|This usually corresponds to [[Triggerhappy]] levels; it affects the number of shots fired by rapid-fire weapons.
|'''ShortInt'''|bodybonus|This is the property used to implement [[Badass]]. Each point reduces [[knockback]] by one, and anything above zero stops health decay.
|'''Byte'''|reloadtime|This is the percentage of normal reload time that the being takes to reload. (It is used to implement [[Reloader]].)
|'''Byte'''|firetime|This is the percentage of normal fire time that the being takes to fire. (It is used to implement [[Finesse]].)
|'''Byte'''|movetime|This is the percentage of normal movement time that the being takes to move. For the player, anything less than 100 applies a corresponding dodge bonus. (This is used to implement [[Hellrunner]].)
|'''Word'''|soundact|This is the being's .act sound.
|'''Word'''|soundhit|This is the being's .hit sound.
|'''Word'''|sounddie|This is the being's .die sound.
|'''Word'''|soundattack|This is the being's .attack sound.
|'''Word'''|soundmelee|This is the being's .melee sound.
|'''Word'''|soundhoof|This is the being's .hoof sound.
|[[Modding:Being|Being Prototype]]|proto|This is the being's prototype.
|}}
|}

== API ==
The [[Modding:Thing#API|Thing API]] can also be used with beings.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="2" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|Being Interface
{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|[[Modding:Being|Being]]|being.[[#being_new|new]]([[Modding:Being|Being ID]] id)
|'''void'''|[[Modding:Being|Being]]:[[#being_destroy|destroy]]('''boolean''' silent)
|'''void'''|[[Modding:Being|Being]]:[[#being_kill|kill]]('''boolean''' overkill)
|'''void'''|[[Modding:Being|Being]]:[[#being_ressurect|ressurect]]('''integer''' rrange)
|'''void'''|[[Modding:Being|Being]]:[[#being_apply_damage|apply_damage]]('''integer''' damage, [[Modding:Constants#BodyTarget|BodyTarget]] target, [[Modding:Constants#DamageType|DamageType]] damageType)
|'''string'''|[[Modding:Being|Being]]:[[#being_get_name|get_name]]('''boolean''' known, '''boolean''' capitalized)
|[[Modding:Item|Item]]|[[Modding:Being|Being]]:[[#being_get_inv_item|get_inv_item]]('''integer''' slot)
|'''void'''|[[Modding:Being|Being]]:[[#being_set_inv_item|set_inv_item]]('''integer''' slot, [[Modding:Item|Item]] item)
|[[Modding:Item|Item]]|[[Modding:Being|Being]]:[[#being_get_eq_item|get_eq_item]]([[Modding:Constants#Equip Slots|Equip Slot]] slot)
|'''void'''|[[Modding:Being|Being]]:[[#being_set_eq_item|set_eq_item]]([[Modding:Constants#Equip Slots|Equip Slot]] slot, [[Modding:Item|Item]] item)
|'''void'''|[[Modding:Being|Being]]:[[#being_play_sound|play_sound]]('''Sound ID''' sound)
|'''integer'''|[[Modding:Being|Being]]:[[#being_get_total_resistance|get_total_resistance]]([[Modding:Constants#Resistance|Resistance]] resistance, [[Modding:Constants#BodyTarget|BodyTarget]] target)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_use|use]]('''integer''' slot)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_wear|wear]]('''integer''' slot)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_pickup|pickup]]([[Modding:Coord|Coord]] pos)
|'''void'''|[[Modding:Being|Being]]:[[#being_attack|attack]]([[Modding:Coord|Coord]] or [[Modding:Being|Being]] target)
|'''void'''|[[Modding:Being|Being]]:[[#being_fire|fire]]([[Modding:Coord|Coord]] target, [[Modding:Item|Item]] weapon)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_reload|reload]]()
|'''integer'''|[[Modding:Being|Being]]:[[#being_direct_seek|direct_seek]]([[Modding:Coord|Coord]] target)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_path_find|path_find]]([[Modding:Coord|Coord]] target, '''integer''' cutoff, '''integer''' maximum)
|'''integer'''|[[Modding:Being|Being]]:[[#being_path_next|path_next]]()
|[[Modding:Coord|Coord]]|[[Modding:Being|Being]]:[[#being_flock_target|flock_target]]('''integer''' range, '''integer''' mind, '''integer''' maxd)
|'''void'''|[[Modding:Being|Being]]:[[#being_msg|msg]]('''string''' msg_player, '''string''' msg_being)
|[[Modding:Item|Item]]|[[Modding:Being|Being]]:[[#being_select_slot_by_letter|select_slot_by_letter]]('''string''' letter)
|'''void'''|[[Modding:Being|Being]]:[[#being_phase|phase]]([[Modding:Cell|Cell ID]] cell)
|'''void'''|[[Modding:Being|Being]]:[[#being_spawn|spawn]]([[Modding:Being|Being ID]] being)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_is_visible|is_visible]]()
|'''boolean'''|[[Modding:Being|Being]]:[[#being_is_player|is_player]]()
|'''integer'''|[[Modding:Being|Being]]:[[#being_set_items|set_items]]([[Modding:ItemSet|ItemSet]] set)
|'''void'''|[[Modding:Being|Being]]:[[#being_nuke|nuke]]('''integer''' time)
|[[Modding:Item|Item]], '''boolean'''|[[Modding:Being|Being]]:[[#being_pick_mod_item|pick_mod_item]]('''string''' modletter, '''integer''' techbonus)
|}}
|}

{{Anchor|being_new}}
;being.new([[Modding:Being|Being ID]] id) → [[Modding:Being|Being]]
:This creates a newly allocated being of the appropriate type. The being won't exist on the map until it is placed by e.g. Level.drop_being.
----
{{Anchor|being_destroy}}
;[[Modding:Being|Being]]:destroy('''boolean''' silent)
:Deallocates the memory associated with the being and removes it from the level (if applicable). The normal results of killing a being (e.g. leaving a corpse) are ignored. The ''silent'' parameter is optional. If true, applicable OnKill and OnKillAll hooks and events will also be ignored.
----
{{Anchor|being_kill}}
;[[Modding:Being|Being]]:kill('''boolean''' overkill)
:Kills the being. If the optional ''overkill'' parameter is true, then the being will be gibbed.
----
{{Anchor|being_ressurect}}
;[[Modding:Being|Being]]:ressurect('''integer''' rrange)
:Resurrects a single corpse that is found within a square of side-length 2 × ''rrange'' + 1, centered around the being. Nearer corpses are preferred. The corpse must not have another being standing on it and must be within sight of the being (as determined by the enemy line-of-sight algorithm). The resurrected being (if any) will have BF_NOEXP set. Messages are included.
----
{{Anchor|being_apply_damage}}
;[[Modding:Being|Being]]:apply_damage('''integer''' damage, [[Modding:Constants#BodyTarget|BodyTarget]] target, [[Modding:Constants#DamageType|DamageType]] damageType)
:Deals damage to the being using the given body target and damage type. (The default damage type is bullet damage.)
----
{{Anchor|being_get_name}}
;[[Modding:Being|Being]]:get_name('''boolean''' known, '''boolean''' capitalized) → '''string'''
:Returns the name of the being. If ''known'' is true, "the" is added, otherwise "a" or "an" is added. If BF_UNIQUENAME is set for the being, then no article is used in either case. If ''capitalized'' is true, then the first letter will be capitalized.
----
{{Anchor|being_get_inv_item}}
;[[Modding:Being|Being]]:get_inv_item('''integer''' slot) → [[Modding:Item|Item]]
;[[Modding:Being|Being]].inv['''integer''' slot] → [[Modding:Item|Item]]
:Returns the item in the given slot in the being's inventory. If the slot is empty, nil is returned instead.
----
{{Anchor|being_set_inv_item}}
;[[Modding:Being|Being]]:set_inv_item('''integer''' slot, [[Modding:Item|Item]] item)
;[[Modding:Being|Being]].inv['''integer''' slot] = [[Modding:Item|Item]] item
:Sets the given slot in the being's inventory to the given item. If the slot wasn't empty before, the previous constents are lost.
----
{{Anchor|being_get_eq_item}}
;[[Modding:Being|Being]]:get_eq_item([[Modding:Constants#Equip Slots|Equip Slot]] slot) → [[Modding:Item|Item]]
;[[Modding:Being|Being]].eq[[[Modding:Constants#Equip Slots|Equip Slot]] slot] → [[Modding:Item|Item]]
:Returns the item in the given equipment slot of the being. If the slot is empty, nil is returned instead. There are additional shorthands for each equipment slot: the ''eq'' table has .weapon, .prepared, .armor, and .boots fields.
----
{{Anchor|being_set_eq_item}}
;[[Modding:Being|Being]]:set_eq_item([[Modding:Constants#Equip Slots|Equip Slot]] slot, [[Modding:Item|Item]] item)
;[[Modding:Being|Being]].eq[[[Modding:Constants#Equip Slots|Equip Slot]] slot] = [[Modding:Item|Item]] item
:Sets the being's equipment slot to the given item. Any item that was previously in that slot is lost. There are additional shorthands for each equipment slot: the ''eq'' table has .weapon, .prepared, .armor, and .boots fields.
----
{{Anchor|being_play_sound}}
;[[Modding:Being|Being]]:play_sound('''Sound ID''' sound)
:Plays the given sound as if it came from the being's position.
----
{{Anchor|being_get_total_resistance}}
;[[Modding:Being|Being]]:get_total_resistance([[Modding:Constants#Resistance|Resistance]] resistance, [[Modding:Constants#BodyTarget|BodyTarget]] target) → '''integer'''
:Calculates the being's effective resistance against attacks of the given target (default is body). This accounts for inherent resists as well as equipment bonuses.
----
{{Anchor|being_use}}
;[[Modding:Being|Being]]:use('''integer''' slot) → '''boolean'''
;[[Modding:Being|Being]]:use([[Modding:Item|Item]] item) → '''boolean'''
:This makes the being use the given consumable item from its inventory. The function always returns false. (Bug: it is supposed to return true on success.)
----
{{Anchor|being_wear}}
;[[Modding:Being|Being]]:wear('''integer''' slot) → '''boolean'''
;[[Modding:Being|Being]]:wear([[Modding:Item|Item]] item) → '''boolean'''
:This makes the being wear the given eqipment from its inventory. Returns true on success and false on failure.
----
{{Anchor|being_pickup}}
;[[Modding:Being|Being]]:pickup([[Modding:Coord|Coord]] pos) → '''boolean'''
:This makes the being pick up the item at the given position. ''pos'' is optional; it defaults to the being's position. Returns true on success and false on failure.
----
{{Anchor|being_attack}}
;[[Modding:Being|Being]]:attack([[Modding:Coord|Coord]] or [[Modding:Being|Being]] target)
:This makes the being do a standard melee attack against the targeted being or coord.
----
{{Anchor|being_fire}}
;[[Modding:Being|Being]]:fire([[Modding:Coord|Coord]] target, [[Modding:Item|Item]] weapon)
:This makes the being fire at ''target'' with ''weapon''.
----
{{Anchor|being_reload}}
;[[Modding:Being|Being]]:reload() → '''boolean'''
:This makes the being reload its currently equipped weapon. The return value is true if there being had at least some of the appropriate ammo to attempt reloading with.
----
{{Anchor|being_direct_seek}}
;[[Modding:Being|Being]]:direct_seek([[Modding:Coord|Coord]] target) → '''integer'''
:This makes the being take a step towards the target. The being will always try to travel in a direct path. The return value is either 0, 1, 2, or 3. 0 indicates success, 1 indicates that a wall blocked the move, 2 indicates that a door blocked the move, and 3 indicates that a being blocked the move.
----
{{Anchor|being_path_find}}
;[[Modding:Being|Being]]:path_find([[Modding:Coord|Coord]] target, '''integer''' cutoff, '''integer''' maximum) → '''boolean'''
:This attempts to calculate a path between the being and ''target''. The ''cutoff'' and ''maximum'' parameters are somewhat technical, but basically they indicate how much time should be spend searching for a path. DoomRL uses 40, 200 for bosses and 10, 40 for normal enemies. The path will be remembered by the being, and can be followed using path_next. Modders should keep in mind that path-finding is a somewhat expensive operation, especially for large ''cutoff'' and ''maximum''. The return value indicates whether a path was found. Even if no path was found, a path will be loaded that will try to take the being closer to the target (although this path may be empty). This uses the AStar searching algorithm using Euclidean distance as a heuristic. The search is aborted if ''maximum'' nodes are expanded without finding the target or it ''cutoff'' nodes are expanded without getting closer to the target. When aborted, a path is created to the closest expanded node to the target in terms of the heuristic.
----
{{Anchor|being_path_next}}
;[[Modding:Being|Being]]:path_next() → '''integer'''
:This causes the being to take a step along the path last calculated by path_find. The return value follows the pattern of direct_seek.
----
{{Anchor|being_flock_target}}
;[[Modding:Being|Being]]:flock_target('''integer''' range, '''integer''' mind, '''integer''' maxd) → [[Modding:Coord|Coord]]
:This looks for the closest being of the same type to the being (within a square ''range''). If the being is farther than ''maxd'' away, then its position is returned. If it is closer than ''mind'', then a position opposite from the closest with respect to the being is returned. Otherwise (or if there is no nearby being of the same type), a random coord from the scanning area is returned.
----
{{Anchor|being_msg}}
;[[Modding:Being|Being]]:msg('''string''' msg_player, '''string''' msg_being)
:If the being is the player, then ''msg_player'' is displayed. If the being is not the player, but visible to the player, the ''msg_being'' is displayed. If either message is nil it is ignored.
----
{{Anchor|being_select_slot_by_letter}}
;[[Modding:Being|Being]]:select_slot_by_letter('''string''' letter) → [[Modding:Item|Item]]
:Returns the one of the being's equipment where "a" is for armor, "b" is for boots, "w" is for weapon, and "p" is for the prepared slot. If the slot is empty, nil is returned.
----
{{Anchor|being_phase}}
;[[Modding:Being|Being]]:phase([[Modding:Cell|Cell ID]] cell)
:If ''cell'' is omitted, then the being is displaced randomly as if it used a [[phase device]] (without the flashy interface stuff). If the cell is included, the being is displaced to a random cell of the given cell id. If the chosen cell is occupied, a nearby cell is used. If no such cell exists, a random cell is chosen.
----
{{Anchor|being_spawn}}
;[[Modding:Being|Being]]:spawn([[Modding:Being|Being ID]] being)
;[[Modding:Being|Being]]:spawn([[Modding:Being|Being]] being)
:Drops a new being of the appropriate type (or the given being) nearby. The dropped being is set with the BF_NOEXP flag.
----
{{Anchor|being_is_visible}}
;[[Modding:Being|Being]]:is_visible() → '''boolean'''
:Determines if the player can see the being.
----
{{Anchor|being_is_player}}
;[[Modding:Being|Being]]:is_player() → '''boolean'''
:Determines if the being is the player.
----
{{Anchor|being_set_items}}
;[[Modding:Being|Being]]:set_items([[Modding:ItemSet|ItemSet]] set) → '''integer'''
:Counts the number of the being's equipped items that belong to the given set.
----
{{Anchor|being_nuke}}
;[[Modding:Being|Being]]:nuke('''integer''' time)
:Sets the nuke timer to ''time'' and changes the cell under the being to the nuke cell. By default, ''time'' is 1. (Setting the nuke time to 0 will disable the countdown.)
----
{{Anchor|being_pick_mod_item}}
;[[Modding:Being|Being]]:pick_mod_item('''string''' modletter, '''integer''' techbonus) → [[Modding:Item|Item]], '''boolean'''
:This only works for the player. This gives the player the item select menu used by mods, and calculates whether the mod is legal (using the given ''techbonus''). This includes assembly checking. The first return value is the item on success. The second return value is true on success and false on failure. (''modletter'' should be the length one string corresponding to the mod type.)

Modding:being (0.9.9.7)

2012-01-31T21:04:25Z

Game Hunter: also it's IF_BLADE not IF_BLADED

If it bleeds, it leads. Beings inherit from the [[Modding:Thing|Thing]] base class which handles some basic properties in common with items. In addition the [[Modding:Player|Player]] inherits this class, so anything you can do to creatures can be done to the player as well.

== Prototype ==

New beings are created from being prototypes. Think of a being prototype as a recipe for creating new beings. There can be multiple former humans, but they all came from the same prototype. Prototypes are declared by passing a table with the desired properties to the Beings function. [[#Engine Hooks|Engine hooks]] may also be included in the prototype. Mostly, the prototype's properties just describe beings' initial properties (occasionally with different names). Beings' properties can also mostly be changed after they are instantiated. Required fields are underlined. Sometimes required fields can safely be omitted, but this will generate a message in the log file. All being prototypes are stored in a global table called beings. This table can be indexed by id or nid.
{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Being Prototype'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''string'''|name|This is the being's name.
|'''string'''|name_plural|This is the being's name_plural. By default, this is the name with an "s" appended.
|'''string'''|ascii|This is the being's picture. It should be a single character string.
|'''string'''|id|This is the being's sid. It must be distinct from other string ids. (The numeric id is automatically assigned to a field called nid.) Only the first 20 characters will be used. The default is the first word of the name in all lowercase.
|'''integer''' '''list'''|overlay|This field is only used in the graphical version. It describes a color transformation to be applied to the being's sprite. This will create overlay_red, overlay_green, overlay_blue, and overlay_alpha fields in the being prototype.
|'''integer'''|XP|This is the being's expvalue. By default, it is <font-family: monospace>3xD2+20, where D is the being's danger (see below).
|[[Modding:Cell|Cell ID]]|corpse|The determines the corpse left by the being. If the value is true, a new corpse cell will automatically be created. Otherwise this field is interpretted as a cell id. After a being is declared, this field will have been translated to a number. The default is true.
|[[Modding:Item|Item Prototype]]|weapon|If this field is included, a new item will be declared and automatically equipped for beings generated from this prototype. The item prototype will automatically be a natural ranged weapon, have an id assigned, have zero weight, have no sprite, and have the IF_NODROP and IF_NOAMMO flags.
|'''integer'''|sprite|This is the being's sprite. (Use 0 for no sprite.)
|[[Modding:Constants#Colors|Color]]|color|This is the being's color.
|'''integer'''|toDam|This is the being's toDam. (This bonus only applies to melee attacks.) The default is 0.
|'''integer'''|toHit|This is the being's toHit. The default is 0.
|'''integer'''|speed|This is the being's speed. (Remember, the maximum allowed speed is 255.) The default is 100.
|'''integer'''|armor|This is the being's armor. The default is 0.
|'''integer'''|danger|This is a [[Monster Generation|monster generation]] parameter.
|'''integer'''|weight|This is a [[Monster Generation|monster generation]] parameter.
|'''integer'''|minLev|This is a [[Monster Generation|monster generation]] parameter.
|'''integer'''|maxLev|This is a [[Monster Generation|monster generation]] parameter. The default is 200.
|'''integer'''|HP|This is the being's hpmax and starting hp. The default is 10.
|'''integer'''|bulk|This parameter is unused. The default is 100.
|'''integer'''|group|Monsters from different groups will fight each other if they use the default AI. Oddly, the default is "weapon-other" which, as a string, translates to 0. The player is in group 1.
|'''integer'''|attackchance|This is the being's attackchance The default is 75.
|'''integer'''|toHitMelee|This is the being's toHitMelee. The default is 0.
|[[Modding:Constants#Being Flags|Being Flag]] '''list'''|flags|The flags in this list will be included in the being's flag set. Upon instantiation, a flagSet property is added to the prototype will include these flags (and possibly some automatic flags) in set format. The default is an empty list.
|'''string'''|sound_id|If included and the being doesn't have sound bindings configured, then it will look for sound bindings under its sound_id.
|[[Modding:AI|AI ID]]|ai_type|This determines the being's AI. By default, the old pascal AI is used. (The pascal AI doesn't have an id.)
|'''integer'''|vision|This is the being's vision. The default is 9. (The player also has vision 9 by default.)
|'''integer'''|res_bullet|This is the being's res_bullet. The default is 0.
|'''integer'''|res_melee|This is the being's res_melee. The default is 0.
|'''integer'''|res_shrapnel|This is the being's res_shrapnel. The default is 0.
|'''integer'''|res_acid|This is the being's res_acid. The default is 0.
|'''integer'''|res_fire|This is the being's res_fire. The default is 0.
|'''integer'''|res_plasma|This is the being's res_plasma. The default is 0.
|'''string'''|desc|This is the description of the being displayed in the more information view.
|'''string'''|kill_desc|If included, this being will have a special kill description in the mortem.
|'''string'''|kill_desc_melee|As kill_desc, but for melee kills.
|}}
|}
=== Flags ===
==== Being Flags ====
{{drltable|Being Flags|2|{{Table2Col
|es=background: #333;
|c1=font-family:monospace; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|BF_INV|Stops the being from taking any damage. (Directly setting the being's HP can circumvent this. Does not work well with the being's HP set to zero.)
|BF_BERSERK|Gives the damage reduction and melee damage bonus of [[Effects#Berserk|berserk]]. (The speed bonus is not included.)
|BF_ENVIROSAFE|Beings with this flag are immune to damage from acid and lava tiles. (New hazardous tiles will have to check for this flag to respect it.)
|BF_BACKPACK|Gives the ammo-stacking benefits of the [[Backpack]] powerup.
|BF_POWERBONUS|Extends the duration of powerups as the [[Marine]] class bonus. New powerups will have to check for this flag (or use the provided helper function) to respect it.
|BF_STAIRSENSE|For the player, reveals the stairs tile(s) as the [[Scout]] class bonus.
|BF_INSTAUSE|Allows consumable items to be used in 0.1s instead of the usual 1.0s, as the [[Technician]] class bonus.
|BF_MAPEXPERT|Makes computer maps work like tracking maps, as the [[Technician]] class bonus.
|BF_MODEXPERT|Allows the being to mod unique items.
|BF_QUICKSWAP|Gives the benefits of the Juggler trait.
|BF_BERSERKER|Gives the benefits of the [[Traits#Berserker|Berserker]] trait.
|BF_DUALGUN|Gives the benefits of the dualgunner trait.
|BF_MASTERDODGE|Gives the benefits of the [[Traits#Dodgemaster|Dodgemaster]] trait.
|BF_SHOTTYMAN|Gives the benefits of the [[Traits#Shottyman|Shottyman]] trait.
|BF_POWERSENSE|For the player, shows the locations of all powerups (as the first level of the [[Traits#Intuition|Intuition]] trait).
|BF_BEINGSENSE|For the player, shows the locations of enemies (as the second level of the Intuition trait).
|BF_LEVERSENSE1|For the player, gives partial information about levers (as the first level of the Intuition trait).
|BF_LEVERSENSE2|For the player, shows the exact effect of levers (as the second level of the Intuition trait).
|BF_VAMPYRE|Gives the benefits of the [[Traits#Vampyre|Vampyre]] trait.
|BF_BULLETDANCE|Gives the benefits of the [[Traits#Bullet Dance|Bullet Dance]] trait.
|BF_ARMYDEAD|Gives the benefits of the [[Traits#Army of the Dead|Army of the Dead]] trait.
|BF_AMMOCHAIN|Gives the benefits of the [[Traits#Ammochain|Ammochain]] trait.
|BF_MEDPLUS|Allows med-packs to heal beyond 100% health (part of the [[Survivalist]] trait).
|BF_HARDY|Allows protection to reduce damage all the way to zero (part of the [[Survivalist]] trait).
|BF_CLEAVE|Gives the benefits of the [[Traits#Blademaster|Blademaster]] trait.
|BF_GUNKATA|Gives the benefits of the [[Traits#Gun Kata|Gun Kata]] trait.
|BF_SHOTTYHEAD|Gives the benefits of the [[Traits#Shottyhead|Shottyhead]] trait.
|BF_NORUNPENALTY|Gives the benefits of the [[Traits#Running Man|Running Man]] trait.
|BF_DUALBLADE|If both weapons in the being's equipment slots have IF_BLADE, this flag allows both weapons to attack in the same turn, each at half the attack time (part of the [[Traits#Malicious Blades|Malicious Blades]] trait).
|BF_BLADEDEFEND|If the weapon in the being's prepared slot has IF_BLADE, this flag grants the being with resistances as [[Traits#Malicious Blades|Malicious Blades]].
|BF_PISTOLMAX|Gives the benefits of the [[Sharpshooter]] trait.
|BF_FIREANGEL|Gives the benefits of the [[Traits#Fireangel|Fireangel]] trait.
|BF_ENTRENCHMENT|Gives the benefits of the [[Traits#Entrenchment|Entrenchment]] trait.
|BF_SCAVENGER|Gives the benefits of the [[Scavenger]] trait (useless on anything other than the player).
|BF_IMPATIENT|This flag causes packs to be automatically used when picked up as [[Angel of Impatience]].
|BF_DARKNESS|For the player, stops exploration from being recorded as in [[Angel of Darkness]].
|BF_MAXDAMAGE|Beings with this flag always roll maximum damage as in [[Angel of Max Carnage]].
|BF_NOHEAL|This is a marker flag that stops healing effects from working as in [[Angel of Masochism]]. New sources of healing will have to check for this flag in order to respect it.
|BF_SESSILE|Beings with this flag cannot move.
|BF_NOMELEE|This flag stops the being from doing any type of melee attack.
|BF_REGENERATE|Beings with this flag regenerate one health per second if they have less than 20 health remaining.
|BF_SELFIMMUNE|Makes the being immune to its own attacks.
|BF_KNOCKIMMUNE|Makes the being immune to [[knockback]].
|BF_UNIQUENAME|This flag makes the game treat the being's name as a proper noun.
|BF_ENTERBOSS1|This is a flag for the player that helps determine which victory message to use in the mortem.
|BF_KILLBOSS1|This is a flag for the player that helps determine which victory message to use in the mortem.
|BF_ENTERBOSS2|This is a flag for the player that helps determine which victory message to use in the mortem.
|BF_KILLBOSS2|This is a flag for the player that helps determine which victory message to use in the mortem.
|BF_CHARGE|This is a flag for the AI. Beings with this flag are willing to walk through hazardous cells to reach the player. (This applies to the default AI, and the direct_seek method.)
|BF_HUNTING|This is a flag for the default AI. Beings with this flag will search out the player even if he is not in their line of sight.
|BF_OPENDOORS|This is a flag for the default AI. Beings with this flag will open doors.
|BF_NODROP|Beings with this flag will not drop their inventory or equipment when they die.
|BF_NOEXP|Beings with this flag will not award experience to the player.
|BF_BOSS|Killing this monster will cause the same message as killing the final boss as well as its death explosion and ending the game.
|BF_JC||When used with BF_BOSS, changes the explosion to blue and changes the message to indicate that JC was killed instead of the cyberdemon.
|}}
}}
== Engine Hooks ==
Specifying one or more of these hooks in the prototype will allow for greater customization.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="2" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Being Hooks'''
{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|'''void'''|[[#being_OnCreate|OnCreate]]([[Modding:Being|Being]] self)
|'''void'''|[[#being_OnAction|OnAction]]([[Modding:Being|Being]] self)
|'''void'''|[[#being_OnDie|OnDie]]([[Modding:Being|Being]] self, '''boolean''' overkill)
|}}
|}

{{Anchor|being_OnCreate}}
;OnCreate([[Modding:Being|Being]] self)
:This is called when the being is created.
----
{{Anchor|being_OnAction}}
;OnAction([[Modding:Being|Being]] self)
:This is called at the beginning of each of the being's turns. (Note that turns are only differentiated if time elapses in between.)
----
{{Anchor|being_OnDie}}
;OnDie([[Modding:Being|Being]] self, '''boolean''' overkill)
:This is called when the being dies. ''overkill'' is true if the being was gibbed.

== Properties ==
Beings also have all the [[Modding:Thing|Thing]] properties in addition to those listed below. For beings, the resistance fields are inherent resistances that apply to all attacks.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|Being
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''Byte'''|attackchance|This is how likely (in percent) a monster is to use a ranged attack on its turn. The exact interpretation may depend on the AI. This property is read-only.
|'''Integer'''|hp|This is the being's current [[health]].
|'''Word'''|hpmax|This is the being's maximum health.
|'''Byte'''|vision|This is the being's vision radius. (It is up to the AI to respect this radius.)
|'''LongInt'''|scount|This is the being's speed count or energy. It counts up by the being's speed every 0.1s, and when it reaches 5000, the being gets to act. For details, see [[Time#Fractional Time|here]].
|'''ShortInt'''|tohit|This [[accuracy]] modifier is applied to all of the being's attacks.
|'''ShortInt'''|todam|This damage modifier is applied to all the being's melee attacks.
|'''ShortInt'''|todamall|This damage modifier is applied to all the being's attacks.
|'''ShortInt'''|tohitmelee|This accuracy modifier is applied to the being's melee attacks.
|'''Byte'''|speed|This is the rate at which the being's scount increases. It affects the speed of all actions.
|'''Byte'''|armor|This is the being's natural armor. It appears as [[protection]] against all attacks.
|'''Word'''|expvalue|This is the amount of [[experience]] that is awarded to the player when the being dies.
|'''ShortInt'''|techbonus|This usually corresponds to [[Whizkid]] levels; it affects the number of mods that can be applied and the level of assemblies that can be constructed.
|'''ShortInt'''|pistolbonus|This usually corresponds to [[Son of a Gun]] levels; it affects pistol firing time and damage.
|'''ShortInt'''|rapidbonus|This usually corresponds to [[Triggerhappy]] levels; it affects the number of shots fired by rapid-fire weapons.
|'''ShortInt'''|bodybonus|This is the property used to implement [[Badass]]. Each point reduces [[knockback]] by one, and anything above zero stops health decay.
|'''Byte'''|reloadtime|This is the percentage of normal reload time that the being takes to reload. (It is used to implement [[Reloader]].)
|'''Byte'''|firetime|This is the percentage of normal fire time that the being takes to fire. (It is used to implement [[Finesse]].)
|'''Byte'''|movetime|This is the percentage of normal movement time that the being takes to move. For the player, anything less than 100 applies a corresponding dodge bonus. (This is used to implement [[Hellrunner]].)
|'''Word'''|soundact|This is the being's .act sound.
|'''Word'''|soundhit|This is the being's .hit sound.
|'''Word'''|sounddie|This is the being's .die sound.
|'''Word'''|soundattack|This is the being's .attack sound.
|'''Word'''|soundmelee|This is the being's .melee sound.
|'''Word'''|soundhoof|This is the being's .hoof sound.
|[[Modding:Being|Being Prototype]]|proto|This is the being's prototype.
|}}
|}

== API ==
The [[Modding:Thing#API|Thing API]] can also be used with beings.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="2" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|Being Interface
{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|[[Modding:Being|Being]]|being.[[#being_new|new]]([[Modding:Being|Being ID]] id)
|'''void'''|[[Modding:Being|Being]]:[[#being_destroy|destroy]]('''boolean''' silent)
|'''void'''|[[Modding:Being|Being]]:[[#being_kill|kill]]('''boolean''' overkill)
|'''void'''|[[Modding:Being|Being]]:[[#being_ressurect|ressurect]]('''integer''' rrange)
|'''void'''|[[Modding:Being|Being]]:[[#being_apply_damage|apply_damage]]('''integer''' damage, [[Modding:Constants#BodyTarget|BodyTarget]] target, [[Modding:Constants#DamageType|DamageType]] damageType)
|'''string'''|[[Modding:Being|Being]]:[[#being_get_name|get_name]]('''boolean''' known, '''boolean''' capitalized)
|[[Modding:Item|Item]]|[[Modding:Being|Being]]:[[#being_get_inv_item|get_inv_item]]('''integer''' slot)
|'''void'''|[[Modding:Being|Being]]:[[#being_set_inv_item|set_inv_item]]('''integer''' slot, [[Modding:Item|Item]] item)
|[[Modding:Item|Item]]|[[Modding:Being|Being]]:[[#being_get_eq_item|get_eq_item]]([[Modding:Constants#Equip Slots|Equip Slot]] slot)
|'''void'''|[[Modding:Being|Being]]:[[#being_set_eq_item|set_eq_item]]([[Modding:Constants#Equip Slots|Equip Slot]] slot, [[Modding:Item|Item]] item)
|'''void'''|[[Modding:Being|Being]]:[[#being_play_sound|play_sound]]('''Sound ID''' sound)
|'''integer'''|[[Modding:Being|Being]]:[[#being_get_total_resistance|get_total_resistance]]([[Modding:Constants#Resistance|Resistance]] resistance, [[Modding:Constants#BodyTarget|BodyTarget]] target)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_use|use]]('''integer''' slot)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_wear|wear]]('''integer''' slot)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_pickup|pickup]]([[Modding:Coord|Coord]] pos)
|'''void'''|[[Modding:Being|Being]]:[[#being_attack|attack]]([[Modding:Coord|Coord]] or [[Modding:Being|Being]] target)
|'''void'''|[[Modding:Being|Being]]:[[#being_fire|fire]]([[Modding:Coord|Coord]] target, [[Modding:Item|Item]] weapon)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_reload|reload]]()
|'''integer'''|[[Modding:Being|Being]]:[[#being_direct_seek|direct_seek]]([[Modding:Coord|Coord]] target)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_path_find|path_find]]([[Modding:Coord|Coord]] target, '''integer''' cutoff, '''integer''' maximum)
|'''integer'''|[[Modding:Being|Being]]:[[#being_path_next|path_next]]()
|[[Modding:Coord|Coord]]|[[Modding:Being|Being]]:[[#being_flock_target|flock_target]]('''integer''' range, '''integer''' mind, '''integer''' maxd)
|'''void'''|[[Modding:Being|Being]]:[[#being_msg|msg]]('''string''' msg_player, '''string''' msg_being)
|[[Modding:Item|Item]]|[[Modding:Being|Being]]:[[#being_select_slot_by_letter|select_slot_by_letter]]('''string''' letter)
|'''void'''|[[Modding:Being|Being]]:[[#being_phase|phase]]([[Modding:Cell|Cell ID]] cell)
|'''void'''|[[Modding:Being|Being]]:[[#being_spawn|spawn]]([[Modding:Being|Being ID]] being)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_is_visible|is_visible]]()
|'''boolean'''|[[Modding:Being|Being]]:[[#being_is_player|is_player]]()
|'''integer'''|[[Modding:Being|Being]]:[[#being_set_items|set_items]]([[Modding:ItemSet|ItemSet]] set)
|'''void'''|[[Modding:Being|Being]]:[[#being_nuke|nuke]]('''integer''' time)
|[[Modding:Item|Item]], '''boolean'''|[[Modding:Being|Being]]:[[#being_pick_mod_item|pick_mod_item]]('''string''' modletter, '''integer''' techbonus)
|}}
|}

{{Anchor|being_new}}
;being.new([[Modding:Being|Being ID]] id) → [[Modding:Being|Being]]
:This creates a newly allocated being of the appropriate type. The being won't exist on the map until it is placed by e.g. Level.drop_being.
----
{{Anchor|being_destroy}}
;[[Modding:Being|Being]]:destroy('''boolean''' silent)
:Deallocates the memory associated with the being and removes it from the level (if applicable). The normal results of killing a being (e.g. leaving a corpse) are ignored. The ''silent'' parameter is optional. If true, applicable OnKill and OnKillAll hooks and events will also be ignored.
----
{{Anchor|being_kill}}
;[[Modding:Being|Being]]:kill('''boolean''' overkill)
:Kills the being. If the optional ''overkill'' parameter is true, then the being will be gibbed.
----
{{Anchor|being_ressurect}}
;[[Modding:Being|Being]]:ressurect('''integer''' rrange)
:Resurrects a single corpse that is found within a square of side-length 2 × ''rrange'' + 1, centered around the being. Nearer corpses are preferred. The corpse must not have another being standing on it and must be within sight of the being (as determined by the enemy line-of-sight algorithm). The resurrected being (if any) will have BF_NOEXP set. Messages are included.
----
{{Anchor|being_apply_damage}}
;[[Modding:Being|Being]]:apply_damage('''integer''' damage, [[Modding:Constants#BodyTarget|BodyTarget]] target, [[Modding:Constants#DamageType|DamageType]] damageType)
:Deals damage to the being using the given body target and damage type. (The default damage type is bullet damage.)
----
{{Anchor|being_get_name}}
;[[Modding:Being|Being]]:get_name('''boolean''' known, '''boolean''' capitalized) → '''string'''
:Returns the name of the being. If ''known'' is true, "the" is added, otherwise "a" or "an" is added. If BF_UNIQUENAME is set for the being, then no article is used in either case. If ''capitalized'' is true, then the first letter will be capitalized.
----
{{Anchor|being_get_inv_item}}
;[[Modding:Being|Being]]:get_inv_item('''integer''' slot) → [[Modding:Item|Item]]
;[[Modding:Being|Being]].inv['''integer''' slot] → [[Modding:Item|Item]]
:Returns the item in the given slot in the being's inventory. If the slot is empty, nil is returned instead.
----
{{Anchor|being_set_inv_item}}
;[[Modding:Being|Being]]:set_inv_item('''integer''' slot, [[Modding:Item|Item]] item)
;[[Modding:Being|Being]].inv['''integer''' slot] = [[Modding:Item|Item]] item
:Sets the given slot in the being's inventory to the given item. If the slot wasn't empty before, the previous constents are lost.
----
{{Anchor|being_get_eq_item}}
;[[Modding:Being|Being]]:get_eq_item([[Modding:Constants#Equip Slots|Equip Slot]] slot) → [[Modding:Item|Item]]
;[[Modding:Being|Being]].eq[[[Modding:Constants#Equip Slots|Equip Slot]] slot] → [[Modding:Item|Item]]
:Returns the item in the given equipment slot of the being. If the slot is empty, nil is returned instead. There are additional shorthands for each equipment slot: the ''eq'' table has .weapon, .prepared, .armor, and .boots fields.
----
{{Anchor|being_set_eq_item}}
;[[Modding:Being|Being]]:set_eq_item([[Modding:Constants#Equip Slots|Equip Slot]] slot, [[Modding:Item|Item]] item)
;[[Modding:Being|Being]].eq[[[Modding:Constants#Equip Slots|Equip Slot]] slot] = [[Modding:Item|Item]] item
:Sets the being's equipment slot to the given item. Any item that was previously in that slot is lost. There are additional shorthands for each equipment slot: the ''eq'' table has .weapon, .prepared, .armor, and .boots fields.
----
{{Anchor|being_play_sound}}
;[[Modding:Being|Being]]:play_sound('''Sound ID''' sound)
:Plays the given sound as if it came from the being's position.
----
{{Anchor|being_get_total_resistance}}
;[[Modding:Being|Being]]:get_total_resistance([[Modding:Constants#Resistance|Resistance]] resistance, [[Modding:Constants#BodyTarget|BodyTarget]] target) → '''integer'''
:Calculates the being's effective resistance against attacks of the given target (default is body). This accounts for inherent resists as well as equipment bonuses.
----
{{Anchor|being_use}}
;[[Modding:Being|Being]]:use('''integer''' slot) → '''boolean'''
;[[Modding:Being|Being]]:use([[Modding:Item|Item]] item) → '''boolean'''
:This makes the being use the given consumable item from its inventory. The function always returns false. (Bug: it is supposed to return true on success.)
----
{{Anchor|being_wear}}
;[[Modding:Being|Being]]:wear('''integer''' slot) → '''boolean'''
;[[Modding:Being|Being]]:wear([[Modding:Item|Item]] item) → '''boolean'''
:This makes the being wear the given eqipment from its inventory. Returns true on success and false on failure.
----
{{Anchor|being_pickup}}
;[[Modding:Being|Being]]:pickup([[Modding:Coord|Coord]] pos) → '''boolean'''
:This makes the being pick up the item at the given position. ''pos'' is optional; it defaults to the being's position. Returns true on success and false on failure.
----
{{Anchor|being_attack}}
;[[Modding:Being|Being]]:attack([[Modding:Coord|Coord]] or [[Modding:Being|Being]] target)
:This makes the being do a standard melee attack against the targeted being or coord.
----
{{Anchor|being_fire}}
;[[Modding:Being|Being]]:fire([[Modding:Coord|Coord]] target, [[Modding:Item|Item]] weapon)
:This makes the being fire at ''target'' with ''weapon''.
----
{{Anchor|being_reload}}
;[[Modding:Being|Being]]:reload() → '''boolean'''
:This makes the being reload its currently equipped weapon. The return value is true if there being had at least some of the appropriate ammo to attempt reloading with.
----
{{Anchor|being_direct_seek}}
;[[Modding:Being|Being]]:direct_seek([[Modding:Coord|Coord]] target) → '''integer'''
:This makes the being take a step towards the target. The being will always try to travel in a direct path. The return value is either 0, 1, 2, or 3. 0 indicates success, 1 indicates that a wall blocked the move, 2 indicates that a door blocked the move, and 3 indicates that a being blocked the move.
----
{{Anchor|being_path_find}}
;[[Modding:Being|Being]]:path_find([[Modding:Coord|Coord]] target, '''integer''' cutoff, '''integer''' maximum) → '''boolean'''
:This attempts to calculate a path between the being and ''target''. The ''cutoff'' and ''maximum'' parameters are somewhat technical, but basically they indicate how much time should be spend searching for a path. DoomRL uses 40, 200 for bosses and 10, 40 for normal enemies. The path will be remembered by the being, and can be followed using path_next. Modders should keep in mind that path-finding is a somewhat expensive operation, especially for large ''cutoff'' and ''maximum''. The return value indicates whether a path was found. Even if no path was found, a path will be loaded that will try to take the being closer to the target (although this path may be empty). This uses the AStar searching algorithm using Euclidean distance as a heuristic. The search is aborted if ''maximum'' nodes are expanded without finding the target or it ''cutoff'' nodes are expanded without getting closer to the target. When aborted, a path is created to the closest expanded node to the target in terms of the heuristic.
----
{{Anchor|being_path_next}}
;[[Modding:Being|Being]]:path_next() → '''integer'''
:This causes the being to take a step along the path last calculated by path_find. The return value follows the pattern of direct_seek.
----
{{Anchor|being_flock_target}}
;[[Modding:Being|Being]]:flock_target('''integer''' range, '''integer''' mind, '''integer''' maxd) → [[Modding:Coord|Coord]]
:This looks for the closest being of the same type to the being (within a square ''range''). If the being is farther than ''maxd'' away, then its position is returned. If it is closer than ''mind'', then a position opposite from the closest with respect to the being is returned. Otherwise (or if there is no nearby being of the same type), a random coord from the scanning area is returned.
----
{{Anchor|being_msg}}
;[[Modding:Being|Being]]:msg('''string''' msg_player, '''string''' msg_being)
:If the being is the player, then ''msg_player'' is displayed. If the being is not the player, but visible to the player, the ''msg_being'' is displayed. If either message is nil it is ignored.
----
{{Anchor|being_select_slot_by_letter}}
;[[Modding:Being|Being]]:select_slot_by_letter('''string''' letter) → [[Modding:Item|Item]]
:Returns the one of the being's equipment where "a" is for armor, "b" is for boots, "w" is for weapon, and "p" is for the prepared slot. If the slot is empty, nil is returned.
----
{{Anchor|being_phase}}
;[[Modding:Being|Being]]:phase([[Modding:Cell|Cell ID]] cell)
:If ''cell'' is omitted, then the being is displaced randomly as if it used a [[phase device]] (without the flashy interface stuff). If the cell is included, the being is displaced to a random cell of the given cell id. If the chosen cell is occupied, a nearby cell is used. If no such cell exists, a random cell is chosen.
----
{{Anchor|being_spawn}}
;[[Modding:Being|Being]]:spawn([[Modding:Being|Being ID]] being)
;[[Modding:Being|Being]]:spawn([[Modding:Being|Being]] being)
:Drops a new being of the appropriate type (or the given being) nearby. The dropped being is set with the BF_NOEXP flag.
----
{{Anchor|being_is_visible}}
;[[Modding:Being|Being]]:is_visible() → '''boolean'''
:Determines if the player can see the being.
----
{{Anchor|being_is_player}}
;[[Modding:Being|Being]]:is_player() → '''boolean'''
:Determines if the being is the player.
----
{{Anchor|being_set_items}}
;[[Modding:Being|Being]]:set_items([[Modding:ItemSet|ItemSet]] set) → '''integer'''
:Counts the number of the being's equipped items that belong to the given set.
----
{{Anchor|being_nuke}}
;[[Modding:Being|Being]]:nuke('''integer''' time)
:Sets the nuke timer to ''time'' and changes the cell under the being to the nuke cell. By default, ''time'' is 1. (Setting the nuke time to 0 will disable the countdown.)
----
{{Anchor|being_pick_mod_item}}
;[[Modding:Being|Being]]:pick_mod_item('''string''' modletter, '''integer''' techbonus) → [[Modding:Item|Item]], '''boolean'''
:This only works for the player. This gives the player the item select menu used by mods, and calculates whether the mod is legal (using the given ''techbonus''). This includes assembly checking. The first return value is the item on success. The second return value is true on success and false on failure. (''modletter'' should be the length one string corresponding to the mod type.)

Modding:being (0.9.9.7)

2012-01-31T21:03:35Z

Game Hunter: BF_MODEXPERT now correct!

If it bleeds, it leads. Beings inherit from the [[Modding:Thing|Thing]] base class which handles some basic properties in common with items. In addition the [[Modding:Player|Player]] inherits this class, so anything you can do to creatures can be done to the player as well.

== Prototype ==

New beings are created from being prototypes. Think of a being prototype as a recipe for creating new beings. There can be multiple former humans, but they all came from the same prototype. Prototypes are declared by passing a table with the desired properties to the Beings function. [[#Engine Hooks|Engine hooks]] may also be included in the prototype. Mostly, the prototype's properties just describe beings' initial properties (occasionally with different names). Beings' properties can also mostly be changed after they are instantiated. Required fields are underlined. Sometimes required fields can safely be omitted, but this will generate a message in the log file. All being prototypes are stored in a global table called beings. This table can be indexed by id or nid.
{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Being Prototype'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''string'''|name|This is the being's name.
|'''string'''|name_plural|This is the being's name_plural. By default, this is the name with an "s" appended.
|'''string'''|ascii|This is the being's picture. It should be a single character string.
|'''string'''|id|This is the being's sid. It must be distinct from other string ids. (The numeric id is automatically assigned to a field called nid.) Only the first 20 characters will be used. The default is the first word of the name in all lowercase.
|'''integer''' '''list'''|overlay|This field is only used in the graphical version. It describes a color transformation to be applied to the being's sprite. This will create overlay_red, overlay_green, overlay_blue, and overlay_alpha fields in the being prototype.
|'''integer'''|XP|This is the being's expvalue. By default, it is <font-family: monospace>3xD2+20, where D is the being's danger (see below).
|[[Modding:Cell|Cell ID]]|corpse|The determines the corpse left by the being. If the value is true, a new corpse cell will automatically be created. Otherwise this field is interpretted as a cell id. After a being is declared, this field will have been translated to a number. The default is true.
|[[Modding:Item|Item Prototype]]|weapon|If this field is included, a new item will be declared and automatically equipped for beings generated from this prototype. The item prototype will automatically be a natural ranged weapon, have an id assigned, have zero weight, have no sprite, and have the IF_NODROP and IF_NOAMMO flags.
|'''integer'''|sprite|This is the being's sprite. (Use 0 for no sprite.)
|[[Modding:Constants#Colors|Color]]|color|This is the being's color.
|'''integer'''|toDam|This is the being's toDam. (This bonus only applies to melee attacks.) The default is 0.
|'''integer'''|toHit|This is the being's toHit. The default is 0.
|'''integer'''|speed|This is the being's speed. (Remember, the maximum allowed speed is 255.) The default is 100.
|'''integer'''|armor|This is the being's armor. The default is 0.
|'''integer'''|danger|This is a [[Monster Generation|monster generation]] parameter.
|'''integer'''|weight|This is a [[Monster Generation|monster generation]] parameter.
|'''integer'''|minLev|This is a [[Monster Generation|monster generation]] parameter.
|'''integer'''|maxLev|This is a [[Monster Generation|monster generation]] parameter. The default is 200.
|'''integer'''|HP|This is the being's hpmax and starting hp. The default is 10.
|'''integer'''|bulk|This parameter is unused. The default is 100.
|'''integer'''|group|Monsters from different groups will fight each other if they use the default AI. Oddly, the default is "weapon-other" which, as a string, translates to 0. The player is in group 1.
|'''integer'''|attackchance|This is the being's attackchance The default is 75.
|'''integer'''|toHitMelee|This is the being's toHitMelee. The default is 0.
|[[Modding:Constants#Being Flags|Being Flag]] '''list'''|flags|The flags in this list will be included in the being's flag set. Upon instantiation, a flagSet property is added to the prototype will include these flags (and possibly some automatic flags) in set format. The default is an empty list.
|'''string'''|sound_id|If included and the being doesn't have sound bindings configured, then it will look for sound bindings under its sound_id.
|[[Modding:AI|AI ID]]|ai_type|This determines the being's AI. By default, the old pascal AI is used. (The pascal AI doesn't have an id.)
|'''integer'''|vision|This is the being's vision. The default is 9. (The player also has vision 9 by default.)
|'''integer'''|res_bullet|This is the being's res_bullet. The default is 0.
|'''integer'''|res_melee|This is the being's res_melee. The default is 0.
|'''integer'''|res_shrapnel|This is the being's res_shrapnel. The default is 0.
|'''integer'''|res_acid|This is the being's res_acid. The default is 0.
|'''integer'''|res_fire|This is the being's res_fire. The default is 0.
|'''integer'''|res_plasma|This is the being's res_plasma. The default is 0.
|'''string'''|desc|This is the description of the being displayed in the more information view.
|'''string'''|kill_desc|If included, this being will have a special kill description in the mortem.
|'''string'''|kill_desc_melee|As kill_desc, but for melee kills.
|}}
|}
=== Flags ===
==== Being Flags ====
{{drltable|Being Flags|2|{{Table2Col
|es=background: #333;
|c1=font-family:monospace; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|BF_INV|Stops the being from taking any damage. (Directly setting the being's HP can circumvent this. Does not work well with the being's HP set to zero.)
|BF_BERSERK|Gives the damage reduction and melee damage bonus of [[Effects#Berserk|berserk]]. (The speed bonus is not included.)
|BF_ENVIROSAFE|Beings with this flag are immune to damage from acid and lava tiles. (New hazardous tiles will have to check for this flag to respect it.)
|BF_BACKPACK|Gives the ammo-stacking benefits of the [[Backpack]] powerup.
|BF_POWERBONUS|Extends the duration of powerups as the [[Marine]] class bonus. New powerups will have to check for this flag (or use the provided helper function) to respect it.
|BF_STAIRSENSE|For the player, reveals the stairs tile(s) as the [[Scout]] class bonus.
|BF_INSTAUSE|Allows consumable items to be used in 0.1s instead of the usual 1.0s, as the [[Technician]] class bonus.
|BF_MAPEXPERT|Makes computer maps work like tracking maps, as the [[Technician]] class bonus.
|BF_MODEXPERT|Allows the being to mod unique items.
|BF_QUICKSWAP|Gives the benefits of the Juggler trait.
|BF_BERSERKER|Gives the benefits of the [[Traits#Berserker|Berserker]] trait.
|BF_DUALGUN|Gives the benefits of the dualgunner trait.
|BF_MASTERDODGE|Gives the benefits of the [[Traits#Dodgemaster|Dodgemaster]] trait.
|BF_SHOTTYMAN|Gives the benefits of the [[Traits#Shottyman|Shottyman]] trait.
|BF_POWERSENSE|For the player, shows the locations of all powerups (as the first level of the [[Traits#Intuition|Intuition]] trait).
|BF_BEINGSENSE|For the player, shows the locations of enemies (as the second level of the Intuition trait).
|BF_LEVERSENSE1|For the player, gives partial information about levers (as the first level of the Intuition trait).
|BF_LEVERSENSE2|For the player, shows the exact effect of levers (as the second level of the Intuition trait).
|BF_VAMPYRE|Gives the benefits of the [[Traits#Vampyre|Vampyre]] trait.
|BF_BULLETDANCE|Gives the benefits of the [[Traits#Bullet Dance|Bullet Dance]] trait.
|BF_ARMYDEAD|Gives the benefits of the [[Traits#Army of the Dead|Army of the Dead]] trait.
|BF_AMMOCHAIN|Gives the benefits of the [[Traits#Ammochain|Ammochain]] trait.
|BF_MEDPLUS|Allows med-packs to heal beyond 100% health (part of the [[Survivalist]] trait).
|BF_HARDY|Allows protection to reduce damage all the way to zero (part of the [[Survivalist]] trait).
|BF_CLEAVE|Gives the benefits of the [[Traits#Blademaster|Blademaster]] trait.
|BF_GUNKATA|Gives the benefits of the [[Traits#Gun Kata|Gun Kata]] trait.
|BF_SHOTTYHEAD|Gives the benefits of the [[Traits#Shottyhead|Shottyhead]] trait.
|BF_NORUNPENALTY|Gives the benefits of the [[Traits#Running Man|Running Man]] trait.
|BF_DUALBLADE|If both weapons in the being's equipment slots have IF_BLADED, this flag allows both weapons to attack in the same turn, each at half the attack time (part of the [[Traits#Malicious Blades|Malicious Blades]] trait).
|BF_BLADEDEFEND|If the weapon in the being's prepared slot has IF_BLADED, this flag grants the being with resistances as [[Traits#Malicious Blades|Malicious Blades]].
|BF_PISTOLMAX|Gives the benefits of the [[Sharpshooter]] trait.
|BF_FIREANGEL|Gives the benefits of the [[Traits#Fireangel|Fireangel]] trait.
|BF_ENTRENCHMENT|Gives the benefits of the [[Traits#Entrenchment|Entrenchment]] trait.
|BF_SCAVENGER|Gives the benefits of the [[Scavenger]] trait (useless on anything other than the player).
|BF_IMPATIENT|This flag causes packs to be automatically used when picked up as [[Angel of Impatience]].
|BF_DARKNESS|For the player, stops exploration from being recorded as in [[Angel of Darkness]].
|BF_MAXDAMAGE|Beings with this flag always roll maximum damage as in [[Angel of Max Carnage]].
|BF_NOHEAL|This is a marker flag that stops healing effects from working as in [[Angel of Masochism]]. New sources of healing will have to check for this flag in order to respect it.
|BF_SESSILE|Beings with this flag cannot move.
|BF_NOMELEE|This flag stops the being from doing any type of melee attack.
|BF_REGENERATE|Beings with this flag regenerate one health per second if they have less than 20 health remaining.
|BF_SELFIMMUNE|Makes the being immune to its own attacks.
|BF_KNOCKIMMUNE|Makes the being immune to [[knockback]].
|BF_UNIQUENAME|This flag makes the game treat the being's name as a proper noun.
|BF_ENTERBOSS1|This is a flag for the player that helps determine which victory message to use in the mortem.
|BF_KILLBOSS1|This is a flag for the player that helps determine which victory message to use in the mortem.
|BF_ENTERBOSS2|This is a flag for the player that helps determine which victory message to use in the mortem.
|BF_KILLBOSS2|This is a flag for the player that helps determine which victory message to use in the mortem.
|BF_CHARGE|This is a flag for the AI. Beings with this flag are willing to walk through hazardous cells to reach the player. (This applies to the default AI, and the direct_seek method.)
|BF_HUNTING|This is a flag for the default AI. Beings with this flag will search out the player even if he is not in their line of sight.
|BF_OPENDOORS|This is a flag for the default AI. Beings with this flag will open doors.
|BF_NODROP|Beings with this flag will not drop their inventory or equipment when they die.
|BF_NOEXP|Beings with this flag will not award experience to the player.
|BF_BOSS|Killing this monster will cause the same message as killing the final boss as well as its death explosion and ending the game.
|BF_JC||When used with BF_BOSS, changes the explosion to blue and changes the message to indicate that JC was killed instead of the cyberdemon.
|}}
}}
== Engine Hooks ==
Specifying one or more of these hooks in the prototype will allow for greater customization.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="2" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Being Hooks'''
{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|'''void'''|[[#being_OnCreate|OnCreate]]([[Modding:Being|Being]] self)
|'''void'''|[[#being_OnAction|OnAction]]([[Modding:Being|Being]] self)
|'''void'''|[[#being_OnDie|OnDie]]([[Modding:Being|Being]] self, '''boolean''' overkill)
|}}
|}

{{Anchor|being_OnCreate}}
;OnCreate([[Modding:Being|Being]] self)
:This is called when the being is created.
----
{{Anchor|being_OnAction}}
;OnAction([[Modding:Being|Being]] self)
:This is called at the beginning of each of the being's turns. (Note that turns are only differentiated if time elapses in between.)
----
{{Anchor|being_OnDie}}
;OnDie([[Modding:Being|Being]] self, '''boolean''' overkill)
:This is called when the being dies. ''overkill'' is true if the being was gibbed.

== Properties ==
Beings also have all the [[Modding:Thing|Thing]] properties in addition to those listed below. For beings, the resistance fields are inherent resistances that apply to all attacks.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|Being
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''Byte'''|attackchance|This is how likely (in percent) a monster is to use a ranged attack on its turn. The exact interpretation may depend on the AI. This property is read-only.
|'''Integer'''|hp|This is the being's current [[health]].
|'''Word'''|hpmax|This is the being's maximum health.
|'''Byte'''|vision|This is the being's vision radius. (It is up to the AI to respect this radius.)
|'''LongInt'''|scount|This is the being's speed count or energy. It counts up by the being's speed every 0.1s, and when it reaches 5000, the being gets to act. For details, see [[Time#Fractional Time|here]].
|'''ShortInt'''|tohit|This [[accuracy]] modifier is applied to all of the being's attacks.
|'''ShortInt'''|todam|This damage modifier is applied to all the being's melee attacks.
|'''ShortInt'''|todamall|This damage modifier is applied to all the being's attacks.
|'''ShortInt'''|tohitmelee|This accuracy modifier is applied to the being's melee attacks.
|'''Byte'''|speed|This is the rate at which the being's scount increases. It affects the speed of all actions.
|'''Byte'''|armor|This is the being's natural armor. It appears as [[protection]] against all attacks.
|'''Word'''|expvalue|This is the amount of [[experience]] that is awarded to the player when the being dies.
|'''ShortInt'''|techbonus|This usually corresponds to [[Whizkid]] levels; it affects the number of mods that can be applied and the level of assemblies that can be constructed.
|'''ShortInt'''|pistolbonus|This usually corresponds to [[Son of a Gun]] levels; it affects pistol firing time and damage.
|'''ShortInt'''|rapidbonus|This usually corresponds to [[Triggerhappy]] levels; it affects the number of shots fired by rapid-fire weapons.
|'''ShortInt'''|bodybonus|This is the property used to implement [[Badass]]. Each point reduces [[knockback]] by one, and anything above zero stops health decay.
|'''Byte'''|reloadtime|This is the percentage of normal reload time that the being takes to reload. (It is used to implement [[Reloader]].)
|'''Byte'''|firetime|This is the percentage of normal fire time that the being takes to fire. (It is used to implement [[Finesse]].)
|'''Byte'''|movetime|This is the percentage of normal movement time that the being takes to move. For the player, anything less than 100 applies a corresponding dodge bonus. (This is used to implement [[Hellrunner]].)
|'''Word'''|soundact|This is the being's .act sound.
|'''Word'''|soundhit|This is the being's .hit sound.
|'''Word'''|sounddie|This is the being's .die sound.
|'''Word'''|soundattack|This is the being's .attack sound.
|'''Word'''|soundmelee|This is the being's .melee sound.
|'''Word'''|soundhoof|This is the being's .hoof sound.
|[[Modding:Being|Being Prototype]]|proto|This is the being's prototype.
|}}
|}

== API ==
The [[Modding:Thing#API|Thing API]] can also be used with beings.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="2" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|Being Interface
{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|[[Modding:Being|Being]]|being.[[#being_new|new]]([[Modding:Being|Being ID]] id)
|'''void'''|[[Modding:Being|Being]]:[[#being_destroy|destroy]]('''boolean''' silent)
|'''void'''|[[Modding:Being|Being]]:[[#being_kill|kill]]('''boolean''' overkill)
|'''void'''|[[Modding:Being|Being]]:[[#being_ressurect|ressurect]]('''integer''' rrange)
|'''void'''|[[Modding:Being|Being]]:[[#being_apply_damage|apply_damage]]('''integer''' damage, [[Modding:Constants#BodyTarget|BodyTarget]] target, [[Modding:Constants#DamageType|DamageType]] damageType)
|'''string'''|[[Modding:Being|Being]]:[[#being_get_name|get_name]]('''boolean''' known, '''boolean''' capitalized)
|[[Modding:Item|Item]]|[[Modding:Being|Being]]:[[#being_get_inv_item|get_inv_item]]('''integer''' slot)
|'''void'''|[[Modding:Being|Being]]:[[#being_set_inv_item|set_inv_item]]('''integer''' slot, [[Modding:Item|Item]] item)
|[[Modding:Item|Item]]|[[Modding:Being|Being]]:[[#being_get_eq_item|get_eq_item]]([[Modding:Constants#Equip Slots|Equip Slot]] slot)
|'''void'''|[[Modding:Being|Being]]:[[#being_set_eq_item|set_eq_item]]([[Modding:Constants#Equip Slots|Equip Slot]] slot, [[Modding:Item|Item]] item)
|'''void'''|[[Modding:Being|Being]]:[[#being_play_sound|play_sound]]('''Sound ID''' sound)
|'''integer'''|[[Modding:Being|Being]]:[[#being_get_total_resistance|get_total_resistance]]([[Modding:Constants#Resistance|Resistance]] resistance, [[Modding:Constants#BodyTarget|BodyTarget]] target)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_use|use]]('''integer''' slot)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_wear|wear]]('''integer''' slot)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_pickup|pickup]]([[Modding:Coord|Coord]] pos)
|'''void'''|[[Modding:Being|Being]]:[[#being_attack|attack]]([[Modding:Coord|Coord]] or [[Modding:Being|Being]] target)
|'''void'''|[[Modding:Being|Being]]:[[#being_fire|fire]]([[Modding:Coord|Coord]] target, [[Modding:Item|Item]] weapon)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_reload|reload]]()
|'''integer'''|[[Modding:Being|Being]]:[[#being_direct_seek|direct_seek]]([[Modding:Coord|Coord]] target)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_path_find|path_find]]([[Modding:Coord|Coord]] target, '''integer''' cutoff, '''integer''' maximum)
|'''integer'''|[[Modding:Being|Being]]:[[#being_path_next|path_next]]()
|[[Modding:Coord|Coord]]|[[Modding:Being|Being]]:[[#being_flock_target|flock_target]]('''integer''' range, '''integer''' mind, '''integer''' maxd)
|'''void'''|[[Modding:Being|Being]]:[[#being_msg|msg]]('''string''' msg_player, '''string''' msg_being)
|[[Modding:Item|Item]]|[[Modding:Being|Being]]:[[#being_select_slot_by_letter|select_slot_by_letter]]('''string''' letter)
|'''void'''|[[Modding:Being|Being]]:[[#being_phase|phase]]([[Modding:Cell|Cell ID]] cell)
|'''void'''|[[Modding:Being|Being]]:[[#being_spawn|spawn]]([[Modding:Being|Being ID]] being)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_is_visible|is_visible]]()
|'''boolean'''|[[Modding:Being|Being]]:[[#being_is_player|is_player]]()
|'''integer'''|[[Modding:Being|Being]]:[[#being_set_items|set_items]]([[Modding:ItemSet|ItemSet]] set)
|'''void'''|[[Modding:Being|Being]]:[[#being_nuke|nuke]]('''integer''' time)
|[[Modding:Item|Item]], '''boolean'''|[[Modding:Being|Being]]:[[#being_pick_mod_item|pick_mod_item]]('''string''' modletter, '''integer''' techbonus)
|}}
|}

{{Anchor|being_new}}
;being.new([[Modding:Being|Being ID]] id) → [[Modding:Being|Being]]
:This creates a newly allocated being of the appropriate type. The being won't exist on the map until it is placed by e.g. Level.drop_being.
----
{{Anchor|being_destroy}}
;[[Modding:Being|Being]]:destroy('''boolean''' silent)
:Deallocates the memory associated with the being and removes it from the level (if applicable). The normal results of killing a being (e.g. leaving a corpse) are ignored. The ''silent'' parameter is optional. If true, applicable OnKill and OnKillAll hooks and events will also be ignored.
----
{{Anchor|being_kill}}
;[[Modding:Being|Being]]:kill('''boolean''' overkill)
:Kills the being. If the optional ''overkill'' parameter is true, then the being will be gibbed.
----
{{Anchor|being_ressurect}}
;[[Modding:Being|Being]]:ressurect('''integer''' rrange)
:Resurrects a single corpse that is found within a square of side-length 2 × ''rrange'' + 1, centered around the being. Nearer corpses are preferred. The corpse must not have another being standing on it and must be within sight of the being (as determined by the enemy line-of-sight algorithm). The resurrected being (if any) will have BF_NOEXP set. Messages are included.
----
{{Anchor|being_apply_damage}}
;[[Modding:Being|Being]]:apply_damage('''integer''' damage, [[Modding:Constants#BodyTarget|BodyTarget]] target, [[Modding:Constants#DamageType|DamageType]] damageType)
:Deals damage to the being using the given body target and damage type. (The default damage type is bullet damage.)
----
{{Anchor|being_get_name}}
;[[Modding:Being|Being]]:get_name('''boolean''' known, '''boolean''' capitalized) → '''string'''
:Returns the name of the being. If ''known'' is true, "the" is added, otherwise "a" or "an" is added. If BF_UNIQUENAME is set for the being, then no article is used in either case. If ''capitalized'' is true, then the first letter will be capitalized.
----
{{Anchor|being_get_inv_item}}
;[[Modding:Being|Being]]:get_inv_item('''integer''' slot) → [[Modding:Item|Item]]
;[[Modding:Being|Being]].inv['''integer''' slot] → [[Modding:Item|Item]]
:Returns the item in the given slot in the being's inventory. If the slot is empty, nil is returned instead.
----
{{Anchor|being_set_inv_item}}
;[[Modding:Being|Being]]:set_inv_item('''integer''' slot, [[Modding:Item|Item]] item)
;[[Modding:Being|Being]].inv['''integer''' slot] = [[Modding:Item|Item]] item
:Sets the given slot in the being's inventory to the given item. If the slot wasn't empty before, the previous constents are lost.
----
{{Anchor|being_get_eq_item}}
;[[Modding:Being|Being]]:get_eq_item([[Modding:Constants#Equip Slots|Equip Slot]] slot) → [[Modding:Item|Item]]
;[[Modding:Being|Being]].eq[[[Modding:Constants#Equip Slots|Equip Slot]] slot] → [[Modding:Item|Item]]
:Returns the item in the given equipment slot of the being. If the slot is empty, nil is returned instead. There are additional shorthands for each equipment slot: the ''eq'' table has .weapon, .prepared, .armor, and .boots fields.
----
{{Anchor|being_set_eq_item}}
;[[Modding:Being|Being]]:set_eq_item([[Modding:Constants#Equip Slots|Equip Slot]] slot, [[Modding:Item|Item]] item)
;[[Modding:Being|Being]].eq[[[Modding:Constants#Equip Slots|Equip Slot]] slot] = [[Modding:Item|Item]] item
:Sets the being's equipment slot to the given item. Any item that was previously in that slot is lost. There are additional shorthands for each equipment slot: the ''eq'' table has .weapon, .prepared, .armor, and .boots fields.
----
{{Anchor|being_play_sound}}
;[[Modding:Being|Being]]:play_sound('''Sound ID''' sound)
:Plays the given sound as if it came from the being's position.
----
{{Anchor|being_get_total_resistance}}
;[[Modding:Being|Being]]:get_total_resistance([[Modding:Constants#Resistance|Resistance]] resistance, [[Modding:Constants#BodyTarget|BodyTarget]] target) → '''integer'''
:Calculates the being's effective resistance against attacks of the given target (default is body). This accounts for inherent resists as well as equipment bonuses.
----
{{Anchor|being_use}}
;[[Modding:Being|Being]]:use('''integer''' slot) → '''boolean'''
;[[Modding:Being|Being]]:use([[Modding:Item|Item]] item) → '''boolean'''
:This makes the being use the given consumable item from its inventory. The function always returns false. (Bug: it is supposed to return true on success.)
----
{{Anchor|being_wear}}
;[[Modding:Being|Being]]:wear('''integer''' slot) → '''boolean'''
;[[Modding:Being|Being]]:wear([[Modding:Item|Item]] item) → '''boolean'''
:This makes the being wear the given eqipment from its inventory. Returns true on success and false on failure.
----
{{Anchor|being_pickup}}
;[[Modding:Being|Being]]:pickup([[Modding:Coord|Coord]] pos) → '''boolean'''
:This makes the being pick up the item at the given position. ''pos'' is optional; it defaults to the being's position. Returns true on success and false on failure.
----
{{Anchor|being_attack}}
;[[Modding:Being|Being]]:attack([[Modding:Coord|Coord]] or [[Modding:Being|Being]] target)
:This makes the being do a standard melee attack against the targeted being or coord.
----
{{Anchor|being_fire}}
;[[Modding:Being|Being]]:fire([[Modding:Coord|Coord]] target, [[Modding:Item|Item]] weapon)
:This makes the being fire at ''target'' with ''weapon''.
----
{{Anchor|being_reload}}
;[[Modding:Being|Being]]:reload() → '''boolean'''
:This makes the being reload its currently equipped weapon. The return value is true if there being had at least some of the appropriate ammo to attempt reloading with.
----
{{Anchor|being_direct_seek}}
;[[Modding:Being|Being]]:direct_seek([[Modding:Coord|Coord]] target) → '''integer'''
:This makes the being take a step towards the target. The being will always try to travel in a direct path. The return value is either 0, 1, 2, or 3. 0 indicates success, 1 indicates that a wall blocked the move, 2 indicates that a door blocked the move, and 3 indicates that a being blocked the move.
----
{{Anchor|being_path_find}}
;[[Modding:Being|Being]]:path_find([[Modding:Coord|Coord]] target, '''integer''' cutoff, '''integer''' maximum) → '''boolean'''
:This attempts to calculate a path between the being and ''target''. The ''cutoff'' and ''maximum'' parameters are somewhat technical, but basically they indicate how much time should be spend searching for a path. DoomRL uses 40, 200 for bosses and 10, 40 for normal enemies. The path will be remembered by the being, and can be followed using path_next. Modders should keep in mind that path-finding is a somewhat expensive operation, especially for large ''cutoff'' and ''maximum''. The return value indicates whether a path was found. Even if no path was found, a path will be loaded that will try to take the being closer to the target (although this path may be empty). This uses the AStar searching algorithm using Euclidean distance as a heuristic. The search is aborted if ''maximum'' nodes are expanded without finding the target or it ''cutoff'' nodes are expanded without getting closer to the target. When aborted, a path is created to the closest expanded node to the target in terms of the heuristic.
----
{{Anchor|being_path_next}}
;[[Modding:Being|Being]]:path_next() → '''integer'''
:This causes the being to take a step along the path last calculated by path_find. The return value follows the pattern of direct_seek.
----
{{Anchor|being_flock_target}}
;[[Modding:Being|Being]]:flock_target('''integer''' range, '''integer''' mind, '''integer''' maxd) → [[Modding:Coord|Coord]]
:This looks for the closest being of the same type to the being (within a square ''range''). If the being is farther than ''maxd'' away, then its position is returned. If it is closer than ''mind'', then a position opposite from the closest with respect to the being is returned. Otherwise (or if there is no nearby being of the same type), a random coord from the scanning area is returned.
----
{{Anchor|being_msg}}
;[[Modding:Being|Being]]:msg('''string''' msg_player, '''string''' msg_being)
:If the being is the player, then ''msg_player'' is displayed. If the being is not the player, but visible to the player, the ''msg_being'' is displayed. If either message is nil it is ignored.
----
{{Anchor|being_select_slot_by_letter}}
;[[Modding:Being|Being]]:select_slot_by_letter('''string''' letter) → [[Modding:Item|Item]]
:Returns the one of the being's equipment where "a" is for armor, "b" is for boots, "w" is for weapon, and "p" is for the prepared slot. If the slot is empty, nil is returned.
----
{{Anchor|being_phase}}
;[[Modding:Being|Being]]:phase([[Modding:Cell|Cell ID]] cell)
:If ''cell'' is omitted, then the being is displaced randomly as if it used a [[phase device]] (without the flashy interface stuff). If the cell is included, the being is displaced to a random cell of the given cell id. If the chosen cell is occupied, a nearby cell is used. If no such cell exists, a random cell is chosen.
----
{{Anchor|being_spawn}}
;[[Modding:Being|Being]]:spawn([[Modding:Being|Being ID]] being)
;[[Modding:Being|Being]]:spawn([[Modding:Being|Being]] being)
:Drops a new being of the appropriate type (or the given being) nearby. The dropped being is set with the BF_NOEXP flag.
----
{{Anchor|being_is_visible}}
;[[Modding:Being|Being]]:is_visible() → '''boolean'''
:Determines if the player can see the being.
----
{{Anchor|being_is_player}}
;[[Modding:Being|Being]]:is_player() → '''boolean'''
:Determines if the being is the player.
----
{{Anchor|being_set_items}}
;[[Modding:Being|Being]]:set_items([[Modding:ItemSet|ItemSet]] set) → '''integer'''
:Counts the number of the being's equipped items that belong to the given set.
----
{{Anchor|being_nuke}}
;[[Modding:Being|Being]]:nuke('''integer''' time)
:Sets the nuke timer to ''time'' and changes the cell under the being to the nuke cell. By default, ''time'' is 1. (Setting the nuke time to 0 will disable the countdown.)
----
{{Anchor|being_pick_mod_item}}
;[[Modding:Being|Being]]:pick_mod_item('''string''' modletter, '''integer''' techbonus) → [[Modding:Item|Item]], '''boolean'''
:This only works for the player. This gives the player the item select menu used by mods, and calculates whether the mod is legal (using the given ''techbonus''). This includes assembly checking. The first return value is the item on success. The second return value is true on success and false on failure. (''modletter'' should be the length one string corresponding to the mod type.)

Modding:being (0.9.9.7)

2012-01-31T20:57:26Z

Game Hunter: added and updated being flags

If it bleeds, it leads. Beings inherit from the [[Modding:Thing|Thing]] base class which handles some basic properties in common with items. In addition the [[Modding:Player|Player]] inherits this class, so anything you can do to creatures can be done to the player as well.

== Prototype ==

New beings are created from being prototypes. Think of a being prototype as a recipe for creating new beings. There can be multiple former humans, but they all came from the same prototype. Prototypes are declared by passing a table with the desired properties to the Beings function. [[#Engine Hooks|Engine hooks]] may also be included in the prototype. Mostly, the prototype's properties just describe beings' initial properties (occasionally with different names). Beings' properties can also mostly be changed after they are instantiated. Required fields are underlined. Sometimes required fields can safely be omitted, but this will generate a message in the log file. All being prototypes are stored in a global table called beings. This table can be indexed by id or nid.
{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Being Prototype'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''string'''|name|This is the being's name.
|'''string'''|name_plural|This is the being's name_plural. By default, this is the name with an "s" appended.
|'''string'''|ascii|This is the being's picture. It should be a single character string.
|'''string'''|id|This is the being's sid. It must be distinct from other string ids. (The numeric id is automatically assigned to a field called nid.) Only the first 20 characters will be used. The default is the first word of the name in all lowercase.
|'''integer''' '''list'''|overlay|This field is only used in the graphical version. It describes a color transformation to be applied to the being's sprite. This will create overlay_red, overlay_green, overlay_blue, and overlay_alpha fields in the being prototype.
|'''integer'''|XP|This is the being's expvalue. By default, it is <font-family: monospace>3xD2+20, where D is the being's danger (see below).
|[[Modding:Cell|Cell ID]]|corpse|The determines the corpse left by the being. If the value is true, a new corpse cell will automatically be created. Otherwise this field is interpretted as a cell id. After a being is declared, this field will have been translated to a number. The default is true.
|[[Modding:Item|Item Prototype]]|weapon|If this field is included, a new item will be declared and automatically equipped for beings generated from this prototype. The item prototype will automatically be a natural ranged weapon, have an id assigned, have zero weight, have no sprite, and have the IF_NODROP and IF_NOAMMO flags.
|'''integer'''|sprite|This is the being's sprite. (Use 0 for no sprite.)
|[[Modding:Constants#Colors|Color]]|color|This is the being's color.
|'''integer'''|toDam|This is the being's toDam. (This bonus only applies to melee attacks.) The default is 0.
|'''integer'''|toHit|This is the being's toHit. The default is 0.
|'''integer'''|speed|This is the being's speed. (Remember, the maximum allowed speed is 255.) The default is 100.
|'''integer'''|armor|This is the being's armor. The default is 0.
|'''integer'''|danger|This is a [[Monster Generation|monster generation]] parameter.
|'''integer'''|weight|This is a [[Monster Generation|monster generation]] parameter.
|'''integer'''|minLev|This is a [[Monster Generation|monster generation]] parameter.
|'''integer'''|maxLev|This is a [[Monster Generation|monster generation]] parameter. The default is 200.
|'''integer'''|HP|This is the being's hpmax and starting hp. The default is 10.
|'''integer'''|bulk|This parameter is unused. The default is 100.
|'''integer'''|group|Monsters from different groups will fight each other if they use the default AI. Oddly, the default is "weapon-other" which, as a string, translates to 0. The player is in group 1.
|'''integer'''|attackchance|This is the being's attackchance The default is 75.
|'''integer'''|toHitMelee|This is the being's toHitMelee. The default is 0.
|[[Modding:Constants#Being Flags|Being Flag]] '''list'''|flags|The flags in this list will be included in the being's flag set. Upon instantiation, a flagSet property is added to the prototype will include these flags (and possibly some automatic flags) in set format. The default is an empty list.
|'''string'''|sound_id|If included and the being doesn't have sound bindings configured, then it will look for sound bindings under its sound_id.
|[[Modding:AI|AI ID]]|ai_type|This determines the being's AI. By default, the old pascal AI is used. (The pascal AI doesn't have an id.)
|'''integer'''|vision|This is the being's vision. The default is 9. (The player also has vision 9 by default.)
|'''integer'''|res_bullet|This is the being's res_bullet. The default is 0.
|'''integer'''|res_melee|This is the being's res_melee. The default is 0.
|'''integer'''|res_shrapnel|This is the being's res_shrapnel. The default is 0.
|'''integer'''|res_acid|This is the being's res_acid. The default is 0.
|'''integer'''|res_fire|This is the being's res_fire. The default is 0.
|'''integer'''|res_plasma|This is the being's res_plasma. The default is 0.
|'''string'''|desc|This is the description of the being displayed in the more information view.
|'''string'''|kill_desc|If included, this being will have a special kill description in the mortem.
|'''string'''|kill_desc_melee|As kill_desc, but for melee kills.
|}}
|}
=== Flags ===
==== Being Flags ====
{{drltable|Being Flags|2|{{Table2Col
|es=background: #333;
|c1=font-family:monospace; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|BF_INV|Stops the being from taking any damage. (Directly setting the being's HP can circumvent this. Does not work well with the being's HP set to zero.)
|BF_BERSERK|Gives the damage reduction and melee damage bonus of [[Effects#Berserk|berserk]]. (The speed bonus is not included.)
|BF_ENVIROSAFE|Beings with this flag are immune to damage from acid and lava tiles. (New hazardous tiles will have to check for this flag to respect it.)
|BF_BACKPACK|Gives the ammo-stacking benefits of the [[Backpack]] powerup.
|BF_POWERBONUS|Extends the duration of powerups as the [[Marine]] class bonus. New powerups will have to check for this flag (or use the provided helper function) to respect it.
|BF_STAIRSENSE|For the player, reveals the stairs tile(s) as the [[Scout]] class bonus.
|BF_INSTAUSE|Allows consumable items to be used in 0.1s instead of the usual 1.0s, as the [[Technician]] class bonus.
|BF_MAPEXPERT|Makes computer maps work like tracking maps, as the [[Technician]] class bonus.
|BF_QUICKSWAP|Gives the benefits of the Juggler trait.
|BF_BERSERKER|Gives the benefits of the [[Traits#Berserker|Berserker]] trait.
|BF_DUALGUN|Gives the benefits of the dualgunner trait.
|BF_MASTERDODGE|Gives the benefits of the [[Traits#Dodgemaster|Dodgemaster]] trait.
|BF_SHOTTYMAN|Gives the benefits of the [[Traits#Shottyman|Shottyman]] trait.
|BF_POWERSENSE|For the player, shows the locations of all powerups (as the first level of the [[Traits#Intuition|Intuition]] trait).
|BF_BEINGSENSE|For the player, shows the locations of enemies (as the second level of the Intuition trait).
|BF_LEVERSENSE1|For the player, gives partial information about levers (as the first level of the Intuition trait).
|BF_LEVERSENSE2|For the player, shows the exact effect of levers (as the second level of the Intuition trait).
|BF_VAMPYRE|Gives the benefits of the [[Traits#Vampyre|Vampyre]] trait.
|BF_BULLETDANCE|Gives the benefits of the [[Traits#Bullet Dance|Bullet Dance]] trait.
|BF_ARMYDEAD|Gives the benefits of the [[Traits#Army of the Dead|Army of the Dead]] trait.
|BF_AMMOCHAIN|Gives the benefits of the [[Traits#Ammochain|Ammochain]] trait.
|BF_MEDPLUS|Allows med-packs to heal beyond 100% health (part of the [[Survivalist]] trait).
|BF_HARDY|Allows protection to reduce damage all the way to zero (part of the [[Survivalist]] trait).
|BF_CLEAVE|Gives the benefits of the [[Traits#Blademaster|Blademaster]] trait.
|BF_GUNKATA|Gives the benefits of the [[Traits#Gun Kata|Gun Kata]] trait.
|BF_SHOTTYHEAD|Gives the benefits of the [[Traits#Shottyhead|Shottyhead]] trait.
|BF_NORUNPENALTY|Gives the benefits of the [[Traits#Running Man|Running Man]] trait.
|BF_DUALBLADE|If both weapons in the being's equipment slots have IF_BLADED, this flag allows both weapons to attack in the same turn, each at half the attack time (part of the [[Traits#Malicious Blades|Malicious Blades]] trait).
|BF_BLADEDEFEND|If the weapon in the being's prepared slot has IF_BLADED, this flag grants the being with resistances as [[Traits#Malicious Blades|Malicious Blades]].
|BF_PISTOLMAX|Gives the benefits of the [[Sharpshooter]] trait.
|BF_FIREANGEL|Gives the benefits of the [[Traits#Fireangel|Fireangel]] trait.
|BF_ENTRENCHMENT|Gives the benefits of the [[Traits#Entrenchment|Entrenchment]] trait.
|BF_SCAVENGER|Gives the benefits of the [[Scavenger]] trait (useless on anything other than the player).
|BF_IMPATIENT|This flag causes packs to be automatically used when picked up as [[Angel of Impatience]].
|BF_DARKNESS|For the player, stops exploration from being recorded as in [[Angel of Darkness]].
|BF_MAXDAMAGE|Beings with this flag always roll maximum damage as in [[Angel of Max Carnage]].
|BF_NOHEAL|This is a marker flag that stops healing effects from working as in [[Angel of Masochism]]. New sources of healing will have to check for this flag in order to respect it.
|BF_SESSILE|Beings with this flag cannot move.
|BF_NOMELEE|This flag stops the being from doing any type of melee attack.
|BF_REGENERATE|Beings with this flag regenerate one health per second if they have less than 20 health remaining.
|BF_SELFIMMUNE|Makes the being immune to its own attacks.
|BF_KNOCKIMMUNE|Makes the being immune to [[knockback]].
|BF_UNIQUENAME|This flag makes the game treat the being's name as a proper noun.
|BF_MODEXPERT|Allows the being to mod assemblies exactly once.
|BF_ENTERBOSS1|This is a flag for the player that helps determine which victory message to use in the mortem.
|BF_KILLBOSS1|This is a flag for the player that helps determine which victory message to use in the mortem.
|BF_ENTERBOSS2|This is a flag for the player that helps determine which victory message to use in the mortem.
|BF_KILLBOSS2|This is a flag for the player that helps determine which victory message to use in the mortem.
|BF_CHARGE|This is a flag for the AI. Beings with this flag are willing to walk through hazardous cells to reach the player. (This applies to the default AI, and the direct_seek method.)
|BF_HUNTING|This is a flag for the default AI. Beings with this flag will search out the player even if he is not in their line of sight.
|BF_OPENDOORS|This is a flag for the default AI. Beings with this flag will open doors.
|BF_NODROP|Beings with this flag will not drop their inventory or equipment when they die.
|BF_NOEXP|Beings with this flag will not award experience to the player.
|BF_BOSS|Killing this monster will cause the same message as killing the final boss as well as its death explosion and ending the game.
|BF_JC||When used with BF_BOSS, changes the explosion to blue and changes the message to indicate that JC was killed instead of the cyberdemon.
|}}
}}
== Engine Hooks ==
Specifying one or more of these hooks in the prototype will allow for greater customization.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="2" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Being Hooks'''
{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|'''void'''|[[#being_OnCreate|OnCreate]]([[Modding:Being|Being]] self)
|'''void'''|[[#being_OnAction|OnAction]]([[Modding:Being|Being]] self)
|'''void'''|[[#being_OnDie|OnDie]]([[Modding:Being|Being]] self, '''boolean''' overkill)
|}}
|}

{{Anchor|being_OnCreate}}
;OnCreate([[Modding:Being|Being]] self)
:This is called when the being is created.
----
{{Anchor|being_OnAction}}
;OnAction([[Modding:Being|Being]] self)
:This is called at the beginning of each of the being's turns. (Note that turns are only differentiated if time elapses in between.)
----
{{Anchor|being_OnDie}}
;OnDie([[Modding:Being|Being]] self, '''boolean''' overkill)
:This is called when the being dies. ''overkill'' is true if the being was gibbed.

== Properties ==
Beings also have all the [[Modding:Thing|Thing]] properties in addition to those listed below. For beings, the resistance fields are inherent resistances that apply to all attacks.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|Being
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''Byte'''|attackchance|This is how likely (in percent) a monster is to use a ranged attack on its turn. The exact interpretation may depend on the AI. This property is read-only.
|'''Integer'''|hp|This is the being's current [[health]].
|'''Word'''|hpmax|This is the being's maximum health.
|'''Byte'''|vision|This is the being's vision radius. (It is up to the AI to respect this radius.)
|'''LongInt'''|scount|This is the being's speed count or energy. It counts up by the being's speed every 0.1s, and when it reaches 5000, the being gets to act. For details, see [[Time#Fractional Time|here]].
|'''ShortInt'''|tohit|This [[accuracy]] modifier is applied to all of the being's attacks.
|'''ShortInt'''|todam|This damage modifier is applied to all the being's melee attacks.
|'''ShortInt'''|todamall|This damage modifier is applied to all the being's attacks.
|'''ShortInt'''|tohitmelee|This accuracy modifier is applied to the being's melee attacks.
|'''Byte'''|speed|This is the rate at which the being's scount increases. It affects the speed of all actions.
|'''Byte'''|armor|This is the being's natural armor. It appears as [[protection]] against all attacks.
|'''Word'''|expvalue|This is the amount of [[experience]] that is awarded to the player when the being dies.
|'''ShortInt'''|techbonus|This usually corresponds to [[Whizkid]] levels; it affects the number of mods that can be applied and the level of assemblies that can be constructed.
|'''ShortInt'''|pistolbonus|This usually corresponds to [[Son of a Gun]] levels; it affects pistol firing time and damage.
|'''ShortInt'''|rapidbonus|This usually corresponds to [[Triggerhappy]] levels; it affects the number of shots fired by rapid-fire weapons.
|'''ShortInt'''|bodybonus|This is the property used to implement [[Badass]]. Each point reduces [[knockback]] by one, and anything above zero stops health decay.
|'''Byte'''|reloadtime|This is the percentage of normal reload time that the being takes to reload. (It is used to implement [[Reloader]].)
|'''Byte'''|firetime|This is the percentage of normal fire time that the being takes to fire. (It is used to implement [[Finesse]].)
|'''Byte'''|movetime|This is the percentage of normal movement time that the being takes to move. For the player, anything less than 100 applies a corresponding dodge bonus. (This is used to implement [[Hellrunner]].)
|'''Word'''|soundact|This is the being's .act sound.
|'''Word'''|soundhit|This is the being's .hit sound.
|'''Word'''|sounddie|This is the being's .die sound.
|'''Word'''|soundattack|This is the being's .attack sound.
|'''Word'''|soundmelee|This is the being's .melee sound.
|'''Word'''|soundhoof|This is the being's .hoof sound.
|[[Modding:Being|Being Prototype]]|proto|This is the being's prototype.
|}}
|}

== API ==
The [[Modding:Thing#API|Thing API]] can also be used with beings.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="2" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|Being Interface
{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|[[Modding:Being|Being]]|being.[[#being_new|new]]([[Modding:Being|Being ID]] id)
|'''void'''|[[Modding:Being|Being]]:[[#being_destroy|destroy]]('''boolean''' silent)
|'''void'''|[[Modding:Being|Being]]:[[#being_kill|kill]]('''boolean''' overkill)
|'''void'''|[[Modding:Being|Being]]:[[#being_ressurect|ressurect]]('''integer''' rrange)
|'''void'''|[[Modding:Being|Being]]:[[#being_apply_damage|apply_damage]]('''integer''' damage, [[Modding:Constants#BodyTarget|BodyTarget]] target, [[Modding:Constants#DamageType|DamageType]] damageType)
|'''string'''|[[Modding:Being|Being]]:[[#being_get_name|get_name]]('''boolean''' known, '''boolean''' capitalized)
|[[Modding:Item|Item]]|[[Modding:Being|Being]]:[[#being_get_inv_item|get_inv_item]]('''integer''' slot)
|'''void'''|[[Modding:Being|Being]]:[[#being_set_inv_item|set_inv_item]]('''integer''' slot, [[Modding:Item|Item]] item)
|[[Modding:Item|Item]]|[[Modding:Being|Being]]:[[#being_get_eq_item|get_eq_item]]([[Modding:Constants#Equip Slots|Equip Slot]] slot)
|'''void'''|[[Modding:Being|Being]]:[[#being_set_eq_item|set_eq_item]]([[Modding:Constants#Equip Slots|Equip Slot]] slot, [[Modding:Item|Item]] item)
|'''void'''|[[Modding:Being|Being]]:[[#being_play_sound|play_sound]]('''Sound ID''' sound)
|'''integer'''|[[Modding:Being|Being]]:[[#being_get_total_resistance|get_total_resistance]]([[Modding:Constants#Resistance|Resistance]] resistance, [[Modding:Constants#BodyTarget|BodyTarget]] target)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_use|use]]('''integer''' slot)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_wear|wear]]('''integer''' slot)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_pickup|pickup]]([[Modding:Coord|Coord]] pos)
|'''void'''|[[Modding:Being|Being]]:[[#being_attack|attack]]([[Modding:Coord|Coord]] or [[Modding:Being|Being]] target)
|'''void'''|[[Modding:Being|Being]]:[[#being_fire|fire]]([[Modding:Coord|Coord]] target, [[Modding:Item|Item]] weapon)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_reload|reload]]()
|'''integer'''|[[Modding:Being|Being]]:[[#being_direct_seek|direct_seek]]([[Modding:Coord|Coord]] target)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_path_find|path_find]]([[Modding:Coord|Coord]] target, '''integer''' cutoff, '''integer''' maximum)
|'''integer'''|[[Modding:Being|Being]]:[[#being_path_next|path_next]]()
|[[Modding:Coord|Coord]]|[[Modding:Being|Being]]:[[#being_flock_target|flock_target]]('''integer''' range, '''integer''' mind, '''integer''' maxd)
|'''void'''|[[Modding:Being|Being]]:[[#being_msg|msg]]('''string''' msg_player, '''string''' msg_being)
|[[Modding:Item|Item]]|[[Modding:Being|Being]]:[[#being_select_slot_by_letter|select_slot_by_letter]]('''string''' letter)
|'''void'''|[[Modding:Being|Being]]:[[#being_phase|phase]]([[Modding:Cell|Cell ID]] cell)
|'''void'''|[[Modding:Being|Being]]:[[#being_spawn|spawn]]([[Modding:Being|Being ID]] being)
|'''boolean'''|[[Modding:Being|Being]]:[[#being_is_visible|is_visible]]()
|'''boolean'''|[[Modding:Being|Being]]:[[#being_is_player|is_player]]()
|'''integer'''|[[Modding:Being|Being]]:[[#being_set_items|set_items]]([[Modding:ItemSet|ItemSet]] set)
|'''void'''|[[Modding:Being|Being]]:[[#being_nuke|nuke]]('''integer''' time)
|[[Modding:Item|Item]], '''boolean'''|[[Modding:Being|Being]]:[[#being_pick_mod_item|pick_mod_item]]('''string''' modletter, '''integer''' techbonus)
|}}
|}

{{Anchor|being_new}}
;being.new([[Modding:Being|Being ID]] id) → [[Modding:Being|Being]]
:This creates a newly allocated being of the appropriate type. The being won't exist on the map until it is placed by e.g. Level.drop_being.
----
{{Anchor|being_destroy}}
;[[Modding:Being|Being]]:destroy('''boolean''' silent)
:Deallocates the memory associated with the being and removes it from the level (if applicable). The normal results of killing a being (e.g. leaving a corpse) are ignored. The ''silent'' parameter is optional. If true, applicable OnKill and OnKillAll hooks and events will also be ignored.
----
{{Anchor|being_kill}}
;[[Modding:Being|Being]]:kill('''boolean''' overkill)
:Kills the being. If the optional ''overkill'' parameter is true, then the being will be gibbed.
----
{{Anchor|being_ressurect}}
;[[Modding:Being|Being]]:ressurect('''integer''' rrange)
:Resurrects a single corpse that is found within a square of side-length 2 × ''rrange'' + 1, centered around the being. Nearer corpses are preferred. The corpse must not have another being standing on it and must be within sight of the being (as determined by the enemy line-of-sight algorithm). The resurrected being (if any) will have BF_NOEXP set. Messages are included.
----
{{Anchor|being_apply_damage}}
;[[Modding:Being|Being]]:apply_damage('''integer''' damage, [[Modding:Constants#BodyTarget|BodyTarget]] target, [[Modding:Constants#DamageType|DamageType]] damageType)
:Deals damage to the being using the given body target and damage type. (The default damage type is bullet damage.)
----
{{Anchor|being_get_name}}
;[[Modding:Being|Being]]:get_name('''boolean''' known, '''boolean''' capitalized) → '''string'''
:Returns the name of the being. If ''known'' is true, "the" is added, otherwise "a" or "an" is added. If BF_UNIQUENAME is set for the being, then no article is used in either case. If ''capitalized'' is true, then the first letter will be capitalized.
----
{{Anchor|being_get_inv_item}}
;[[Modding:Being|Being]]:get_inv_item('''integer''' slot) → [[Modding:Item|Item]]
;[[Modding:Being|Being]].inv['''integer''' slot] → [[Modding:Item|Item]]
:Returns the item in the given slot in the being's inventory. If the slot is empty, nil is returned instead.
----
{{Anchor|being_set_inv_item}}
;[[Modding:Being|Being]]:set_inv_item('''integer''' slot, [[Modding:Item|Item]] item)
;[[Modding:Being|Being]].inv['''integer''' slot] = [[Modding:Item|Item]] item
:Sets the given slot in the being's inventory to the given item. If the slot wasn't empty before, the previous constents are lost.
----
{{Anchor|being_get_eq_item}}
;[[Modding:Being|Being]]:get_eq_item([[Modding:Constants#Equip Slots|Equip Slot]] slot) → [[Modding:Item|Item]]
;[[Modding:Being|Being]].eq[[[Modding:Constants#Equip Slots|Equip Slot]] slot] → [[Modding:Item|Item]]
:Returns the item in the given equipment slot of the being. If the slot is empty, nil is returned instead. There are additional shorthands for each equipment slot: the ''eq'' table has .weapon, .prepared, .armor, and .boots fields.
----
{{Anchor|being_set_eq_item}}
;[[Modding:Being|Being]]:set_eq_item([[Modding:Constants#Equip Slots|Equip Slot]] slot, [[Modding:Item|Item]] item)
;[[Modding:Being|Being]].eq[[[Modding:Constants#Equip Slots|Equip Slot]] slot] = [[Modding:Item|Item]] item
:Sets the being's equipment slot to the given item. Any item that was previously in that slot is lost. There are additional shorthands for each equipment slot: the ''eq'' table has .weapon, .prepared, .armor, and .boots fields.
----
{{Anchor|being_play_sound}}
;[[Modding:Being|Being]]:play_sound('''Sound ID''' sound)
:Plays the given sound as if it came from the being's position.
----
{{Anchor|being_get_total_resistance}}
;[[Modding:Being|Being]]:get_total_resistance([[Modding:Constants#Resistance|Resistance]] resistance, [[Modding:Constants#BodyTarget|BodyTarget]] target) → '''integer'''
:Calculates the being's effective resistance against attacks of the given target (default is body). This accounts for inherent resists as well as equipment bonuses.
----
{{Anchor|being_use}}
;[[Modding:Being|Being]]:use('''integer''' slot) → '''boolean'''
;[[Modding:Being|Being]]:use([[Modding:Item|Item]] item) → '''boolean'''
:This makes the being use the given consumable item from its inventory. The function always returns false. (Bug: it is supposed to return true on success.)
----
{{Anchor|being_wear}}
;[[Modding:Being|Being]]:wear('''integer''' slot) → '''boolean'''
;[[Modding:Being|Being]]:wear([[Modding:Item|Item]] item) → '''boolean'''
:This makes the being wear the given eqipment from its inventory. Returns true on success and false on failure.
----
{{Anchor|being_pickup}}
;[[Modding:Being|Being]]:pickup([[Modding:Coord|Coord]] pos) → '''boolean'''
:This makes the being pick up the item at the given position. ''pos'' is optional; it defaults to the being's position. Returns true on success and false on failure.
----
{{Anchor|being_attack}}
;[[Modding:Being|Being]]:attack([[Modding:Coord|Coord]] or [[Modding:Being|Being]] target)
:This makes the being do a standard melee attack against the targeted being or coord.
----
{{Anchor|being_fire}}
;[[Modding:Being|Being]]:fire([[Modding:Coord|Coord]] target, [[Modding:Item|Item]] weapon)
:This makes the being fire at ''target'' with ''weapon''.
----
{{Anchor|being_reload}}
;[[Modding:Being|Being]]:reload() → '''boolean'''
:This makes the being reload its currently equipped weapon. The return value is true if there being had at least some of the appropriate ammo to attempt reloading with.
----
{{Anchor|being_direct_seek}}
;[[Modding:Being|Being]]:direct_seek([[Modding:Coord|Coord]] target) → '''integer'''
:This makes the being take a step towards the target. The being will always try to travel in a direct path. The return value is either 0, 1, 2, or 3. 0 indicates success, 1 indicates that a wall blocked the move, 2 indicates that a door blocked the move, and 3 indicates that a being blocked the move.
----
{{Anchor|being_path_find}}
;[[Modding:Being|Being]]:path_find([[Modding:Coord|Coord]] target, '''integer''' cutoff, '''integer''' maximum) → '''boolean'''
:This attempts to calculate a path between the being and ''target''. The ''cutoff'' and ''maximum'' parameters are somewhat technical, but basically they indicate how much time should be spend searching for a path. DoomRL uses 40, 200 for bosses and 10, 40 for normal enemies. The path will be remembered by the being, and can be followed using path_next. Modders should keep in mind that path-finding is a somewhat expensive operation, especially for large ''cutoff'' and ''maximum''. The return value indicates whether a path was found. Even if no path was found, a path will be loaded that will try to take the being closer to the target (although this path may be empty). This uses the AStar searching algorithm using Euclidean distance as a heuristic. The search is aborted if ''maximum'' nodes are expanded without finding the target or it ''cutoff'' nodes are expanded without getting closer to the target. When aborted, a path is created to the closest expanded node to the target in terms of the heuristic.
----
{{Anchor|being_path_next}}
;[[Modding:Being|Being]]:path_next() → '''integer'''
:This causes the being to take a step along the path last calculated by path_find. The return value follows the pattern of direct_seek.
----
{{Anchor|being_flock_target}}
;[[Modding:Being|Being]]:flock_target('''integer''' range, '''integer''' mind, '''integer''' maxd) → [[Modding:Coord|Coord]]
:This looks for the closest being of the same type to the being (within a square ''range''). If the being is farther than ''maxd'' away, then its position is returned. If it is closer than ''mind'', then a position opposite from the closest with respect to the being is returned. Otherwise (or if there is no nearby being of the same type), a random coord from the scanning area is returned.
----
{{Anchor|being_msg}}
;[[Modding:Being|Being]]:msg('''string''' msg_player, '''string''' msg_being)
:If the being is the player, then ''msg_player'' is displayed. If the being is not the player, but visible to the player, the ''msg_being'' is displayed. If either message is nil it is ignored.
----
{{Anchor|being_select_slot_by_letter}}
;[[Modding:Being|Being]]:select_slot_by_letter('''string''' letter) → [[Modding:Item|Item]]
:Returns the one of the being's equipment where "a" is for armor, "b" is for boots, "w" is for weapon, and "p" is for the prepared slot. If the slot is empty, nil is returned.
----
{{Anchor|being_phase}}
;[[Modding:Being|Being]]:phase([[Modding:Cell|Cell ID]] cell)
:If ''cell'' is omitted, then the being is displaced randomly as if it used a [[phase device]] (without the flashy interface stuff). If the cell is included, the being is displaced to a random cell of the given cell id. If the chosen cell is occupied, a nearby cell is used. If no such cell exists, a random cell is chosen.
----
{{Anchor|being_spawn}}
;[[Modding:Being|Being]]:spawn([[Modding:Being|Being ID]] being)
;[[Modding:Being|Being]]:spawn([[Modding:Being|Being]] being)
:Drops a new being of the appropriate type (or the given being) nearby. The dropped being is set with the BF_NOEXP flag.
----
{{Anchor|being_is_visible}}
;[[Modding:Being|Being]]:is_visible() → '''boolean'''
:Determines if the player can see the being.
----
{{Anchor|being_is_player}}
;[[Modding:Being|Being]]:is_player() → '''boolean'''
:Determines if the being is the player.
----
{{Anchor|being_set_items}}
;[[Modding:Being|Being]]:set_items([[Modding:ItemSet|ItemSet]] set) → '''integer'''
:Counts the number of the being's equipped items that belong to the given set.
----
{{Anchor|being_nuke}}
;[[Modding:Being|Being]]:nuke('''integer''' time)
:Sets the nuke timer to ''time'' and changes the cell under the being to the nuke cell. By default, ''time'' is 1. (Setting the nuke time to 0 will disable the countdown.)
----
{{Anchor|being_pick_mod_item}}
;[[Modding:Being|Being]]:pick_mod_item('''string''' modletter, '''integer''' techbonus) → [[Modding:Item|Item]], '''boolean'''
:This only works for the player. This gives the player the item select menu used by mods, and calculates whether the mod is legal (using the given ''techbonus''). This includes assembly checking. The first return value is the item on success. The second return value is true on success and false on failure. (''modletter'' should be the length one string corresponding to the mod type.)

Modding:level blueprint (0.9.9.7)

2012-01-31T20:16:57Z

Game Hunter: moved and updated level flags

Level objects define the properties of fixed special levels. The level API, however, is a general purpose API for manipulating the level. This is used both for map generation (along with the [[Modding:Generator#API|generator API]]) and for changing the level on the fly. The Level variable also has some general properties that don't necessarily correspond to special levels in particular.

== Prototype ==
Levels prototypes are only used for special levels and scripted levels, not random levels. They are declared using the Levels function with the ID as the first argument, and a prototype table as the second argument. They are stored by ID in a global table called levels.
{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Level Prototype'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|string|ID|The unique identifier used by the engine for this level. Instead of being included in the table, this must be passed as the first argument to the Levels function.
|string|name|The name displayed in the HUD.
|string|welcome|Optional message displayed on level entry.
|integer|chance|Optional percent chance the level will appear. Defaults to 100.
|[[Modding:Functions$function_resolve_range|Range]]|level|Level range where the level may appear.
|string|entry|Optional mortem history message for level entry.
}}
|}
=== Flags ===
{{drltable|Level Flags|2|{{Table2Col
|es=background: #333;
|c1=font-family:monospace; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|LF_NOHOMING|Causes homing phase devices to act like normal phase devices.
|LF_UNIQUEITEM|Used by the level generation code to keep track of whether a unique item has dropped on the current level (in order to prevent multiple uniques from dropping on one level). This flag also causes a level feeling to occur indicating that a unique item is present.
|LF_BONUS|This flag is automatically set for so-called special levels like [[Halls of Carnage]]. (It is not set for those special levels like [[Hellgate]] that replace normal levels, only by those reached from red stairs.)
|LF_RESPAWN|Causes monsters to randomly respawn as when playing the game on Nightmare!
|LF_NORESPAWN|Prevents the Nightmare! respawn feature.
|LF_NUKED|This flag is automatically set when the level is nuked.
|LF_NONUKE|Causes the thermonuclear bomb to have no effect when it is used. It is not respected by other nuke effects.
|LF_ITEMSVISIBLE|Allows the player to see all items on the level (as with a [[Computer Map]]).
|LF_BEINGSVISIBLE|Allows the player to see all beings on the level (as with a [[Tracking Map]]).
|}}
}}
== Engine Hooks ==
{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="2" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Level Hooks'''
{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|void|[[#level_Create|Create]]()
|void|[[#level_OnTick|OnTick]]()
|void|[[#level_OnEnter|OnEnter]]()
|void|[[#level_OnExit|OnExit]]()
|void|[[#level_OnKill|OnKill]]()
|void|[[#level_OnKillAll|OnKillAll]]()
|boolean|[[#level_IsCompleted|IsCompleted]]()
}}
|}

{{Anchor|level_Create}}
;Create()
:This function should create the layout of the level. It also usually sets up the initial being and item locations. The player's initial location should be set here using Level.player.
----
{{Anchor|level_OnTick}}
;OnTick()
:This is called every 0.1s of game time. This will happen many times for each of the player's moves, so be careful about putting intense calculations here.
----
{{Anchor|level_OnEnter}}
;OnEnter()
:This is triggered just after the player enters the level.
----
{{Anchor|level_OnExit}}
;OnExit()
:This is triggered when the player leaves the level.
----
{{Anchor|level_OnKill}}
;OnKill()
:This hook is triggered whenever an enemy is killed.
----
{{Anchor|level_OnKillAll}}
;OnKillAll()
:After OnKill has triggered, if there are no enemies left on the level, the OnKillAll will be triggered. It is possible for OnKillAll to trigger again later if more enemies are spawned. By default, the "relatively safe" message is displayed.
----
{{Anchor|level_IsCompleted}}
;IsCompleted() → '''boolean'''
:The game calls this hook to determine if the game statistics should count the level as completed. This is only called for special levels, not scripted levels. By default, all enemies must be dead for the level to be complete.

== Properties ==
These are properties of the global Level variable. They are changed by the engine as the player moves from level to level. For some of the read-only properties, rawset can be used to create a lua property that shadows the pascal property, tricking APIs that are implemented in lua. This is particularly useful for tricking the generator API into using a custom style.
{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Level'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|Word|status|This is for use by level designers. It is preferred to access it through Level.result.
|string|name|This is the level name as displayed on the HUD.
|Byte|name_number|This controls the "LevX" part of the level name. If zero, it won't be displayed.
|Byte|danger_level|Level generation parameter that corresponds to depth.
|Byte|style|The style (tile set) used by the level generation functions. This property is read-only.
|string|special_exit|The sid of the level that red stairs lead to on the current level number. This property is read-only.
|string|special_name|The sid of the current level prototype or the empty string for random levels. This property is read-only.
|DWord|item_array_size|Length of the sparse array that stores all the items on the level. This property is read-only.
|DWord|being_array_size|Length of the sparse array that stores all the beings on the level. This property is read-only.
}}
|}

== API ==
{{drltable|Level Interface|2|{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|{{modarg|value}}|{{moddef|list|property_get|dot||string|property}}
|{{modarg|void}}|{{moddef|list|property_set|dot|string|property|value|value}}
|{{modarg|boolean}}|{{moddef|list|flag_get|dot||Level Flag|flag}}
|{{modarg|void}}|{{moddef|list|flag_set|dot||Level Flag|flag|boolean|value}}
|{{modarg|value}}|{{moddef|list|roll_weight|dot||list|list|integer|sum}}
|{{modarg|integer}}|{{moddef|list|weight_list_sum|dot||list|list}}
|{{modarg|void}}|{{moddef|list|place_tile|dot||table|translation|string|tile|integer|x|integer|y}}
|{{modarg|void}}|{{moddef|list|player|dot||integer|x|integer|y}}
|{{modarg|integer}}|{{moddef|list|result|dot||integer|value}}
|{{modarg|boolean}}|{{moddef|list|eye_contact|dot||Coord|c1|Coord|c2}}
|{{modarg|boolean}}|{{moddef|list|is_visible|dot||Coord|position}}
|{{modarg|void}}|{{moddef|list|nuke|dot}}
|{{modarg|void}}|{{moddef|list|explosion|dot||Coord|position|integer|radius|integer|delay|integer|damage_dice|integer|damage_sides|Color|color|Sound ID|sound|DamageType|damagetype|ExplosionFlag List|flags|Cell ID|content}}
||'''Cell-specific functions'''
|{{modarg|boolean}}|{{moddef|list|light_flag_get|dot||Coord|position|LightFlag|flag}}
|{{modarg|void}}|{{moddef|list|light_flag_set|dot||Coord|position|LightFlag|flag|boolean|value}}
|{{modarg|integer}}|{{moddef|list|hp_get|dot||Coord|position}}
|{{modarg|void}}|{{moddef|list|hp_set|dot||Coord|position|integer|value}}
|{{modarg|boolean}}|{{moddef|list|is_corpse|dot||Coord|position}}
|{{modarg|boolean}}|{{moddef|list|scan|dot||Area|scan_area|Cell ID|good}}
|{{modarg|void}}|{{moddef|list|fill|dot||Cell ID|cell|Area|fill_area}}
|{{modarg|void}}|{{moddef|list|flood|dot||Cell ID|tile|Area|flood_area}}
|{{modarg|void}}|{{moddef|list|scatter|dot||Area|scatter_area|Cell ID|good|Cell ID|fill|integer|count}}
|{{modarg|void}}|{{moddef|list|scatter_put|dot||Area|scatter_area|table|translation|string|tile|Cell ID|good|integer|count}}

||'''Being-specific functions'''
|{{modarg|Being}}|{{moddef|list|get_being|dot||integer|index}}
|{{modarg|Being}}|{{moddef|list|get_being_by_uid|dot||integer|uid}}
|{{modarg|Being}}|{{moddef|list|drop_being|dot||Being ID|bid|Coord|position}}
|{{modarg|void}}|{{moddef|list|drop_being_ext|dot||table|being|Coord|position}}
|{{modarg|Being}}|{{moddef|list|summon|dot||Being ID|bid|integer|count}}
|{{modarg|Being}}|{{moddef|list|area_summon|dot||Area|where|Being ID|bid|integer|count}}
|{{modarg|void}}|{{moddef|list|clear_being|dot||Coord|position}}
|{{modarg|list}}, {{modarg|integer}}|{{moddef|list|get_being_list|dot}}
|[[Modding:Being|Being ID]]|{{moddef|list|random_being|dot}}
|{{modarg|void}}|{{moddef|list|flood_monster|dot||Being ID|bid|integer|amount}}
|{{modarg|void}}|{{moddef|list|flood_monsters|dot||integer|amount}}
|{{modarg|Being iterator}}|{{moddef|list|beings|dot}}
|{{modarg|Being iterator}}|{{moddef|list|beings_in_range|dot||Coord|position|integer|range}}
||'''Item-specific functions'''
|{{modarg|Item}}|{{moddef|list|get_item|dot||integer|index}}
|{{modarg|Item}}|{{moddef|list|get_item_by_uid|dot||integer|uid}}
|{{modarg|Item}}|{{moddef|list|drop_item|dot||Item ID|iid|Coord|position}}
|{{modarg|void}}|{{moddef|list|drop_item_ext|dot||table|item|Coord|position}}
|{{modarg|Item}}|{{moddef|list|drop|dot||Item ID|iid|integer|count}}
|{{modarg|Item}}|{{moddef|list|area_drop|dot||Area|where|Item ID|iid|integer|count}}
|{{modarg|void}}|{{moddef|list|try_destroy_item|dot||Coord|c}}
|{{modarg|list}}, {{modarg|integer}}|{{moddef|list|get_item_list|dot||integer|max_level|integer|unique_mult}}
|[[Modding:Item|Item ID]]|{{moddef|list|roll_item_type|dot||ItemType list|itypes|integer|max_level|integer|unique_mod}}
|[[Modding:Item|Item ID]]|{{moddef|list|roll_item|dot||integer|max_level|integer|unique_mod}}
|{{modarg|void}}|{{moddef|list|flood_items|dot||integer|amount|}}
|{{modarg|Item iterator}}|{{moddef|list|items|dot}}
|{{modarg|Item iterator}}|{{moddef|list|items_in_range|dot||Coord|position|integer|range}}
}}
}}

{{moddef|desc|property_get|dot|value|string|property}}
:Gets the value of the given level property. It is preferred to use the Lua dot indexing syntax instead.
----
{{moddef|desc|property_set|dot|string|property|value|value}}
:Sets the given level property to the given value. It is preferred to use the Lua dot indexing syntax instead.
----
{{moddef|desc|flag_get|dot|boolean|Level Flag|flag}}
;Level.flags[[[Modding:Constants#Level Flags|Level Flag]] flag] → '''boolean'''
:Determines the current state of the given level flag.
----
{{moddef|desc|flag_set|dot||Level Flag|flag|boolean|value}}
;Level.flags[[[Modding:Constants#Level Flags|Level Flag]] flag] = '''boolean''' value
:Sets the given level flag to the given value.
----
{{moddef|desc|roll_weight|dot|value|list|list|integer|sum}}
:Randomly chooses an item from the list according to the weight property of the list items. Sum must be the sum of the weights of all the list items.
----
{{moddef|desc|weight_list_sum|dot|integer|list|list}}
:Returns the sum of the weight properties of all the items in the list.
----
{{moddef|desc|place_tile|dot||table|translation|string|tile|integer|x|integer|y}}
:Places the map tile given by ''translation'' and ''tile'' on the map at the position given by ''x'' and ''y''. ''translation'' should be a table that maps single character strings to either cell ids, or to tables. These tables have their first array element be a cell id, but they may also contain a being and''or'' item key that is mapped to a being or item id respectively. Level.drop_being_ext and Level.drop_item_ext syntax is allowed. ''tile'' should be a string of characters that are defined in ''translation''. Line breaks correspond to line breaks on the map.
----
{{moddef|desc|player|dot||integer|x|integer|y}}
:Sets the initial position of the player for a special or scripted level. This should be called in the Create hook; after that it has no meaningful effect.
----
{{moddef|desc|result|dot|integer|integer|value}}
:If ''value'' is given, updates the level's status and returns nil. If ''value'' is omitted, returns the current status.
----
{{moddef|desc|eye_contact|dot|boolean|Coord|c1|Coord|c2}}
:Determines whether or not there is a line-of-sight path between '''c1''' and '''c2'''. This calculation ignores light flags (such that two beings can have eye contact even if they aren't visible to each other).
----
{{moddef|desc|is_visible|dot|boolean|Coord|position}}
:Determines if the given position is visible to the player.
----
{{moddef|desc|nuke|dot}}
:Triggers an immediate nuclear explosion as from a [[thermonuclear bomb]].
----
{{moddef|desc|explosion|dot||Coord|position|integer|radius|integer|delay|integer|damage_dice|integer|damage_sides|Color|color|Sound ID|sound|DamageType|damagetype|ExplosionFlag List|flags|Cell ID|content}}
:Creates an [[explosions|explosion]] centered at the given position with the given parameters. ''radius'' is the size of the explosion. ''delay'' is the delay in milliseconds between animation frames (typically this is around 40). ''damage_dice'' and ''damage_sides'' determine the damage roll for the explosion. For a no-damage explosion, both should be 0. The default damage type is fire. ''content'' determines the cell that is randomly created wherever the explosion does enough damage. By default, there are no flags and there is no content. Only some colors are supported, and these are automatically translated into 3 color combinations used by the explosion animation. The supported colors are LIGHTBLUE, BLUE, MAGENTA, GREEN, LIGHTRED, YELLOW, and the default RED.
----
{{moddef|desc|light_flag_get|dot|boolean|Coord|position|LightFlag|flag}}
;Level.light[[[Modding:Coord|Coord]] position][[[Modding:Constants#LightFlag|LightFlag]] flag] → '''boolean'''
:Gets the value of the given light flag at the given position.
----
{{moddef|desc|light_flag_set|dot||Coord|position|LightFlag|flag|boolean|value}}
;Level.light[[[Modding:Coord|Coord]] position][[[Modding:Constants#LightFlag|LightFlag]] flag] = '''boolean''' value
;Level.light[[[Modding:Constants#LightFlag|LightFlag]] flag] = '''boolean''' value
:Sets the value of the given light flag at the given position. For the syntax without a position, the light flag will be set at every position on the map.
----
{{moddef|desc|hp_get|dot|integer|Coord|position}}
;Level.hp[[[Modding:Coord|Coord]] position] → '''integer'''
:Gets the current hp of the cell at the given position.
----
{{moddef|desc|hp_set|dot||Coord|position|integer|value}}
;Level.hp[[[Modding:Coord|Coord]] position] = '''integer''' value
:Sets the current hp of the cell at the given position. Setting hp to 0 won't destroy a cell.
----
{{moddef|desc|is_corpse|dot|boolean|Coord|position}}
:Determines whether the given position has a corpse in it. This counts the cell with id "corpse" as a corpse even though it otherwise isn't a corpse as far as the engine is concerned.
----
{{moddef|desc|scan|dot|boolean|Area|scan_area|Cell ID|good}}
:Determines if every cell in ''scan_area'' is ''good''.
----
{{moddef|desc|fill|dot||Cell ID|cell|Area|fill_area}}
:Sets every cell in the given area to the area. ''fill_area'' is optional; it defaults to the full map.
----
{{moddef|desc|flood|dot||Cell ID|tile|Area|flood_area}}
:Changes CELLSET_FLOORS and CF_LIQUID tiles in the area to ''tile''. If ''tile'' has CF_HAZARD, then it will destroy items.
----
{{moddef|desc|scatter|dot||Area|scatter_area|Cell ID|good|Cell ID|fill|integer|count}}
:Chooses ''count'' random tiles in ''scatter_area'' (possibly with duplicates) and sets any chosen cells that are ''good'' to ''fill''.
----
{{moddef|desc|scatter_put|dot||Area|scatter_area|table|translation|string|tile|Cell ID|good|integer|count}}
:Chooses ''count'' random subareas with upper-left corner in ''scatter_area'' of the size appropriate of ''tile'' (using the first line length and number of lines to define a rectangular area). There may be duplicates or overlaps. For each subarea, if the area is already filled with ''good'', then it is replaced with ''tile'' (according to ''translation''). See Level.place_tile for the semantics of ''translation'' and ''tile''.
----

{{moddef|desc|get_being|dot|Being|integer|index}}
:Returns the being at the given index in the sparse being array. A being's index won't change as long as it is in the array.
----
{{moddef|desc|get_being_by_uid|dot|Being|integer|uid}}
:Returns the being with the given uid, or nil if that being doesn't exist or has been removed from the map.
----
{{moddef|desc|drop_being|dot|Being|Being ID|bid|Coord|position}}
:Drops a newly created being in the given position. ''bid'' can also be an actual being object, although this should not be used for beings that are already on the map. If the position is occupied, the being will be dropped nearby. The dropped being is returned. If the function fails, nil is returned.
----
{{moddef|desc|drop_being_ext|dot||table|being|Coord|position}}
:As Level.drop_being, except additional values are accetable for ''being'' as Level.drop_item_ext.
----
{{moddef|desc|summon|dot|Being|Being ID|bid|integer|count}}
:Creates new beings of the type given by ''bid'' and amount given by ''count'' and scatters them around the map. The last dropped being (if any) is returned. ''count'' is optional and defaults to 1.
----
{{moddef|desc|area_summon|dot|Being|Area|where|Being ID|bid|integer|count}}
:As Level.summon, but all the summoned beings are randomly placed in ''where'' rather than scattered across the whole map.
----
{{moddef|desc|clear_being|dot||Coord|position}}
{{moddef|desc|clear_being|dot||integer|index}}
:Removes an item from the map at the given position, or from the given index in the item array.
----
{{moddef|desc|get_being_list|dot|list,integer}}
:Returns the list and sum (ready to be used with [[#level_roll_weight|Level.roll_weight]]) for beings and beings groups according to Level.danger_level and DIFFICULTY. The result is cached.
----
{{moddef|desc|random_being|dot|Being ID}}
:Returns a random being chosen according to weights from the current level's list. This will never choose a group. The returned id is always a string id.
----
{{moddef|desc|flood_monster|dot||Being ID|bid|integer|amount}}
:Add the given monster type to the level in an amount specified by the total danger value ''amount'' (so it scales appropriately with Level.flood_monsters).
----
{{moddef|desc|flood_monsters|dot||integer|amount}}
:Adds monsters to the level using the normal algorithm for random levels. The ''amount'' is a total danger value such as a value returned by Generator.being_weight.
----
{{moddef|desc|beings|dot|Being iterator}}
:Gives an iterator over all beings in the level.
----
{{moddef|desc|beings_in_range|dot|Being iterator|Coord|position|integer|range}}
:Gives an iterator over all beings within '''range''' units of [[distance]] from '''position''' in the level.
----
{{moddef|desc|get_item|dot|Item|integer|index}}
:Returns the item at the given index in the sparse item array. An item's index won't change as long as it is in the array.
----
{{moddef|desc|get_item_by_uid|dot|Item|integer|uid}}
:Returns the item with the given uid, or nil if that item doesn't exist or has been removed from the map.
----
{{moddef|desc|drop_item|dot|Item|Item ID|iid|Coord|position}}
:Drops a newly created item in the given position. ''iid'' can also be an actual item object, although this should not be used for items that are already on the map. If the position is occupied, the item will be dropped nearby. The dropped item is returned. If the function fails, nil is returned.
----
{{moddef|desc|drop_item_ext|dot||table|item|Coord|position}}
:As Level.drop_item, except additional values are acceptable for ''item''. If ''item'' is a table, the first list element is passed used to determine which item to drop. For other key-value pairs in the table, the property of the dropped item that corresponds to the key will be set to the value.
----
{{moddef|desc|drop|dot|Item|Item ID|iid|integer|count}}
:Creates new items of the type given by ''iid'' and amount given by ''count'' and scatters them around the map. The last dropped item (if any) is returned. ''count'' is optional and defaults to 1.
----
{{moddef|desc|area_drop|dot|Item|Area|where|Item ID|iid|integer|count}}
:As Level.drop, but all dropped items are randomly placed in ''where'' rather than scattered across the whole map.
----
{{moddef|desc|try_destroy_item|dot||Coord|c}}
:Destroys an item at '''position''', if there is one to be found.
----
{{moddef|desc|get_item_list|dot|list,integer|integer|max_level|integer|unique_mult}}
:Returns the list and sum (ready to be used with [[#level_roll_weight|Level.roll_weight]]) for items according to ''max_level'', and ''unique_mult''. ''max_level'' defaults to Level.danger_level, and is used to determine which items fall in the proper level range. Unique items' weights are multiplied by ''unique_mult'' (which defaults to 1). The result is cached.
----
{{moddef|desc|roll_item_type|dot|Item ID|ItemType list|itypes|integer|max_level|integer|unique_mod}}
:Returns a random item chosen from among the given item types according to weights from the list specified by ''max_level'' and ''unique_mod''. The returned id is always a string id.
----
{{moddef|desc|roll_item|dot|Item ID|integer|max_level|integer|unique_mod}}
:As Level.roll_item_type, but the item type of the result isn't restricted.
----
{{moddef|desc|flood_items|dot||integer|amount|}}
:Adds items to the level according to the normal algorithm for random levels (not counting special features). The number of items is given by ''amount''.
----
{{moddef|desc|items|dot|Item iterator}}
:Gives an iterator over all items in the level.
----
{{moddef|desc|items_in_range|dot|Item iterator|Coord|position|integer|range}}
:Gives an iterator over all items within '''range''' units of [[distance]] from '''position''' in the level.

Modding:Cell

2012-01-31T20:08:52Z

Game Hunter: moved cell flags (Modding:Constants will eventually be stripped)

Cells are what make up the game world. You walk over them, open them, travel down their stairs, and blow up their barrels. Unlinke [[Modding:Being|beings]] and [[Modding:Item|items]], cells aren't instantiated. All cells of a given type are exactly the same except for hp and light flags both of which must be accessed through the [[Modding:Level#API|Level API]].

== Prototype ==
Once a cell is registered, changing the lua object will have no effect on how the cell operates (although it can affect some of the APIs). The exception to this is that hooks can be redefined (although which hooks are present can't be changed). Cell prototypes are declared by passing a table with the desired properties and hooks to the global Cells function. Required properties are underlined. Cells prototypes are stored in a global table called cells that can be indexed by string id or numeric id.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|Cell Prototype
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|'''string'''|name|This is the name of the cell that is displayed in game messages.
|'''string'''|id|This is the string id that is used to reference the cell prototype internally. (A numeric id called nid is generated automatically.) The default is the first word of the name in all lowercase.
|'''string'''|ascii|This should be a single character string. It is used to display cells on the map.
|'''string'''|asciilow|If the ascii property is not once of the standard visible ASCII characters, then asciilow should be one of these standard characters to accomodate players that don't have support for an extended character selection. Whether or not to use asciilow is configurable by the player in config.lua.
|'''integer'''|sprite|This indicates the sprite used to represent the cell in the graphical version. Use 0 to indicate no sprite.
|[[Modding:Constants#Colors|Color]]|color|This is the color used to draw the cell when it is in the player's line-of-sight. The default is LIGHTGRAY.
|[[Modding:Constants#Colors|Color]]|color_dark|This is the color used to draw the cell when it has been explored, but is not in the player's line-of-sight. The default is DARKGRAY.
|'''string'''|color_id|If this is defined, then for the purposes of user color configuration, this is the cell's ID. Use this to force several cells to have the same color even if the user tries to redefine them.
|'''integer'''|effect|This is a multi-purpose cell property. Currently it is only used to specify the corresponding being ID for corpses (as 100 plus the being ID). As most corpses are [[Modding:Being#Prototype|generated automatically]], most modders won't need to worry about this. The default is 0.
|'''integer'''|armor|This is the amount of armor the cell has. All damage to the cell is reduced by this value (regardless of damage type, although some damage types may not affect the cell at all; see CF_FRAGILE). This can reduce damage to 0. If the cell's armor is 0, then it cannot be destroyed by damage. The default is 0.
|'''integer'''|hp|This is the initial amount of hp for the cell. If the cell is damaged, the hp for that particular cell (not the prototype) is reduced, and the cell isn't destroyed until it drops to 0. Cells with 0 hp must still be damaged to be destroyed. Be careful: changing cells after the beginning of the level doesn't usually update cells' current hp. The default is 0.
|Cell Flag '''list'''|flags|The flags in this list will be included in the cell's flag set. A property called flag_set is automatically created containing these flags in set format. The default is an empty list.
|[[Modding:Cell|Cell ID]]|bloodto|If defined, then the cell will transmute to the given new cell when it is affected by blood. This must be a string id.
|[[Modding:Cell|Cell ID]]|destroyto|If the cell is destroyed, it will transmute to the given new cell. This must be a string id. The default is "floor".
|[[Modding:Constants#Cellsets|Cellset]]|set|The cellsets are groupings for cells. They aren't used very much. Most notably, beings will only leave corpses on cells in CELLSET_FLOORS. By default, the cell won't be included in a set.
|}}
|}
=== Cell Flags ===
{{drltable|Cell Flags|2|{{Table2Col
|es=background: #333;
|c1=font-family:monospace; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|CF_BLOCKMOVE|Cells with this flag block movement and projectiles.
|CF_BLOCKLOS|Cells with this flag block vision.
|CF_CORPSE|This flag is set for autogenerated corpses. Only cells with this flag can be ressurected. The being created by resurrection can be specified by setting the cell's effect parameter to 100 + being.id. Note that the "corpse" cell does not have this flag. To include this cell, use Level.is_corpse.
|CF_NOCHANGE|Currently, this flag is only checked by the map powerups. The map powerups reveal cells with this flag (as well as CF_BLOCKMOVE cells).
|CF_NORUN|The run command (not the run tactic) will stop the player before he steps on a cell with this flag.
|CF_PUSHABLE|Cells with this flag can be pushed (like barrels in DoomRL). Pushing is mostly hard-coded.
|CF_FRAGILE|Cells with this flag can be destroyed by any damage type (assuming they have HP or armor) whereas cells cannot usually be damaged by bullet, melee, shrapnel, or piercing damage.
|CF_HAZARD|This flag should be set for cells that are dangerous to step on. The AI will usually avoid these tiles. This flag is also used with the EF_NOHARM empty flag.
|CF_OVERLAY|This flag is related to the graphical version.
|CF_MULTISPRITE|This flag is related to the graphical version.
|CF_STICKWALL|This flag is related to the graphical version.
|CF_LIQUID|This flag is used to mark liquid cells (water, acid, lava). Currently, it is only checked by Level.flood which will flood over CELLSET_FLOORS cells and CF_LIQUID cells.
|CF_OPENABLE|This flag indicates that the cell can be opened. What happens when the cells is opened is determined by the cell's OnAct hook.
|CF_CLOSABLE|As CF_OPENABLE, but for the close command.
|CF_RUNSTOP|Cells with this flag will stop the player's run when the player is orthogonally adjacent. Contrast with CF_NORUN.
|CF_NUKABLE|Cells with this flag will be destroyed be a nuke even if they are normally not destructible.
|CF_CRITICAL|Cells with this flag should usually not be altered or destroyed be the game. It is currently only checked by the flooding level event. Stairs have this flag.
|CF_HIGHLIGHT|This flag determines whether the light or dark color variant is used when a StatusEffect overlay is being applied.
|CF_BLOODY|When a being walks on one of these cells, its feet won't become less bloody. (See CF_BLOODY.)
|CF_VBLOODY|When a being walks on one of these cells, its feet will become bloody and it will temporarily leave a trail of blood.
|CF_STAIRS|Stairs are marked with this flag. (New stairs cells should include this.)
|}}
}}

== Engine Hooks ==
Although these hooks should be defined with a coord as the first argument, they are immediately translated into a new function that has x and y as its first two arguments. This is important when replacing the hooks after the fact or calling the hooks manually. For all hooks, the first argument is the coord of the cell that caused the hook.

{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="2" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|Cell Hooks
{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|'''void'''|[[#cell_OnEnter|OnEnter]]([[Modding:Coord|Coord]] c, [[Modding:Being|Being]] enterer)
|'''void'''|[[#cell_OnExit|OnExit]]([[Modding:Coord|Coord]] c)
|'''void'''|[[#cell_OnAct|OnAct]]([[Modding:Coord|Coord]] c, [[Modding:Being|Being]] actor)
|'''string'''|[[#cell_OnDescribe|OnDescribe]]([[Modding:Coord|Coord]] c)
|'''void'''|[[#cell_OnDestroy|OnDestroy]]([[Modding:Coord|Coord]] c)
|}}
|}

{{Anchor|cell_OnEnter}}
;OnEnter([[Modding:Coord|Coord]] c, [[Modding:Being|Being]] enterer)
:This hooks is called at the beginning of a being's turn if it is standing on the cell. (This triggers even if the being hasn't moved since its last turn.)
----
{{Anchor|cell_OnExit}}
;OnExit([[Modding:Coord|Coord]] c)
:This hook is called if the player uses the descend stairs action on the cell. That action is only allowed if this hook is defined. This hook also allows saving which is designed to work it the hook moves the player to the next level.
----
{{Anchor|cell_OnAct}}
;OnAct([[Modding:Coord|Coord]] c, [[Modding:Being|Being]] actor)
:This hook is called when a being opens or closes a cell. Opening and closing must be allowed by the CF_OPENABLE and CF_CLOSEABLE flags respectively.
----
{{Anchor|cell_OnDescribe}}
;OnDescribe([[Modding:Coord|Coord]] c) → '''string'''
:If this hook is defined, then it is used instead of the cell name for in game messages.
----
{{Anchor|cell_OnDestroy}}
;OnDestroy([[Modding:Coord|Coord]] c)
:This hook is called after a cell is destroyed. (The hook for the previous cell is used even though the cell has already been transmuted to the destroyto value.)

Modding:level blueprint (0.9.9.7)

2012-01-28T21:30:46Z

Game Hunter: revised with new templates

Level objects define the properties of fixed special levels. The level API, however, is a general purpose API for manipulating the level. This is used both for map generation (along with the [[Modding:Generator#API|generator API]]) and for changing the level on the fly. The Level variable also has some general properties that don't necessarily correspond to special levels in particular.

== Prototype ==
Levels prototypes are only used for special levels and scripted levels, not random levels. They are declared using the Levels function with the ID as the first argument, and a prototype table as the second argument. They are stored by ID in a global table called levels.
{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Level Prototype'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|string|ID|The unique identifier used by the engine for this level. Instead of being included in the table, this must be passed as the first argument to the Levels function.
|string|name|The name displayed in the HUD.
|string|welcome|Optional message displayed on level entry.
|integer|chance|Optional percent chance the level will appear. Defaults to 100.
|[[Modding:Functions$function_resolve_range|Range]]|level|Level range where the level may appear.
|string|entry|Optional mortem history message for level entry.
}}
|}

== Engine Hooks ==
{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="2" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Level Hooks'''
{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|void|[[#level_Create|Create]]()
|void|[[#level_OnTick|OnTick]]()
|void|[[#level_OnEnter|OnEnter]]()
|void|[[#level_OnExit|OnExit]]()
|void|[[#level_OnKill|OnKill]]()
|void|[[#level_OnKillAll|OnKillAll]]()
|boolean|[[#level_IsCompleted|IsCompleted]]()
}}
|}

{{Anchor|level_Create}}
;Create()
:This function should create the layout of the level. It also usually sets up the initial being and item locations. The player's initial location should be set here using Level.player.
----
{{Anchor|level_OnTick}}
;OnTick()
:This is called every 0.1s of game time. This will happen many times for each of the player's moves, so be careful about putting intense calculations here.
----
{{Anchor|level_OnEnter}}
;OnEnter()
:This is triggered just after the player enters the level.
----
{{Anchor|level_OnExit}}
;OnExit()
:This is triggered when the player leaves the level.
----
{{Anchor|level_OnKill}}
;OnKill()
:This hook is triggered whenever an enemy is killed.
----
{{Anchor|level_OnKillAll}}
;OnKillAll()
:After OnKill has triggered, if there are no enemies left on the level, the OnKillAll will be triggered. It is possible for OnKillAll to trigger again later if more enemies are spawned. By default, the "relatively safe" message is displayed.
----
{{Anchor|level_IsCompleted}}
;IsCompleted() → '''boolean'''
:The game calls this hook to determine if the game statistics should count the level as completed. This is only called for special levels, not scripted levels. By default, all enemies must be dead for the level to be complete.

== Properties ==
These are properties of the global Level variable. They are changed by the engine as the player moves from level to level. For some of the read-only properties, rawset can be used to create a lua property that shadows the pascal property, tricking APIs that are implemented in lua. This is particularly useful for tricking the generator API into using a custom style.
{|class="wikitable" style="border: 2px solid darkred; border-spacing: 0; font-size: 90%; margin: 0.25em 0.5em;"
! colspan="3" style="background: darkred; color: yellow; font-size: 120%; text-align: center"|'''Level'''
{{Table3Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=vertical-align:top; padding:0px 2px;
|c3=padding:0px 2px;
|Word|status|This is for use by level designers. It is preferred to access it through Level.result.
|string|name|This is the level name as displayed on the HUD.
|Byte|name_number|This controls the "LevX" part of the level name. If zero, it won't be displayed.
|Byte|danger_level|Level generation parameter that corresponds to depth.
|Byte|style|The style (tile set) used by the level generation functions. This property is read-only.
|string|special_exit|The sid of the level that red stairs lead to on the current level number. This property is read-only.
|string|special_name|The sid of the current level prototype or the empty string for random levels. This property is read-only.
|DWord|item_array_size|Length of the sparse array that stores all the items on the level. This property is read-only.
|DWord|being_array_size|Length of the sparse array that stores all the beings on the level. This property is read-only.
}}
|}

== API ==
{{drltable|Level Interface|2|{{Table2Col
|es=background: #333;
|c1=font-weight:bold; text-align:right; vertical-align:top; padding:0px 2px;
|c2=padding:0px 2px;
|{{modarg|value}}|{{moddef|list|property_get|dot||string|property}}
|{{modarg|void}}|{{moddef|list|property_set|dot|string|property|value|value}}
|{{modarg|boolean}}|{{moddef|list|flag_get|dot||Level Flag|flag}}
|{{modarg|void}}|{{moddef|list|flag_set|dot||Level Flag|flag|boolean|value}}
|{{modarg|value}}|{{moddef|list|roll_weight|dot||list|list|integer|sum}}
|{{modarg|integer}}|{{moddef|list|weight_list_sum|dot||list|list}}
|{{modarg|void}}|{{moddef|list|place_tile|dot||table|translation|string|tile|integer|x|integer|y}}
|{{modarg|void}}|{{moddef|list|player|dot||integer|x|integer|y}}
|{{modarg|integer}}|{{moddef|list|result|dot||integer|value}}
|{{modarg|boolean}}|{{moddef|list|eye_contact|dot||Coord|c1|Coord|c2}}
|{{modarg|boolean}}|{{moddef|list|is_visible|dot||Coord|position}}
|{{modarg|void}}|{{moddef|list|nuke|dot}}
|{{modarg|void}}|{{moddef|list|explosion|dot||Coord|position|integer|radius|integer|delay|integer|damage_dice|integer|damage_sides|Color|color|Sound ID|sound|DamageType|damagetype|ExplosionFlag List|flags|Cell ID|content}}
||'''Cell-specific functions'''
|{{modarg|boolean}}|{{moddef|list|light_flag_get|dot||Coord|position|LightFlag|flag}}
|{{modarg|void}}|{{moddef|list|light_flag_set|dot||Coord|position|LightFlag|flag|boolean|value}}
|{{modarg|integer}}|{{moddef|list|hp_get|dot||Coord|position}}
|{{modarg|void}}|{{moddef|list|hp_set|dot||Coord|position|integer|value}}
|{{modarg|boolean}}|{{moddef|list|is_corpse|dot||Coord|position}}
|{{modarg|boolean}}|{{moddef|list|scan|dot||Area|scan_area|Cell ID|good}}
|{{modarg|void}}|{{moddef|list|fill|dot||Cell ID|cell|Area|fill_area}}
|{{modarg|void}}|{{moddef|list|flood|dot||Cell ID|tile|Area|flood_area}}
|{{modarg|void}}|{{moddef|list|scatter|dot||Area|scatter_area|Cell ID|good|Cell ID|fill|integer|count}}
|{{modarg|void}}|{{moddef|list|scatter_put|dot||Area|scatter_area|table|translation|string|tile|Cell ID|good|integer|count}}

||'''Being-specific functions'''
|{{modarg|Being}}|{{moddef|list|get_being|dot||integer|index}}
|{{modarg|Being}}|{{moddef|list|get_being_by_uid|dot||integer|uid}}
|{{modarg|Being}}|{{moddef|list|drop_being|dot||Being ID|bid|Coord|position}}
|{{modarg|void}}|{{moddef|list|drop_being_ext|dot||table|being|Coord|position}}
|{{modarg|Being}}|{{moddef|list|summon|dot||Being ID|bid|integer|count}}
|{{modarg|Being}}|{{moddef|list|area_summon|dot||Area|where|Being ID|bid|integer|count}}
|{{modarg|void}}|{{moddef|list|clear_being|dot||Coord|position}}
|{{modarg|list}}, {{modarg|integer}}|{{moddef|list|get_being_list|dot}}
|[[Modding:Being|Being ID]]|{{moddef|list|random_being|dot}}
|{{modarg|void}}|{{moddef|list|flood_monster|dot||Being ID|bid|integer|amount}}
|{{modarg|void}}|{{moddef|list|flood_monsters|dot||integer|amount}}
|{{modarg|Being iterator}}|{{moddef|list|beings|dot}}
|{{modarg|Being iterator}}|{{moddef|list|beings_in_range|dot||Coord|position|integer|range}}
||'''Item-specific functions'''
|{{modarg|Item}}|{{moddef|list|get_item|dot||integer|index}}
|{{modarg|Item}}|{{moddef|list|get_item_by_uid|dot||integer|uid}}
|{{modarg|Item}}|{{moddef|list|drop_item|dot||Item ID|iid|Coord|position}}
|{{modarg|void}}|{{moddef|list|drop_item_ext|dot||table|item|Coord|position}}
|{{modarg|Item}}|{{moddef|list|drop|dot||Item ID|iid|integer|count}}
|{{modarg|Item}}|{{moddef|list|area_drop|dot||Area|where|Item ID|iid|integer|count}}
|{{modarg|void}}|{{moddef|list|try_destroy_item|dot||Coord|c}}
|{{modarg|list}}, {{modarg|integer}}|{{moddef|list|get_item_list|dot||integer|max_level|integer|unique_mult}}
|[[Modding:Item|Item ID]]|{{moddef|list|roll_item_type|dot||ItemType list|itypes|integer|max_level|integer|unique_mod}}
|[[Modding:Item|Item ID]]|{{moddef|list|roll_item|dot||integer|max_level|integer|unique_mod}}
|{{modarg|void}}|{{moddef|list|flood_items|dot||integer|amount|}}
|{{modarg|Item iterator}}|{{moddef|list|items|dot}}
|{{modarg|Item iterator}}|{{moddef|list|items_in_range|dot||Coord|position|integer|range}}
}}
}}

{{moddef|desc|property_get|dot|value|string|property}}
:Gets the value of the given level property. It is preferred to use the Lua dot indexing syntax instead.
----
{{moddef|desc|property_set|dot|string|property|value|value}}
:Sets the given level property to the given value. It is preferred to use the Lua dot indexing syntax instead.
----
{{moddef|desc|flag_get|dot|boolean|Level Flag|flag}}
;Level.flags[[[Modding:Constants#Level Flags|Level Flag]] flag] → '''boolean'''
:Determines the current state of the given level flag.
----
{{moddef|desc|flag_set|dot||Level Flag|flag|boolean|value}}
;Level.flags[[[Modding:Constants#Level Flags|Level Flag]] flag] = '''boolean''' value
:Sets the given level flag to the given value.
----
{{moddef|desc|roll_weight|dot|value|list|list|integer|sum}}
:Randomly chooses an item from the list according to the weight property of the list items. Sum must be the sum of the weights of all the list items.
----
{{moddef|desc|weight_list_sum|dot|integer|list|list}}
:Returns the sum of the weight properties of all the items in the list.
----
{{moddef|desc|place_tile|dot||table|translation|string|tile|integer|x|integer|y}}
:Places the map tile given by ''translation'' and ''tile'' on the map at the position given by ''x'' and ''y''. ''translation'' should be a table that maps single character strings to either cell ids, or to tables. These tables have their first array element be a cell id, but they may also contain a being and''or'' item key that is mapped to a being or item id respectively. Level.drop_being_ext and Level.drop_item_ext syntax is allowed. ''tile'' should be a string of characters that are defined in ''translation''. Line breaks correspond to line breaks on the map.
----
{{moddef|desc|player|dot||integer|x|integer|y}}
:Sets the initial position of the player for a special or scripted level. This should be called in the Create hook; after that it has no meaningful effect.
----
{{moddef|desc|result|dot|integer|integer|value}}
:If ''value'' is given, updates the level's status and returns nil. If ''value'' is omitted, returns the current status.
----
{{moddef|desc|eye_contact|dot|boolean|Coord|c1|Coord|c2}}
:Determines whether or not there is a line-of-sight path between '''c1''' and '''c2'''. This calculation ignores light flags (such that two beings can have eye contact even if they aren't visible to each other).
----
{{moddef|desc|is_visible|dot|boolean|Coord|position}}
:Determines if the given position is visible to the player.
----
{{moddef|desc|nuke|dot}}
:Triggers an immediate nuclear explosion as from a [[thermonuclear bomb]].
----
{{moddef|desc|explosion|dot||Coord|position|integer|radius|integer|delay|integer|damage_dice|integer|damage_sides|Color|color|Sound ID|sound|DamageType|damagetype|ExplosionFlag List|flags|Cell ID|content}}
:Creates an [[explosions|explosion]] centered at the given position with the given parameters. ''radius'' is the size of the explosion. ''delay'' is the delay in milliseconds between animation frames (typically this is around 40). ''damage_dice'' and ''damage_sides'' determine the damage roll for the explosion. For a no-damage explosion, both should be 0. The default damage type is fire. ''content'' determines the cell that is randomly created wherever the explosion does enough damage. By default, there are no flags and there is no content. Only some colors are supported, and these are automatically translated into 3 color combinations used by the explosion animation. The supported colors are LIGHTBLUE, BLUE, MAGENTA, GREEN, LIGHTRED, YELLOW, and the default RED.
----
{{moddef|desc|light_flag_get|dot|boolean|Coord|position|LightFlag|flag}}
;Level.light[[[Modding:Coord|Coord]] position][[[Modding:Constants#LightFlag|LightFlag]] flag] → '''boolean'''
:Gets the value of the given light flag at the given position.
----
{{moddef|desc|light_flag_set|dot||Coord|position|LightFlag|flag|boolean|value}}
;Level.light[[[Modding:Coord|Coord]] position][[[Modding:Constants#LightFlag|LightFlag]] flag] = '''boolean''' value
;Level.light[[[Modding:Constants#LightFlag|LightFlag]] flag] = '''boolean''' value
:Sets the value of the given light flag at the given position. For the syntax without a position, the light flag will be set at every position on the map.
----
{{moddef|desc|hp_get|dot|integer|Coord|position}}
;Level.hp[[[Modding:Coord|Coord]] position] → '''integer'''
:Gets the current hp of the cell at the given position.
----
{{moddef|desc|hp_set|dot||Coord|position|integer|value}}
;Level.hp[[[Modding:Coord|Coord]] position] = '''integer''' value
:Sets the current hp of the cell at the given position. Setting hp to 0 won't destroy a cell.
----
{{moddef|desc|is_corpse|dot|boolean|Coord|position}}
:Determines whether the given position has a corpse in it. This counts the cell with id "corpse" as a corpse even though it otherwise isn't a corpse as far as the engine is concerned.
----
{{moddef|desc|scan|dot|boolean|Area|scan_area|Cell ID|good}}
:Determines if every cell in ''scan_area'' is ''good''.
----
{{moddef|desc|fill|dot||Cell ID|cell|Area|fill_area}}
:Sets every cell in the given area to the area. ''fill_area'' is optional; it defaults to the full map.
----
{{moddef|desc|flood|dot||Cell ID|tile|Area|flood_area}}
:Changes CELLSET_FLOORS and CF_LIQUID tiles in the area to ''tile''. If ''tile'' has CF_HAZARD, then it will destroy items.
----
{{moddef|desc|scatter|dot||Area|scatter_area|Cell ID|good|Cell ID|fill|integer|count}}
:Chooses ''count'' random tiles in ''scatter_area'' (possibly with duplicates) and sets any chosen cells that are ''good'' to ''fill''.
----
{{moddef|desc|scatter_put|dot||Area|scatter_area|table|translation|string|tile|Cell ID|good|integer|count}}
:Chooses ''count'' random subareas with upper-left corner in ''scatter_area'' of the size appropriate of ''tile'' (using the first line length and number of lines to define a rectangular area). There may be duplicates or overlaps. For each subarea, if the area is already filled with ''good'', then it is replaced with ''tile'' (according to ''translation''). See Level.place_tile for the semantics of ''translation'' and ''tile''.
----

{{moddef|desc|get_being|dot|Being|integer|index}}
:Returns the being at the given index in the sparse being array. A being's index won't change as long as it is in the array.
----
{{moddef|desc|get_being_by_uid|dot|Being|integer|uid}}
:Returns the being with the given uid, or nil if that being doesn't exist or has been removed from the map.
----
{{moddef|desc|drop_being|dot|Being|Being ID|bid|Coord|position}}
:Drops a newly created being in the given position. ''bid'' can also be an actual being object, although this should not be used for beings that are already on the map. If the position is occupied, the being will be dropped nearby. The dropped being is returned. If the function fails, nil is returned.
----
{{moddef|desc|drop_being_ext|dot||table|being|Coord|position}}
:As Level.drop_being, except additional values are accetable for ''being'' as Level.drop_item_ext.
----
{{moddef|desc|summon|dot|Being|Being ID|bid|integer|count}}
:Creates new beings of the type given by ''bid'' and amount given by ''count'' and scatters them around the map. The last dropped being (if any) is returned. ''count'' is optional and defaults to 1.
----
{{moddef|desc|area_summon|dot|Being|Area|where|Being ID|bid|integer|count}}
:As Level.summon, but all the summoned beings are randomly placed in ''where'' rather than scattered across the whole map.
----
{{moddef|desc|clear_being|dot||Coord|position}}
{{moddef|desc|clear_being|dot||integer|index}}
:Removes an item from the map at the given position, or from the given index in the item array.
----
{{moddef|desc|get_being_list|dot|list,integer}}
:Returns the list and sum (ready to be used with [[#level_roll_weight|Level.roll_weight]]) for beings and beings groups according to Level.danger_level and DIFFICULTY. The result is cached.
----
{{moddef|desc|random_being|dot|Being ID}}
:Returns a random being chosen according to weights from the current level's list. This will never choose a group. The returned id is always a string id.
----
{{moddef|desc|flood_monster|dot||Being ID|bid|integer|amount}}
:Add the given monster type to the level in an amount specified by the total danger value ''amount'' (so it scales appropriately with Level.flood_monsters).
----
{{moddef|desc|flood_monsters|dot||integer|amount}}
:Adds monsters to the level using the normal algorithm for random levels. The ''amount'' is a total danger value such as a value returned by Generator.being_weight.
----
{{moddef|desc|beings|dot|Being iterator}}
:Gives an iterator over all beings in the level.
----
{{moddef|desc|beings_in_range|dot|Being iterator|Coord|position|integer|range}}
:Gives an iterator over all beings within '''range''' units of [[distance]] from '''position''' in the level.
----
{{moddef|desc|get_item|dot|Item|integer|index}}
:Returns the item at the given index in the sparse item array. An item's index won't change as long as it is in the array.
----
{{moddef|desc|get_item_by_uid|dot|Item|integer|uid}}
:Returns the item with the given uid, or nil if that item doesn't exist or has been removed from the map.
----
{{moddef|desc|drop_item|dot|Item|Item ID|iid|Coord|position}}
:Drops a newly created item in the given position. ''iid'' can also be an actual item object, although this should not be used for items that are already on the map. If the position is occupied, the item will be dropped nearby. The dropped item is returned. If the function fails, nil is returned.
----
{{moddef|desc|drop_item_ext|dot||table|item|Coord|position}}
:As Level.drop_item, except additional values are acceptable for ''item''. If ''item'' is a table, the first list element is passed used to determine which item to drop. For other key-value pairs in the table, the property of the dropped item that corresponds to the key will be set to the value.
----
{{moddef|desc|drop|dot|Item|Item ID|iid|integer|count}}
:Creates new items of the type given by ''iid'' and amount given by ''count'' and scatters them around the map. The last dropped item (if any) is returned. ''count'' is optional and defaults to 1.
----
{{moddef|desc|area_drop|dot|Item|Area|where|Item ID|iid|integer|count}}
:As Level.drop, but all dropped items are randomly placed in ''where'' rather than scattered across the whole map.
----
{{moddef|desc|try_destroy_item|dot||Coord|c}}
:Destroys an item at '''position''', if there is one to be found.
----
{{moddef|desc|get_item_list|dot|list,integer|integer|max_level|integer|unique_mult}}
:Returns the list and sum (ready to be used with [[#level_roll_weight|Level.roll_weight]]) for items according to ''max_level'', and ''unique_mult''. ''max_level'' defaults to Level.danger_level, and is used to determine which items fall in the proper level range. Unique items' weights are multiplied by ''unique_mult'' (which defaults to 1). The result is cached.
----
{{moddef|desc|roll_item_type|dot|Item ID|ItemType list|itypes|integer|max_level|integer|unique_mod}}
:Returns a random item chosen from among the given item types according to weights from the list specified by ''max_level'' and ''unique_mod''. The returned id is always a string id.
----
{{moddef|desc|roll_item|dot|Item ID|integer|max_level|integer|unique_mod}}
:As Level.roll_item_type, but the item type of the result isn't restricted.
----
{{moddef|desc|flood_items|dot||integer|amount|}}
:Adds items to the level according to the normal algorithm for random levels (not counting special features). The number of items is given by ''amount''.
----
{{moddef|desc|items|dot|Item iterator}}
:Gives an iterator over all items in the level.
----
{{moddef|desc|items_in_range|dot|Item iterator|Coord|position|integer|range}}
:Gives an iterator over all items within '''range''' units of [[distance]] from '''position''' in the level.