Parameterized linedef specials

From Eternity Wiki
Revision as of 15:56, 28 July 2016 by Printz (talk | contribs) (Ceiling movement)
Jump to: navigation, search

The parameterized linedefs types are Hexen-like action specials with arguments, whose purpose is to be more customizable than the Boom generalized types. Currently they can be implemented by using ExtraData lumps attached via EMAPINFO to each map, or by designing the level in the Hexen format. They can also be called from ACS. When called in ExtraData or ACS, their parameters aren't limited to 0-255 as it is the case with the Hexen map format.

Each parameterized line special has a name and two associated numbers: one for ExtraData support, set this way to avoid conflicts with classic Boom specials, and one for Hexen, ACS and (upcoming) UDMF formats.

For any parameterized special with first argument defined as tag, if it's 0, it will affect the sector behind the line (if any). It will not affect all sectors with tag 0, or be rejected, as it is with classic specials.

IMPORTANT: all reserved parameters must be set to 0. Failure to do so will result in your maps being broken in later Eternity versions!

Back to Linedef types


  • 300:Door_Raise(tag, speed, delay, light_tag)
  • 301:Door_Open(tag, speed, light_tag)
  • 302:Door_Close(tag, speed, light_tag)
  • 303:Door_CloseWaitOpen(tag, speed, delay, light_tag)
  • 304:Door_WaitRaise(tag, speed, delay, timeoffset, light_tag)
  • 305:Door_WaitClose(tag, speed, timeoffset, light_tag)
  • 429:Door_LockedRaise(tag, speed, delay, lock, light_tag) (since Feb 25 2016)
tag: Tag of sector to affect. If it's 0, then the sector behind the linedef will be activated, if applicable.
speed: How fast, in eights of units per tic, the door should move. Doom normal doors are as fast as 16, and blazing doors are 64.
delay: Time in tics (1/35 seconds) for the door before it returns to its opposite movement.
timeoffset: Time in tics before the door activates.
light_tag: Sector tag to receive light changes to maximum or minimum neighbor depending on whether the door is closed or opened.
lock: One of the lock identifiers to specify the key or set of keys.

Floor movement, earthquake

  • 306:Floor_RaiseToHighest ( tag, speed, change, crush )
  • 307:Floor_LowerToHighest ( tag, speed, change )
  • 308:Floor_RaiseToLowest ( tag, change, crush )
  • 309:Floor_LowerToLowest ( tag, speed, change )
  • 310:Floor_RaiseToNearest ( tag, speed, change, crush )
  • 311:Floor_LowerToNearest ( tag, speed, change )
  • 312:Floor_RaiseToLowestCeiling ( tag, speed, change, crush )
  • 313:Floor_LowerToLowestCeiling ( tag, speed, change )
  • 314:Floor_RaiseToCeiling ( tag, speed, change, crush )
  • 315:Floor_RaiseByTexture ( tag, speed, change, crush )
  • 316:Floor_LowerByTexture ( tag, speed, change )
  • 317:Floor_RaiseByValue ( tag, speed, height, change, crush )
  • 318:Floor_LowerByValue ( tag, speed, height, change )
  • 319:Floor_MoveToValue ( tag, speed, height, change, crush )
  • 320:Floor_RaiseInstant ( tag, height, change, crush )
  • 321:Floor_LowerInstant ( tag, height, change )
  • 322:Floor_ToCeilingInstant ( tag, change, crush )
Most of these are self-explanatory. The first six functions move the floor relative to the neighbor floor and the next two to the neighbor ceiling. The 'ByTexture' types move by the shortest lower texture's height. Parameters follow -
  • tag - the target sector(s) tag. If set to 0, it will target the sector beyond the triggering linedef, like how manual doors work.
  • speed - speed in eights of units per tic. As a reference most of the Doom regular type floors move by 8.
  • change - 0 : No texture or type change.
1 : Copy texture, zero type; trigger model.
2 : Copy texture, zero type; numeric model.
3 : Copy texture, preserve type; trigger model.
4 : Copy texture, preserve type; numeric model.
5 : Copy texture and type; trigger model.
6 : Copy texture and type; numeric model.
  • crush - nonzero if to crush, and by how much damage per each event. Regular Doom crushers have 10 damage.
  • height - integer value specifying how much to move the floor, or which is the absolute destination Z coordinate to move it.
  • 431:Floor_Donut (pillar_tag, pillar_speed, surrounding_speed)
Does the donut movement behavior, allowing you to choose pillar speed and surrounding pool speed. The tag belongs to the pillar.
  • 397:Floor_Waggle ( tag, height, speed, offset, timer )
This special implements the sinusoidal floor motion from Hexen. Its tag and speed parameters bear similar properties to the other floor specials, but -
  • height - waggle amplitude in 1/8 units
  • offset - phase offset; how much to delay the waggle in relation to others (0 to 63, in byte angles)
  • timer - time in seconds the waggle lasts. Zero means permanent
  • 375:Radius_Quake (intensity, duration, damageradius, quakeradius, tid)
This special implements the earthquake effect, centred on the map spot with the given tid, with user-selectable intensity, duration and separate thing damage radius and tremor radius (both being multiplied with 64).

Plats, lifts

410:Plat_PerpetualRaise(tag, speed, delay)
412:Plat_DownWaitUpStay(tag, speed, delay)
413:Plat_DownByValue(tag, speed, delay, height)
414:Plat_UpWaitDownStay(tag, speed, delay)
415:Plat_UpByValue(tag, speed, delay, height)

Ceiling movement

#    Function                           ExtraData Name 

323  Up to Highest Neighbor Ceiling     Ceiling_RaiseToHighest
324  Up to HnC Instant                  Ceiling_ToHighestInstant
325  Up to Nearest Neighbor Ceiling     Ceiling_RaiseToNearest
326  Down to Nearest Neighbor Ceiling   Ceiling_LowerToNearest
327  Up to Lowest Neighbor Ceiling      Ceiling_RaiseToLowest
328  Down to Lowest Neighbor Ceiling    Ceiling_LowerToLowest
329  Up to Highest Neighbor Floor       Ceiling_RaiseToHighestFloor
330  Down to Highest Neighbor Floor     Ceiling_LowerToHighestFloor
331  Down to Floor Instant              Ceiling_ToFloorInstant
332  Down to Floor                      Ceiling_LowerToFloor
333  Up Abs Shortest Upper Texture      Ceiling_RaiseByTexture
334  Down Abs Shortest Upper Texture    Ceiling_LowerByTexture
335  Up Absolute Param                  Ceiling_RaiseByValue
336  Down Absolute Param                Ceiling_LowerByValue
337  To Absolute Height                 Ceiling_MoveToValue
338  Up Absolute Param, Instant         Ceiling_RaiseInstant
339  Down Absolute Param, Instant       Ceiling_LowerInstant 

Ceiling_RaiseToHighest       tag, speed, change
Ceiling_ToHighestInstant     tag, change, crush
Ceiling_RaiseToNearest       tag, speed, change
Ceiling_LowerToNearest       tag, speed, change, crush
Ceiling_RaiseToLowest        tag, speed, change
Ceiling_LowerToLowest        tag, speed, change, crush
Ceiling_RaiseToHighestFloor  tag, speed, change
Ceiling_LowerToHighestFloor  tag, speed, change, crush
Ceiling_ToFloorInstant       tag, change, crush
Ceiling_LowerToFloor         tag, speed, change, crush
Ceiling_RaiseByTexture       tag, speed, change
Ceiling_LowerByTexture       tag, speed, change, crush
Ceiling_RaiseByValue         tag, speed, height, change
Ceiling_LowerByValue         tag, speed, height, change, crush
Ceiling_MoveToValue          tag, speed, height, change, crush
Ceiling_RaiseInstant         tag, height, change
Ceiling_LowerInstant         tag, height, change, crush 

tag    : Tag of the sector(s) to affect. A tag of zero means to
         affect the sector on the second side of the line.
speed  : Speed of ceiling in eighths of a unit per tic.
change : This parameter takes the following values:
         0 : No texture or type change.
         1 : Copy texture, zero type; trigger model.
         2 : Copy texture, zero type; numeric model.
         3 : Copy texture, preserve type; trigger model.
         4 : Copy texture, preserve type; numeric model.
         5 : Copy texture and type; trigger model.
         6 : Copy texture and type; numeric model.
crush  : Amount of crushing damage ceiling inflicts at each
         crushing event (when gametic % 4 = 0). If this
         amount is less than or equal to zero, no crushing
         damage is done.
height : An integer number of units, either the amount to 
         move the floor by or the exact z coordinate to move
         the floor toward. Negative numbers are valid for 
         the latter case.

Crushing ceilings

There are some crushing ceilings available now. Some originate from Hexen while others are extensions from ZDoom. ZDoom compatibility is considered where relevant. For all specials where it applies, crushmode can take one of these values:

  • 0: compatibility. Act like it would do in ZDoom. This means that in Doom the crusher keeps pushing into the things it crushes, while in Hexen it stays on position while dealing damage. And if the game is Doom, the special has "Dist" in the name and the speed is set to 8, it will also slow down to speed 1 when crushing.
  • 1: Doom mode without slowdown. Same as classic Doom's fast crushers.
  • 2: Hexen mode. It will rest in position while crushing.
  • 3: Doom mode with slowdown. Same as classic Doom's slow crushers. Currently the crushing speed is hardcoded to 1.

The specials are the following. Take care that Ceiling_CrushAndRaise is mainly for Hexen compatibility: it will rise at half the speed it lowers. For Doom-like crushers use Ceiling_CrushAndRaiseA (all "A" crushers let you specify the rising speed) or Ceiling_CrushAndRaiseDist (all "Dist" crushers rise at the same speed as they lower, but instead let you specify the gap size to the ground). Finally, Generic_Crusher aims to act like the Boom crushers, having the following particularities: it will slow down when crushing if speed is less than 24, and it will be totally silent if specified in the parameter (won't even make clunk noises).

  • 432: Ceiling_CrushAndRaise(tag, speed, damage, crushmode)
  • 439: Ceiling_CrushAndRaiseA(tag, down_speed, up_speed, damage, crushmode)
  • 440: Ceiling_CrushAndRaiseSilentA(tag, down_speed, up_speed, damage, crushmode)
  • 437: Ceiling_CrushAndRaiseDist(tag, ground_distance, speed, damage, crushmode)
  • 441: Ceiling_CrushAndRaiseSilentDist(tag, ground_distance, speed, damage, crushmode)
  • 434: Ceiling_CrushAndRaiseAndStay(tag, speed, damage, crushmode)
  • 438: Ceiling_CrushAndRaiseAndStayA(tag, down_speed, up_speed, damage, crushmode)
  • 442: Ceiling_CrushAndRaiseAndStaySilA(tag, down_speed, up_speed, damage, crushmode)
  • 435: Ceiling_LowerAndCrush(tag, speed, damage, crushmode)
  • 436: Ceiling_LowerAndCrushDist(tag, speed, damage, ground_distance, crushmode)
  • 433: Ceiling_CrushStop(tag)
  • 443: Generic_Crusher(tag, down_speed, up_speed, silent, damage)

Stair building

#    Function                            ExtraData Name 

340  Build stairs up, DOOM method        Stairs_BuildUpDoom
341  Build stairs down, DOOM method      Stairs_BuildDownDoom
342  Build stairs up sync*, DOOM method  Stairs_BuildUpDoomSync
343  Build stairs dn sync*, DOOM method  Stairs_BuildDownDoomSync 

* Synchronized stairs have each step move at a different speed so that all the
  steps reach the destination height at the same time. This stair building
  style is only available with these parameterized line types. 

Stairs_BuildUpDoom        tag, speed, stepsize, delay, reset
Stairs_BuildDownDoom      tag, speed, stepsize, delay, reset
Stairs_BuildUpDoomSync    tag, speed, stepsize, reset
Stairs_BuildDownDoomSync  tag, speed, stepsize, reset

tag       : Tag of first sector to raise or lower as a step.
            When the stair building method is DOOM, subsequent
            steps are found by searching across two-sided
            lines where the first side belongs to the current
            sector and the floor texture is the same. The
            Hexen stair building method is not yet supported.
speed     : Speed of steps in eights of a unit per tic. If the
            build style is synchronized, only the first step
            moves at this speed. Other steps will move at a
            speed which allows them to reach their 
            destination height at the same time.
stepsize  : Step size in units.
delay     : Delay time in tics between steps
reset     : If greater than zero, the stairs will wait this
            amount of time in tics after completely building
            and will then reset by repeating the same stair
            building action but in the reverse direction. If
            zero, the stairs will never reset.

PolyObject control

#    Function                            ExtraData Name 

348  Marks first line in PolyObject*     Polyobj_StartLine
349  Explicitly includes a line*         Polyobj_ExplicitLine
350  Open PolyObject as sliding door     Polyobj_DoorSlide
351  Open PolyObject as swinging door    Polyobj_DoorSwing
352  Move PolyObject in xy plane         Polyobj_Move
353  Move PolyObject w/override**        Polyobj_OR_Move
354  Rotate PolyObject right             Polyobj_RotateRight
355  Rotate PolyObject right w/override  Polyobj_OR_RotateRight
356  Rotate PolyObject left              Polyobj_RotateLeft
357  Rotate PolyObject left w/override   Polyobj_OR_RotateLeft 
474  Stop PolyObject***                  Polyobj_Stop

* There are two different methods of creating a PolyObject. In the first,
  the "first" line is given the Polyobj_StartLine special, and subsequent
  lines are added to the PolyObject by following segs from vertex to vertex.
  To use this, all the lines around the PolyObject must run in the same
  direction, and the last line must end at the same vertex which starts the
  first line (in other words, it must be closed).
  With the second method, every line to be included must be given the
  Polyobj_ExplicitLine special and must be given a linenum param which is
  unique amongst all lines that will added to that polyobject. Polyobjects
  of this sort should also be closed for proper rendering, but the game
  engine cannot and will not verify that this is the case.
  Only PolyObjects created with the Polyobj_StartLine method can have other
  line specials on the PolyObject's lines themselves. 

** Override types will take effect even if an action is already affecting the
  specified polyobject. Normal actions will fail in this case. 

*** This will stop a polyobject from its action, leaving it free for other movement.

Polyobj_StartLine       polyobj_id, mirror_id, sndseq_id
Polyobj_ExplicitLine    polyobj_id, linenum, mirror_id, sndseq_id
Polyobj_DoorSlide       polyobj_id, speed, angle, dist, delay
Polyobj_DoorSwing       polyobj_id, aspeed, adist, delay
Polyobj_Move            polyobj_id, speed, angle, dist
Polyobj_OR_Move         polyobj_id, speed, angle, dist
Polyobj_RotateRight     polyobj_id, aspeed, adist
Polyobj_OR_RotateRight  polyobj_id, aspeed, adist
Polyobj_RotateLeft      polyobj_id, aspeed, adist
Polyobj_OR_RotateLeft   polyobj_id, aspeed, adist 
Polyobj_Stop            polyobj_id

polyobj_id : ID number of the PolyObject of which this line is
             a part. PolyObject ID numbers are defined in the
             angle field of their EEPolyObjSpawnSpot object
             (DoomEd numbers 9301 or 9302). Every PolyObject
             must be given a valid unique ID number greater
             than zero.
mirror_id  : The ID number of a PolyObject that wants to mirror
             every action that this PolyObject makes. This
             number cannot refer to the self-same PolyObject,
             nor should PolyObjects attempt to mirror each
             other in a cycle since this will create problems
             with override actions. Angle of motion is always
             reversed when applying an action to a mirroring
             PolyObject. If a mirror is already in motion for
             a non-override action, the mirror will not be
             affected even if the main object was moved. Mirror
             polyobjects can themselves define a mirror, and
             an action will affect all mirroring polyobjects
             in the chain.
sndseq_id  : Selects the EDF sound sequence this
             PolyObject uses when moving.
linenum    : For Polyobj_ExplicitLine only, specifies the
             order in which lines should be added to the
             PolyObject. Each line must have a number greater
             than zero which is unique within all lines that
             belong to that PolyObject. Although, unlike Hexen,
             there is no requirement that the numbers be in
             consecutive order or that they start at 1.
speed      : Linear speed of PolyObject motion in eighths of a
             unit per tic.
angle      : Byte angle of linear motion. *
dist       : Total linear distance to move in units.
delay      : Time to wait before closing in tics.
aspeed     : Byte angle specifying speed in degrees per tic. *
adist      : Byte angle specifying total angular distance to
             rotate. *, **

* Byte angles follow this system:
    0 =   0 degrees (East)
   64 =  90 degrees (North)
  128 = 180 degrees (West)
  192 = 270 degrees (South)
  To convert from degrees to byte angles, use the following calculation:
  byteangle = (degrees * 256) / 360

  Chop or round the result to an integer.
  Valid byte angles fall between 0 and 255, so adjust any angles less than
  0 or greater than or equal to 360 before performing this conversion.
** For the adist parameter to Polyobj_Rotate-type specials (excluding
   Polyobj_DoorSwing), the values 0 and 255 have the following special
  0   == The PolyObject will rotate exactly 360 degrees.
  255 == The PolyObject will rotate perpetually.
  All other byte angle values have their normal meaning.

Pillar building

#    Function                            ExtraData Name

362  Build pillar                        Pillar_Build
363  Build pillar and crush              Pillar_BuildAndCrush
364  Open pillar                         Pillar_Open 

Pillar_Build                  tag, speed, height
Pillar_BuildAndCrush          tag, speed, height, crush
Pillar_Open                   tag, speed, fdist, cdist

tag       : Tag of sector to close or open as a pillar. For the
            action to succeed, neither surface may have an 
            action running on it already. If the tag is zero,
            the sector on the backside of a 2S line with this
            special will be used.
speed     : Speed of the surface with the greatest distance to
            move in eights of a unit per tic. The other surface
            will move at a speed which causes it to reach its
            destination at the same time.
height    : For Build and BuildAndCrush types, this is the 
            height relative to the floor where the floor and 
            ceiling should meet. If this value is zero, the 
            floor and ceiling will meet exactly half-way.
crush     : For BuildAndCrush type only, this specifies the 
            amount of damage to inflict per crush event.
fdist     : For Open type only, this is the distance the floor
            should move down. If this value is zero, the floor
            will move to its lowest neighboring floor.
cdist     : For Open type only, this is the distance the
            ceiling should move up. If this value is zero, the
            ceiling will move to its highest neighboring 

ACS Scripts

This part incorporates text from the open-content ZDoom Wiki

Eternity supports ACS script calling.

  • 365:ACS_Execute(scriptnum, mapnum, arg0, arg1, arg2)
Executes the specified script. A map value of zero indicates that the script is on the current map. If the script is on a different map, then the execution of the script will be delayed until the player enters the map that contains it. Only one copy of a script can be running at a time when started with this special.
If the specified script was previously executed but then suspended, then execution will begin at the point immediately after where it was suspended instead of starting over again at the beginning.
The number of usable arguments is limited to 3.
  • 366:ACS_Suspend(scriptnum, mapnum)
Suspends execution of a script until an ACS_Execute special resumes it.
  • 367:ACS_Terminate(scriptnum, mapnum)
Terminates the script.
  • 430:ACS_LockedExecute(scriptnum, mapnum, arg1, arg2, lock) (since Feb 25 2016)
This one executes a script that requires the player to have a key or more. See Lock identifiers for info on what to put for the lock argument.


Eternity supports the following light level controlling parameterized linedef specials. If tag is 0, any such parameterized special will affect the sector behind the linedef, if applicable.

  • 368:Light_RaiseByValue(tag, lvl)
Adds the lvl value to the light levels of tagged sectors, capping them to 255.
  • 369:Light_LowerByValue(tag, lvl)
Substracts the lvl value from the light levels of tagged sectors, limiting them to 0.
  • 370:Light_ChangeToValue(tag, lvl)
Sets the lvl value for the light level of tagged sectors, and caps it between 0 and 255 inclusive.
  • 371:Light_Fade(tag, destvalue, tics)
Makes the light level of tagged sectors gradually go to destvalue, for the given amount of tics. tics must be greater than 0.
  • 372:Light_Glow(tag, maxval, minval, tics)
Enables periodic glowing light effect on tagged sectors. tics is the duration between the extreme light levels and must be positive. The sequence starts by fading down.
  • 373:Light_Flicker(tag, maxval, minval)
Enables flickering light effect on tagged sectors.
  • 374:Light_Strobe(tag, maxval, minval, maxtime, mintime)
Enables strobing light effect on tagged sectors. Light will periodically flash, staying at maxval level for maxtime tics and at minval level for mintime tics.
  • 473:Light_MinNeighbor(tag)
Sets the lights in tagged sectors to their minimum neighbors' values


  • 398:Thing_Spawn(tid, type, angle)
Spawns an object of acs_spawndata num type on top of map spot things marked with TID tid. Note: teleportation fog is spawned as well.
  • 399:Thing_SpawnNoFog(tid, type, angle)
Similar to above, but without teleportation fog.
  • 402:Thing_Projectile(tid, type, angle, speed, verticalspeed)
Throws a projectile from a map spot. Can also be used to throw a flying monster. Like in Thing_Spawn, type is an acs_spawndata num. Note that speed and verticalspeed are in eighths (units per 8 tics). Up is positive for verticalspeed.
  • 403:Thing_ProjectileGravity(tid, type, angle, speed, verticalspeed)
Same as above, but the thrown projectile or monster will be subject to gravity.
  • 404:Thing_Activate(tid)
"Activates" an object of TID tid. The object will enter activestate while playing activatesound. If the object is a monster (SHOOTABLE or KILLABLE flag set), its DORMANT flag will be reset as well, "waking it up" from a statue.
  • 405:Thing_Deactivate(tid)
Analogous/opposite to the above, the object will enter inactivestate while playing deactivatesound. If the object is a monster (SHOOTABLE or KILLABLE flag set), its DORMANT flag will be set as well, turning it into a statue.
  • 421:Thing_ChangeTID(oldtid, newtid) (since Nov 14 2015)
Sets the TID of all things which currently have oldtid to the value newtid. If oldtid is zero, it will change the TID of the activator.
  • 422:Thing_Raise(tid) (since Feb 24 2016)
Resurrects all corpses having tid if they have room. They will retain their alignment (friend or foe) before their death. If tid is 0, it will resurrect the activator. Doesn't work on players.
  • 423:Thing_Stop(tid) (since Feb 24 2016)
Stops the movement of all things tagged tid. If tid is 0, it will stop the activator. It works by resetting velocity to 0, which means that it will work against players, projectiles and other thrusted objects. It will not "paralyze" monsters because they use a different kind of movement.
  • 424:ThrustThing(angle, speed, reserved, tid) (since Feb 24 2016)
Pushes the thing in a direction using the specified speed. If tid is 0 it will push the activator. The argument reserved must be 0 and is intended to be used when Eternity has a working high-speed movement system. If the map is made for vanilla Hexen, it will only be activated from the front side; otherwise it will depend on the 1SONLY ExtraData flag.
  • 425:ThrustThingZ(tid, speed, up_down, set_add) (since Feb 24 2016)
Pushes the things tagged tid vertically. The value from speed will be divided by 4 before being added to the thing's vertical speed. Up_down will cause the thing to be thrusted upwards if 0, downwards if 1. Set_add will cause the speed to override the current value if 0, or add to the current value if 1.
  • 426:DamageThing(damage, mod) (since Feb 24 2016)
Damages the activator. Mod is a means-of-death (damagetype), which can be used for custom obituaries and damage resistances. If damage is 0, it will actually do 10000 (gibbing) damage.
  • 427:Thing_Damage(tid, damage, mod) (since Feb 24 2016)
Same as DamageThing, but with the possibility to select TID (where 0 will mean the activator). It's done this way for ZDoom compatibility. Unlike DamageThing, it will not cause 10000 damage if damage is 0.
  • 428:Thing_Destroy(tid, reserved, sectortag) (since Feb 24 2016)
Causes 10000 damage to all things tagged tid. Beware that, in accordance to Hexen, tid 0 will NOT affect the activator; for that use DamageThing. Reserved must be set to 0. Sectortag can be used to only kill things inside sectors with given tag.
  • 469:HealThing(amount, maxhealth)
Heals the activator by amount. Maxhealth influences maximum health and only affects player activators. For monsters and other objects, the maximum health is always the spawn health. On players, maxhealth has the following meanings:
  • If 0, it will heal the player up to the initial health (such as the maximum medikit health in default Doom).
  • If 1, it will heal the player up to the soulsphere maximum health (in default Doom) or the initial health + 100 (if no soulsphere is defined in current game mode)
  • Otherwise, it will heal the player up to maxhealth.


  • 470:Sector_SetRotation(tag, floor_angle, ceiling_angle)
Sets the floor and ceiling texture rotation of tagged sectors to the given values in degrees (0-360).
  • 471:Sector_SetFloorPanning(tag, x_int, x_frac, y_int, y_frac)
Sets the floor texture panning of tagged sectors to given X and Y values. A value is calculated as x_int + 0.01 * x_frac.
  • 472:Sector_SetCeilingPanning(tag, x_int, x_frac, y_int, y_frac)
Same as Sector_SetFloorPanning, but for the ceiling texture.


  • 444:Teleport(tid, sector_tag, reserved)
Teleports the activator. Depending on whether tid or sector_tag is nonzero, the behavior will be Hexen or Doom compatible. If tid is zero, then it will teleport like in Doom, into the first teleport destination found on sectors tagged sector_tag.
If tid is non-zero, it will teleport to one random target thing (doesn't matter the type) among the ones tagged tid. If in this case sector_tag is also non-zero, it will only seek a destination thing located in these tagged sectors. This behavior is based on the Hexen teleporters.
  • 445:Teleport_NoFog(tid, use_angle, sector_tag, keep_height)
Teleports the activator silently, without fog and without holding it. Tid and sector_tag are used the same as in Teleport.
Use_angle sets how the activator angle should be set after teleportation, and can take one of the following values:
  • 0: default Hexen behavior. The thing won't change its angle at all during teleportation.
  • 1: set thing's angle to the same angle as the one of the destination spot
  • 2: use Boom's original, buggy behavior: shift angle opposite to that of the difference between destination spot's angle and the line normal's angle
  • 3: use Boom's supposedly intended behavior: shift angle by the difference between destination spot's angle and line normal's angle.
If use_angle is 2 or 3 and the special is not triggered from a linedef, then it will work like mode 1.
Keep_height: setting this to 1 will make the thing preserve its distance to the floor after teleporting. If it's 0, the thing will be teleported on the floor, like in Hexen.
  • 446:Teleport_Line(reserved, dest_id, flip)
Encapsulates the Boom line-teleporting functions. Dest_id is the tag of the target line. Flip will cause the user to rotate 180 degrees after teleporting.

Binary format specific

  • 378:Line_SetIdentification(id)
Sets the linedef identification number (separate from tag) to id. Useful for various specials that use the line id.


  • 400:Teleport_EndGame
Ends the game in victory.
  • 447:Exit_Normal(reserved)
Exits to a normal destination level. The argument is reserved and must be 0.
  • 448:Exit_Secret(reserved)
Exits to the secret destination level. The argument is reserved and must be 0.
  • 449:Teleport_NewMap(level_number, reserved, reserved)
Exits to the given map. The last two arguments are reserved and must be 0.