Brdoom wiki - Contribuições do usuário [pt-br]

Predefinição:STFeature

2026-03-19T19:25:49Z

MegaManx3: Criou página com '{| align=center border=0 cellpadding=4 cellspacing=4 style="border: solid 1px #a3b1bf; background-color: #cee0f2; padding: 0.4em 1em; width: 55%; margin: 1em auto; text-align: center;" |- | {{{image|link=}}} | '''Warning:''' This feature is Skulltag specific, and is not compatible with ZDoom! ''To see all of Skulltag's specific features, see Skulltag features.'' |} {{SkulltagColors}} <includeonly>Category:Sku...'

{| align=center border=0 cellpadding=4 cellspacing=4 style="border: solid 1px #a3b1bf; background-color: #cee0f2; padding: 0.4em 1em; width: 55%; margin: 1em auto; text-align: center;"
|-
| {{{image|[[File:SkulltagIcon.png|link=]]}}}
| '''Warning:''' This feature is [[Skulltag]] specific, and is not compatible with [[ZDoom]]! ''To see all of Skulltag's specific features, see [[Skulltag features]].''
|}
{{SkulltagColors}}
<includeonly>[[Category:Skulltag features]]</includeonly><noinclude>[[Category:Infobox templates]]</noinclude>

Player SetTeam

2026-03-19T19:25:15Z

MegaManx3: Criou página com '{{DISPLAYTITLE:Player_SetTeam}} {{STFeature}} '''145:Player_SetTeam (team)''' * ''team'': What team to set the player to. Sets the player's team. Usually used at the start of a CTF map in the team selection area. A valid team is anywhere between 0 and sv_maxteams (so 2, 3, 4). The teams are 0 = Blue, 1 = Red, 2 = Green, 3 = Gold. Using the current value of sv_maxteams removes the player from his current team without making him join another. ==Example== {{noexamples}}'

{{DISPLAYTITLE:Player_SetTeam}}
{{STFeature}}

'''145:Player_SetTeam (team)'''

* ''team'': What team to set the player to.

Sets the player's team. Usually used at the start of a CTF map in the team selection area. A valid team is anywhere between 0 and sv_maxteams (so 2, 3, 4). The teams are 0 = Blue, 1 = Red, 2 = Green, 3 = Gold. Using the current value of sv_maxteams removes the player from his current team without making him join another.

==Example==
{{noexamples}}

Line Horizon

2026-03-17T17:00:50Z

MegaManx3: Criou página com '{{DISPLAYTITLE:Line_Horizon}} {{Special|9|nenhum parâmetro necessário|Renderer|use=line}} Este special deve ser colocado em uma linha do mapa, que então é “estendida” ao infinito. Ele só cria uma visão infinita nessa linha específica, então talvez você precise colocá-lo em várias linhas para obter o efeito desejado. Útil para skyboxes. Não use com inclinações! == Exemplos == {{noexamples}} == Conversões a partir de tipos de li...'

{{DISPLAYTITLE:Line_Horizon}}
{{Special|9|nenhum parâmetro necessário|Renderer|use=line}}

Este special deve ser colocado em uma linha do mapa, que então é “estendida” ao infinito. Ele só cria uma visão infinita nessa linha específica, então talvez você precise colocá-lo em várias linhas para obter o efeito desejado. Útil para [[skybox|skyboxes]]. Não use com [[slopes|inclinações]]!

== Exemplos ==
{{noexamples}}

== Conversões a partir de tipos de linedef ==
Os seguintes tipos do formato Doom podem ser convertidos para Line Horizon:
{| {{prettytable}}
!Tipo!!Conversão!!Gatilho
|-
|{{icon|ZDoom}} 337:Line Horizon||Line_Horizon ()||
|-
|{{icon|Eternity}} 450:Line Horizon||Line_Horizon ()||
|}

== Links externos ==
* {{oldref}}

Arquivo:Poly06.png

2026-03-15T18:08:18Z

MegaManx3:

Arquivo:Poly05.png

2026-03-15T18:08:12Z

MegaManx3:

Arquivo:Poly04.png

2026-03-15T18:08:05Z

MegaManx3:

Arquivo:Poly03.png

2026-03-15T18:07:57Z

MegaManx3:

Arquivo:Poly02.png

2026-03-15T18:07:48Z

MegaManx3:

Arquivo:Poly01.png

2026-03-15T18:07:39Z

MegaManx3:

Polyobject

2026-03-15T18:05:16Z

MegaManx3: Criou página com '{{doomwiki|link=Polyobject|name=polyobject}}Como o uso de um {{dw|BSP}} pré-calculado para renderização força a geometria vertical do mapa a permanecer constante, é impossível mover uma estrutura nos eixos X e Y no vanilla Doom. O ZDoom resolve isso oferecendo '''PolyObjects'''. Um PolyObject normalmente consiste em um grupo de linhas unilaterais (one-sided) conectadas, contidas dentro de um único subsector. == Criando polyobjects simples == Fazer um polyobj...'

{{doomwiki|link=Polyobject|name=polyobject}}Como o uso de um {{dw|BSP}} pré-calculado para renderização força a geometria vertical do mapa a permanecer constante, é impossível mover uma estrutura nos eixos X e Y no [[vanilla Doom]]. O ZDoom resolve isso oferecendo '''PolyObjects'''. Um PolyObject normalmente consiste em um grupo de linhas unilaterais (one-sided) conectadas, contidas dentro de um único subsector.

== Criando polyobjects simples ==

Fazer um polyobject é bem simples, embora possa parecer difícil no começo. Depois que você pega o jeito, dá pra fazer vários rapidinho.

{|
|[[Image:Poly01.png|right]]||Primeiro precisamos do mapa em si. Vamos fazer uma porta deslizante como polyobject (provavelmente o tipo mais fácil), então vamos precisar de duas salas com teto a 192 e um corredor central (onde os polys vão aparecer) com teto a 128. Todos os pisos ficam na altura 0.
|-
|[[Image:Poly02.png|right]]||Depois você precisa construir os polyobjects. Eles devem ficar em um setor “dummy” ou em algum lugar inacessível, porque o espaço que eles ocupam no mapa normalmente ainda é considerado bloqueado, o que pode causar situações indesejadas — por exemplo, uma porta giratória que, ao abrir, deixa uma barreira invisível no lugar. Além disso, os setores de “armazenamento” serão automaticamente ocultados no [[automap]].

Note que os polyobjects são colunas “sólidas” de vazio, compostas apenas por linedefs de 1 lado (one-sided).

As linhas marcadas em amarelo devem ter o special <tt>[[Polyobj_StartLine]]</tt>, que recebe três argumentos: o número do polyobject, o polyobject espelhado (mirror) e o som que ele faz enquanto se move (definido em [[SNDSEQ]]). Para o poly de cima, use o número 0; e para o de baixo, use o número 1 (mas qualquer número serviria). Como esses polys vão espelhar um ao outro (as ações serão as mesmas, só que invertidas — por exemplo, o poly1 abre para a direita e o poly0 abre para a esquerda), você deve colocar o número do poly “oposto” no segundo campo. O som não é importante agora, então deixe 0.
|-
|[[Image:Poly03.png|right]]||Agora você precisa colocar as âncoras (polyobject anchors) e os start spots. Eles determinam onde os polyobjects realmente vão aparecer no mapa. Primeiro coloque as âncoras, que têm DoomEdNum 9300. Elas devem ficar dentro dos polyobjects do jeito que você desenhou no mapa (ou perto da borda), como na imagem. A coisa mais importante das âncoras é o ângulo, que deve corresponder ao número do polyobject. Então a âncora de cima tem ângulo 0 e a âncora de baixo tem ângulo 1.
|-
|[[Image:Poly04.png|right]]||Em seguida, coloque os start spots. Eles são colocados de forma parecida com as âncoras: em um local onde você quer que o polyobject apareça no jogo, relativo à âncora. Neste caso, colocamos a âncora no centro do poly, então queremos o start spot no centro de onde queremos que o poly apareça, como mostrado na imagem. Start spots têm DoomEdNum 9301, 9302 ou 9303:
:'''9301:''' Polyobject normal — ele aborta o movimento se colidir com um ator.
:'''9302:''' Polyobject “crush” — ele continua movendo e os atores no caminho são esmagados.
:'''9303:''' Polyobject “harmful” — ele causa dano ao toque mesmo antes do ator ser esmagado.
|-
|[[Image:poly05.png|right]]||Aqui temos a configuração completa. Note que desde o ZDoom 2.5.0, é possível ter geometria complexa para polyobjects e fazer eles se moverem para qualquer lugar do mapa. Versões anteriores tinham limitações rígidas sobre o que um polyobject podia ser e fazer. Como este exemplo já é antigo, ele mostra uma configuração bem simples.
|-
|[[Image:Poly06.png|right]]||Por fim, você provavelmente quer que os polyobjects realmente abram. Isso é bem simples: dê às “laterais largas” dos polyobjects o special <tt>[[Polyobj_DoorSlide]]</tt>, com os argumentos 0, 32, 128, 64, 105 — que são: número do polyobject, velocidade do movimento, [[angle|ângulo]], distância a mover e o atraso antes dos polys voltarem à posição original (em [[tic]]s; 105 são 3 segundos, pois são 35 tics por segundo). Você não precisa se preocupar com o polyobject 1 neste caso, porque ele vai espelhar tudo o que o polyobject 0 fizer. Pronto — terminou!
|}

* [[:Image:Polyexample.zip|Baixar o WAD de exemplo (729 bytes)]]

== Criando polyobjects avançados ==
Embora os polyobjects simples acima sejam suficientes na maioria dos casos, às vezes não dá. Por exemplo: e se você quiser um polyobject “vazado/see-through”? Nesse caso, você vai precisar usar linedefs de dois lados (two-sided). Porém, o engine não consegue criar o polyobject automaticamente nesses casos, então você precisa usar [[Polyobj_ExplicitLine]] em cada linha do polyobject.

# Construa seu polyobject em um setor de “armazenamento” como antes, mas transforme-o em um setor autorreferente (os dois lados do polyobject pertencem ao setor de armazenamento).
# Cada linha do polyobject deve ser marcada com Polyobj_ExplicitLine. Para a ordem de renderização, você pode usar o valor 1 em todas elas, já que esse parâmetro é um resquício da implementação original do ''[[Hexen]]''.
# Se você quiser que algumas linhas do polyobject sejam ativáveis, você precisa dar um lineid a elas. No [[Hexen format]], isso é feito por um dos parâmetros do Polyobj_ExplicitLine; no [[UDMF]] isso é uma das propriedades do [[linedef]]. Depois, você vai precisar de um script [[OPEN]] em [[ACS]] chamando [[SetLineSpecial]] no lineid escolhido para atribuir um special diferente.
# Como o polyobject agora é two-sided, garanta que ele realmente tenha uma textura no middle!
# O setor de armazenamento deve ter as mesmas alturas de piso e teto do setor de destino — não porque o engine exija, mas porque isso facilita MUITO ajustar os offsets verticais das texturas do polyobject. Use o flag “lower unpegged” se você quer que o polyobject encoste no chão.
# Dê às linhas do polyobject o flag de "[[3D middle texture]]" para que ele tenha uma caixa de colisão vertical finita. Note que o setor de armazenamento do polyobject será usado como referência para checar se há espaço acima/abaixo dele, e não o setor onde ele realmente está!

== Personalizando o dano de polyobjects ==
[[Image:Polyobject Damage.png|500px|right]]
Para mudar o dano exato que polyobjects do tipo “crushing” e “hurts-to-touch” causam a cada toque em um ator, você precisa (no [[Ultimate Doom Builder]] ou no [[Doom_Builder#GZDB-Bugfix|GZDoom Builder (Bugfix)]]) ir na aba Action/Tag/Misc das coisas âncora (anchors) e alterar o valor de health das âncoras — do mesmo jeito que polyobjects são ligados entre si usando o ângulo do start spot e das âncoras.

O health padrão 1 significa que o polyobject usa o dano padrão dele, que é 3. Qualquer valor acima de 1 mata instantaneamente qualquer coisa no caminho. E valores negativos definem o dano exato que o polyobject causa em cada impacto. Por exemplo, health = -10 causa 10 de dano por hit em vez de 3.

== Veja também ==
* [[Tutorials]]

Para specials relacionados a PolyObjects, veja:
* [[Polyobj_DoorSlide]]
* [[Polyobj_DoorSwing]]
* [[Polyobj_ExplicitLine]]
* [[Polyobj_Move]]
* [[Polyobj_MoveTimes8]]
* [[Polyobj_MoveTo]]
* [[Polyobj_MoveToSpot]]
* [[Polyobj_OR_Move]]
* [[Polyobj_OR_MoveTimes8]]
* [[Polyobj_OR_MoveTo]]
* [[Polyobj_OR_MoveToSpot]]
* [[Polyobj_OR_RotateLeft]]
* [[Polyobj_OR_RotateRight]]
* [[Polyobj_RotateLeft]]
* [[Polyobj_RotateRight]]
* [[Polyobj_StartLine]]
* [[Polyobj_Stop]]
* [[GetPolyobjX]]
* [[GetPolyobjY]]

Para scripting com PolyObjects:
* [[PolyWait]]

[[Category:Features]][[Category:Glossary]][[Category:Guides]]

Polyobj DoorSlide

2026-03-15T18:03:45Z

MegaManx3: Criou página com '{{DISPLAYTITLE:Polyobj_DoorSlide}} {{Special|8|po, speed, angle, dist, delay|Polyobject|DoorSlide}} Move um polyobject, espera e então o move de volta para sua posição original. * ''po'': polyobject a ser movido * ''speed'': quão rápido mover o polyobject * ''angle'': direção para mover o polyobject (isto é um ângulo em byte) * ''dist'': distância para mover o polyobject * ''delay'': atraso em tics antes de retornar à posiçã...'

{{DISPLAYTITLE:Polyobj_DoorSlide}}
{{Special|8|po, speed, angle, dist, delay|Polyobject|DoorSlide}}

Move um [[polyobject]], espera e então o move de volta para sua posição original.

* ''po'': polyobject a ser movido
* ''speed'': quão rápido mover o polyobject
* ''angle'': direção para mover o polyobject (isto é um [[Definitions#Byte_Angles|ângulo em byte]])
* ''dist'': distância para mover o polyobject
* ''delay'': atraso em tics antes de retornar à posição original

== Exemplos ==
* [https://www.mediafire.com/file/4cx4x5xkxdp9d7h/PolySLIDE_2.wad Mapa de exemplo: abre uma porta em 2 partes com atraso de fechamento quase infinito]

== Veja também ==
[[PolyObjects]]

Polyobj DoorSwing

2026-03-15T17:50:49Z

MegaManx3: Criou página com '{{DISPLAYTITLE:Polyobj_DoorSwing}} {{Special|7|po, speed, angle, delay|Polyobject|DoorSwing}} Gira (rotaciona) um polyobject, espera, e então o gira na direção oposta até ele voltar à orientação original. * ''po'': polyobj a ser movido * ''speed'': quão rápido o polyobj deve girar * ''angle'': ângulo em byte pelo qual o polyobj será rotacionado * ''delay'': atraso em tics antes de retornar à orientação original Por padrão, o...'

{{DISPLAYTITLE:Polyobj_DoorSwing}}
{{Special|7|po, speed, angle, delay|Polyobject|DoorSwing}}

Gira (rotaciona) um polyobject, espera, e então o gira na direção oposta até ele voltar à orientação original.

* ''po'': polyobj a ser movido
* ''speed'': quão rápido o polyobj deve girar
* ''angle'': [[Definitions#Byte_angles|ângulo em byte]] pelo qual o polyobj será rotacionado
* ''delay'': atraso em tics antes de retornar à orientação original

Por padrão, o polyobj gira no sentido anti-horário.

Usando esta função em ACS, ou ao usar [[Universal Doom Map Format|UDMF]], você pode inverter essa direção fornecendo um valor negativo no parâmetro ''speed''.

== Veja também ==
[[PolyObjects]]

== Links externos ==
* [http://www.mediafire.com/file/aja3dqqwwgfrkia/poly-swing.WAD/file Mapa de exemplo po_swing usando o formato Doom:Hexen]
* [https://www.mediafire.com/file/xlsrd0yplsyr5js/U_poly-swing.WAD/file Mapa de exemplo U_poly-swing usando Doom:UDMF]

Polyobj MoveTimes8

2026-03-15T17:50:03Z

MegaManx3: Criou página com '{{DISPLAYTITLE:Polyobj_MoveTimes8}} {{Special|6:|po, speed, angle, dist|Polyobject|MoveTimes8}} Move um polyobject por (''dist'' * 8) unidades. * ''po'': polyobj a ser movido * ''speed'': quão rapidamente o polyobj deve se mover * ''angle'': direção em que o polyobj deve se mover (este é um ângulo em byte) * ''dist'': distância a mover, em unidades de 8 ==Veja também== * Polyobj_OR_MoveTimes8 * PolyObjects'

{{DISPLAYTITLE:Polyobj_MoveTimes8}}
{{Special|6:|po, speed, angle, dist|Polyobject|MoveTimes8}}

Move um polyobject por (''dist'' * 8) unidades.

* ''po'': polyobj a ser movido
* ''speed'': quão rapidamente o polyobj deve se mover
* ''angle'': direção em que o polyobj deve se mover (este é um [[Definitions#Byte_Angles|ângulo em byte]])
* ''dist'': distância a mover, em unidades de 8

==Veja também==

* [[Polyobj_OR_MoveTimes8]]
* [[PolyObjects]]

Polyobj ExplicitLine

2026-03-15T17:44:46Z

MegaManx3: Criou página com '{{DISPLAYTITLE:Polyobj_ExplicitLine}} {{Special|5|po, order, mirror, sound, lineid|Polyobject|ExplicitLine|use=line}} {{warning|text=Este special não é totalmente suportado pelo formato de mapa UDMF. Certos parâmetros, observados abaixo, tornaram-se obsoletos pela capacidade de especificar propriedades diretamente na estrutura do linedef. Esses parâmetros devem ser definidos como 0 ao usar o formato UDMF.}} Inclui explicitamente um linedef como parte de um poly...'

{{DISPLAYTITLE:Polyobj_ExplicitLine}}
{{Special|5|po, order, mirror, sound, lineid|Polyobject|ExplicitLine|use=line}}

{{warning|text=Este special não é totalmente suportado pelo formato de mapa [[UDMF]]. Certos parâmetros, observados abaixo, tornaram-se obsoletos pela capacidade de especificar propriedades diretamente na estrutura do linedef. Esses parâmetros devem ser definidos como 0 ao usar o formato UDMF.}}

Inclui explicitamente um linedef como parte de um polyobject.

* ''po'': polyobj que está sendo definido
* ''order'': ordem de renderização deste linedef
* ''mirror'': polyobj que irá espelhar os movimentos deste
* ''sound'': [[sound sequence|sequência de som]] de porta a tocar quando este polyobj se mover
* ''lineid'': também define o id deste linedef se não for zero. ''Obsoleto em UDMF.''

== Veja também ==
[[PolyObjects]]

== Links externos ==
*[https://www.mediafire.com/file/5rtpq9b89s8q4eh/po_ex_door_example2b.wad/file Mapa de exemplo]

Polyobj RotateRight

2026-03-15T17:34:45Z

MegaManx3: Criou página com '{{DISPLAYTITLE:Polyobj_RotateRight}} {{special|3|po, speed, angle|Polyobject|RotateRight}} Gira um polyobject para a direita pelo ângulo especificado. Se ''angle'' for 255, então o polyobject irá girar continuamente e nunca vai parar. * ''po'': polyobj a ser girado * ''speed'': quão rápido o polyobj deve girar * ''angle'': ângulo em byte pelo qual o polyobj deve girar ==Veja também== * Polyobj_RotateLeft * Polyobj_OR_Rota...'

{{DISPLAYTITLE:Polyobj_RotateRight}}
{{special|3|po, speed, angle|Polyobject|RotateRight}}

Gira um [[polyobject]] para a direita pelo ângulo especificado. Se ''angle'' for 255, então o polyobject irá girar continuamente e nunca vai parar.

* ''po'': polyobj a ser girado
* ''speed'': quão rápido o polyobj deve girar
* ''angle'': [[Definitions#Byte_Angles|ângulo em byte]] pelo qual o polyobj deve girar

==Veja também==

* [[Polyobj_RotateLeft]]
* [[Polyobj_OR_RotateRight]]
* [[PolyObjects]]

== Links externos ==
*[http://www.mediafire.com/download/9d8bbwakmdco4ub/poly-rotate.WAD Mapa de exemplo]

Pow

2026-03-08T19:41:33Z

MegaManx3: Criou página com 'Esta função calcula a potência n-ésima de x.<pre> function int pow (int x, int n) { int y = 1; while (n-- > 0) y *= x; return y; } </pre>'

Esta função calcula a potência n-ésima de x.<pre>
function int pow (int x, int n)
{
int y = 1;
while (n-- > 0) y *= x;
return y;
}
</pre>

Fixed floor

2026-03-08T19:35:05Z

MegaManx3:

Mapeia um valor em ponto fixo para o número inteiro anterior.
<pre>
function int floor (int x)
{
return x & 0xFFFF0000;
}
</pre>

[[category:Sample ACS functions]]

Fixed floor

2026-03-08T19:27:22Z

MegaManx3: Criou página com 'Map a fixed point value to the previous whole number. <pre> function int floor (int x) { return x & 0xFFFF0000; } </pre> category:Sample ACS functions'

Map a fixed point value to the previous whole number.
<pre>
function int floor (int x)
{
return x & 0xFFFF0000;
}
</pre>

[[category:Sample ACS functions]]

Abs

2026-03-08T19:26:26Z

MegaManx3: Criou página com '{{DISPLAYTITLE:abs}} This function can be used to return the absolute value of a negative integer. <pre> function int abs (int x) { if (x < 0) return -x; return x; } </pre> category:Sample ACS functions'

{{DISPLAYTITLE:abs}}
This function can be used to return the absolute value of a negative integer.
<pre>
function int abs (int x)
{
if (x < 0)
return -x;

return x;
}
</pre>

[[category:Sample ACS functions]]

Other useful functions

2026-03-08T19:25:50Z

MegaManx3: Criou página com '* abs * floor * ceil * pow * sqrt * round * logN * min and max * printsprite * distance * getspawnid * spawnradius * gettargetangle * gettargetpitch * acs_terminaterange * hudmessagetime * syncspeed * getaspectratio * hudmessageonactor * adjustedhudwidth * rad2deg * deg2rad Category:ACS'

* [[abs]]
* [[fixed_floor|floor]]
* [[ceil]]
* [[pow]]
* [[sqrt]]
* [[round]]
* [[logN]]
* [[min and max]]
* [[printsprite]]
* [[distance]]
* [[getspawnid]]
* [[spawnradius]]
* [[gettargetangle]]
* [[gettargetpitch]]
* [[acs_terminaterange]]
* [[hudmessagetime]]
* [[syncspeed]]
* [[getaspectratio]]
* [[hudmessageonactor]]
* [[adjustedhudwidth]]
* [[rad2deg]]
* [[deg2rad]]
[[Category:ACS]]

Libraries

2026-03-08T17:22:58Z

MegaManx3: Criou página com 'Uma '''biblioteca''' é um script ACS independente que define scripts, funções e constantes comuns, que podem ser usados por outros scripts ACS. Ela é diferente das diretivas padrão '''#include''' do ACS porque o arquivo incluído **não é compilado dentro** do binário final resultante. Usar bibliotecas pode ajudar a economizar espaço nos seus scripts (útil se você usa um editor de scripts com limite de tamanho, como o WadA...'

Uma '''biblioteca''' é um script [[ACS]] independente que define [[scripts]], [[functions|funções]] e [[constants|constantes]] comuns, que podem ser usados por outros scripts ACS.
Ela é diferente das diretivas padrão '''#include''' do ACS porque o arquivo incluído **não é compilado dentro** do binário final resultante.

Usar bibliotecas pode ajudar a economizar espaço nos seus scripts (útil se você usa um editor de scripts com limite de tamanho, como o [[WadAuthor]]), além de reduzir duplicação de código e erros de copy-paste.
Quaisquer mudanças nas bibliotecas serão refletidas automaticamente em todos os scripts que as utilizam.

O uso mais comum de bibliotecas é em projetos grandes, onde múltiplos mapas compartilham ACS, e também em mods auxiliares de gameplay que incluem seu próprio ACS via [[LOADACS]].

== Criando bibliotecas ==
Um script ACS normal é marcado como biblioteca usando a diretiva '''#library''', que deve ser a primeira instrução no arquivo:

#library "LIBNAME"
#include "zcommon.acs"

O nome passado para a diretiva '''#library''' especifica o nome da biblioteca, limitado pelas regras padrão de nomes de lumps em WAD.
Depois de [[ACC|compilado]], o lump binário deve ser colocado no [[namespace|namespace]] de bibliotecas ACS com o mesmo nome usado na diretiva '''#library'''.
Editores modernos de recursos, como o [[SLADE 3]], conseguem automatizar esse processo.

'''Nota:''' ao usar [[LOADACS]], scripts {{SType|enter}} e {{SType|open}} dentro da sua biblioteca serão executados em **todo** mapa (seguindo as regras de cada tipo de script).

== Importando bibliotecas ==
Scripts podem importar bibliotecas usando a diretiva '''#import''':

#import "libname.acs"

O caminho passado em '''#import''' especifica o fonte ''não compilado'' da biblioteca (e não o binário compilado). O caminho pode ser absoluto ou relativo (por exemplo, "/doom/levels/mymaps/foomap/lumps/lib/foolib.acs").
Os seguintes elementos são importados da biblioteca:

* [[Scripts]], tanto [[named script|nomeados]] quanto numerados (em caso de conflito número/nome, o que for carregado por último é usado {{verification}})
* [[Functions|Funções]]
* [[Constants|Constantes]] declaradas com a diretiva '''#libdefine'''

'''Nota:''' quando o [[ACC]] varre bibliotecas importadas, todas as diretivas '''#include''' dentro da biblioteca são ignoradas e esses arquivos não são varridos.

== Exemplo ==
Abaixo há um exemplo curto e (espero) simples: uma biblioteca de objetivos de fase. Eu comentei mais do que normalmente comentaria, e isso assume que você já tem conhecimento básico de ACS (como [[loops|loops]], if, [[HudMessage]], #define, funções, [[arrays|arrays]] e variáveis). Se você não tiver, não fique tentando “quebrar a cabeça” com isso (e, se você não conhece essas coisas, provavelmente ainda não deveria estar usando bibliotecas).

//foolib.acs, o arquivo texto do script (biblioteca)
#library "foolib"
#include "zcommon.acs"

#define MAX_OBJECTIVES 4 // número máximo de objetivos por mapa

// este array guarda os objetivos; ele é alterado cada vez que você entra em um novo mapa
world str 0:objectives[];

// esta função é chamada pelo script 999 (veja abaixo)
function void printobjs(void)
{
[[HudMessage]](s:"Objectives\n\n";
{{const|HUDMSG_PLAIN}} | {{const|HUDMSG_LOG}}, 0, {{const|CR_RED}}, 0.0, 0.0, 5.0 );

// imprime cada objetivo
for(int x = 0; x < MAX_OBJECTIVES; x++)
{
[[HudMessage]](s:objectives[x];
{{const|HUDMSG_PLAIN}} | {{const|HUDMSG_LOG}}, 0, {{const|CR_WHITE}}, 0.0, (x * 0.1) + 0.1, 5.0);
}
}

// Este script roda toda vez que você entra em um novo mapa, mostrando os
// objetivos de missão daquele mapa. Se você quiser que o jogador consiga
// ver os objetivos depois que eles sumirem, você precisa configurar um alias
// para “puke 999” em um lump [[KEYCONF]].
script 999 {{SType|Enter}}
{
printobjs();
[[delay]](35 * 5); // atraso de cinco segundos
// note que delays não podem ser colocados em funções, por isso aparece aqui
}

-----

// este é um lump SCRIPTS para o map01
#import "foolib.acs"
#include "zcommon.acs"

script 100 {{SType|Open}}
{
objectives[0] = "Find the shotgun";
objectives[1] = "Get the blue key";
objectives[2] = "Destroy the computer";
objectives[3] = "Escape from the complex";
}

// Depois você coloca aqui embaixo os scripts que precisar para o mapa.
// Se quiser, ao completar um objetivo você pode alterar a cor do objetivo
// completado, para o jogador saber que concluiu. Por exemplo: o HudMessage
// imprime tudo em branco; então o script abaixo roda quando você completa
// o primeiro objetivo (objectives[0]).

script 1 (void)
{
objectives[0] = "\cFFind the shotgun";
// o \cF no começo da string muda a cor para amarelo (ou dourado)
}

-----

// este é um lump SCRIPTS para o map02
#import "foolib.acs"
#include "zcommon.acs"

script 100 {{SType|Open}}
{
objectives[0] = "Kill some imps";
objectives[1] = "Eat a cheeseburger";
objectives[2] = "Find a BFG";
objectives[3] = "";
// se você não quer que um objetivo apareça, deixe como string vazia
}

Note que este exemplo armazena cada objetivo nos scripts do mapa; você poderia armazenar na biblioteca, mas aí precisaria que os scripts de saída do mapa anotassem para qual mapa você está indo (não é difícil) e então selecionassem o array apropriado na biblioteca ao imprimir os objetivos.
[[Category:ACS]][[Category:Glossary]]

Doom Builder ACS Configuration

2026-03-08T17:09:43Z

MegaManx3: Criou página com 'A '''Configuração ACS do Doom Builder''' é a configuração que o Doom Builder usa no editor de scripts para fornecer realce de sintaxe e autocompletar com CTRL+SPACE. Ela existe aqui na wiki do ZDoom para que possa ser mantida atualizada da mesma forma que a documentação. Novas versões do Doom Builder usarão isto como fonte para o arquivo de configuração ACS e, quando possível, até para o arquivo de configuração de jogo do ZDoom. Note que esta é a...'

A '''Configuração ACS do Doom Builder''' é a configuração que o [[Doom Builder]] usa no editor de scripts para fornecer realce de sintaxe e autocompletar com CTRL+SPACE. Ela existe aqui na wiki do ZDoom para que possa ser mantida atualizada da mesma forma que a documentação. Novas versões do [[Doom Builder]] usarão isto como fonte para o arquivo de configuração ACS e, quando possível, até para o arquivo de configuração de jogo do ZDoom.

Note que esta é a configuração de scripts para o Doom Builder 1. Para usar esta lista no Doom Builder 2, você precisará modificar as configurações no topo (veja o ZDoom_ACS.cfg do Doom Builder 2 como exemplo).

== Diretrizes de atualização ==

Use estas diretrizes ao atualizar esta configuração, para que dê menos trabalho converter esta página em um arquivo acs.cfg do Doom Builder.

* Sempre use MixedCase para nomes de funções, exatamente como o ACS define. '''Não''' force para UPPERCASE ou lowercase; isso pode ser feito no Doom Builder se necessário.
* Sempre use lowercase para os argumentos das funções.
* Cada linha deve ficar assim: FunctionName = "FunctionName(argument, argument,...)";
* Depois da vírgula entre argumentos, adicione um espaço. (fica mais legível)
* Não deixe espaços *dentro* dos argumentos.
** Errado: FunctionName = "FunctionName(first id, second id)";
** Certo: FunctionName = "FunctionName(first, second)";
* Tente manter um pouco em ordem alfabética para conseguirmos achar uma função facilmente ao procurar aqui. Porém, o Doom Builder não se importa com isso.
* Adicione um espaço no início de cada linha para que ela fique formatada em monospace.

== A configuração ==
<pre>
/*******************************************************************\
Doom Builder Script highlighting definitions for ACS
\*******************************************************************/

type = "Doom Builder Script Configuration";

casesensitive = 0;
insertcase = 0; // 0=Normal, 1=Lowercase, 2=Uppercase
linecomment = "//";
commentopen = "/*";
commentclose = "*/";
string = "\"";
escape = "\\";
terminator = ";";
scopeopen = "{";
scopeclose = "}";
delimiters = " \n\r\t(){}[]:;!%^&*-+=.,<>/\?|\"";
functionopen = "(";
functionclose = ")";
argumentdelimiter = ",";
keywordhelp = "http://www.zdoom.org/wiki/index.php?title=%K";

keywords
{
#Define = "#Define identifier expression";
#EncryptStrings = "#EncryptStrings";
#Import = "#Import";
#Include = "#Include";
#LibDefine = "#LibDefine identifier expression";
#Library = "#Library";
#NoCompact = "#NoCompact";
#NoWadAuthor = "#NoWadAuthor";
#WadAuthor = "#WadAuthor";
#region = "#region block";
#endregion = "end of #region block";
ACS_Execute = "ACS_Execute(script, map, arg1, arg2, arg3)";
ACS_ExecuteAlways = "ACS_ExecuteAlways(script, map, arg1, arg2, arg3)";
ACS_ExecuteWait = "ACS_ExecuteWait(script, unused, arg1, arg2, arg3)";
ACS_ExecuteWithResult = "ACS_ExecuteWithResult(script, arg1, arg2, arg3, arg4)";
ACS_LockedExecute = "ACS_LockedExecute(script, map, arg1, arg2, lock)";
ACS_LockedExecuteDoor = "ACS_LockedExecuteDoor(script, map, arg1, arg2, lock)";
ACS_NamedExecute = "ACS_NamedExecute(script, map, arg1, arg2, arg3)";
ACS_NamedExecuteAlways = "ACS_NamedExecuteAlways(script, map, arg1, arg2, arg3)";
ACS_NamedExecuteWait = "ACS_NamedExecuteWait(script, unused, arg1, arg2, arg3)";
ACS_NamedExecuteWithResult = "ACS_NamedExecuteWithResult(script, arg1, arg2, arg3, arg4)";
ACS_NamedLockedExecute = "ACS_NamedLockedExecute(script, map, arg1, arg2, lock)";
ACS_NamedLockedExecuteDoor = "ACS_NamedLockedExecuteDoor(script, map, arg1, arg2, lock)";
ACS_NamedSuspend = "ACS_NamedSuspend(script, map)";
ACS_NamedTerminate = "ACS_NamedTerminate(script, map)";
ACS_Suspend = "ACS_Suspend(script, map)";
ACS_Terminate = "ACS_Terminate(script, map)";
ActivatorSound = "ActivatorSound(sound, volume)";
ActivatorTID = "ActivatorTID()";
AmbientSound = "AmbientSound(sound, volume)";
AnnouncerSound = "AnnouncerSound(sound, flags)";
Autosave = "Autosave()";
BeginDBTransaction = "BeginDBTransaction()";
BlueCount = "BlueCount()";
BlueReturn = "Script expression BlueReturn";
BlueScore = "BlueScore()";
BlueTeamCount = "BlueTeamCount()";
BlueTeamScore = "BlueTeamScore()";
Bool = "Bool expression";
Break = "Break";
CancelFade = "CancelFade()";
CanRaiseActor = "CanRaiseActor(tid)";
Case = "Case expression:";
Ceil = "Ceil(value)";
Ceiling_CrushAndRaise = "Ceiling_CrushAndRaise(tag, speed, crush, crushmode)";
Ceiling_CrushAndRaiseA = "Ceiling_CrushAndRaiseA(tag, dspeed, uspeed, crush, crushmode)";
Ceiling_CrushAndRaiseDist = "Ceiling_CrushAndRaiseDist(tag, dist, speed, damage, crushmode)";
Ceiling_CrushAndRaiseSilentA = "Ceiling_CrushAndRaiseSilentA(tag, dspeed, uspeed, crush, crushmode)";
Ceiling_CrushAndRaiseSilentDist = "Ceiling_CrushAndRaiseSilentDist(tag, dist, speed, damage, crushmode)";
Ceiling_CrushRaiseAndStay = "Ceiling_CrushRaiseAndStay(tag, speed, crush, crushmode)";
Ceiling_CrushRaiseAndStayA = "Ceiling_CrushRaiseAndStayA(tag, dspeed, uspeed, crush, crushmode)";
Ceiling_CrushRaiseAndStaySilA = "Ceiling_CrushRaiseAndStaySilA(tag, dspeed, uspeed, crush, crushmode)";
Ceiling_CrushStop = "Ceiling_CrushStop(tag)";
Ceiling_LowerAndCrush = "Ceiling_LowerAndCrush(tag, speed, crush, crushmode)";
Ceiling_LowerAndCrushDist = "Ceiling_LowerAndCrushDist(tag, speed, crush, dist, crushmode)";
Ceiling_LowerByTexture = "Ceiling_LowerByTexture(tag, speed, change, crush)";
Ceiling_LowerByValue = "Ceiling_LowerByValue(tag, speed, height)";
Ceiling_LowerByValueTimes8 = "Ceiling_LowerByValueTimes8(tag, speed, height)";
Ceiling_LowerInstant = "Ceiling_LowerInstant(tag, unused, height)";
Ceiling_LowerToFloor = "Ceiling_LowerToFloor(tag, speed)";
Ceiling_LowerToHighestFloor = "Ceiling_LowerToHighestFloor(tag, speed)";
Ceiling_LowerToLowest = "Ceiling_LowerToLowest(tag, speed)";
Ceiling_LowerToNearest = "Ceiling_LowerToNearest(tag, speed, change, crush)";
Ceiling_MoveToValue = "Ceiling_MoveToValue(tag, speed, height, neg)";
Ceiling_MoveToValueAndCrush = "Ceiling_MoveToValueAndCrush(tag, speed, height, crush, crushmode)";
Ceiling_MoveToValueTimes8 = "Ceiling_MoveToValueTimes8(tag, speed, height, neg)";
Ceiling_RaiseByTexture = "Ceiling_RaiseByTexture(tag, speed, change)";
Ceiling_RaiseByValue = "Ceiling_RaiseByValue(tag, speed, height)";
Ceiling_RaiseByValueTimes8 = "Ceiling_RaiseByValueTimes8(tag, speed, height)";
Ceiling_RaiseInstant = "Ceiling_RaiseInstant(tag, unused, height)";
Ceiling_RaiseToHighest = "Ceiling_RaiseToHighest(tag, speed, change)";
Ceiling_RaiseToHighestFloor = "Ceiling_RaiseToHighestFloor(tag, speed, change)";
Ceiling_RaiseToLowest = "Ceiling_RaiseToLowest(tag, speed, change)";
Ceiling_RaiseToNearest = "Ceiling_RaiseToNearest(tag, speed)";
Ceiling_Stop = "Ceiling_Stop(tag)";
Ceiling_ToFloorInstant = "Ceiling_ToFloorInstant(tag, change, crush, gap)";
Ceiling_ToHighestInstant = "Ceiling_ToHighestInstant(tag, change, crush)";
Ceiling_Waggle = "Ceiling_Waggle(tag, amp, freq, offset, time)";
ChangeActorAngle = "ChangeActorAngle(tid, angle, interpolate)";
ChangeActorPitch = "ChangeActorPitch(tid, pitch, interpolate)";
ChangeActorRoll = "ChangeActorRoll(tid, angle, interpolate)";
ChangeCamera = "ChangeCamera(tid, who, revert)";
ChangeCeiling = "ChangeCeiling(tag, flat)";
ChangeFloor = "ChangeFloor(tag, flat)";
ChangeLevel = "ChangeLevel(mapname, position, flags, skill)";
ChangeSkill = "ChangeSkill(skill)";
ChangeSky = "ChangeSky(sky1, sky2)";
CheckActorCeilingTexture = "CheckActorCeilingTexture(tid, texture)";
CheckActorClass = "CheckActorClass(tid, class)";
CheckActorFloorTexture = "CheckActorFloorTexture(tid, texture)";
CheckActorInventory = "CheckActorInventory(tid, inventoryitem)";
CheckActorProperty = "CheckActorProperty(tid, property, value)";
CheckActorState = "CheckActorState(tid, statename, exact)";
CheckClass = "CheckClass(classname)";
CheckFlag = "CheckFlag(tid, flag)";
CheckFont = "CheckFont(fontname)";
CheckInventory = "CheckInventory(inventoryitem)";
CheckPlayerCamera = "CheckPlayerCamera(player)";
CheckProximity = "CheckProximity(tid, classname, distance, count, flags, pointer)";
CheckSight = "CheckSight(source, dest, flags)";
CheckWeapon = "CheckWeapon(weapon)";
ClassifyActor = "ClassifyActor(tid)";
ClearActorInventory = "ClearActorInventory(tid)";
ClearForceField = "ClearForceField(tag)";
ClearInventory = "ClearInventory()";
ClearLineSpecial = "ClearLineSpecial()";
ConsoleCommand = "ConsoleCommand(command)";
ConsolePlayerNumber = "ConsolePlayerNumber()";
Const = "Const";
Continue = "Continue";
cos = "cos(angle)";
CountDBResults = "CountDBResults(results)";
CreateTranslation = "CreateTranslation(transnumber, translation, translation, translation, ...)";
DamageActor = "DamageActor(target_tid, target_pointer, inflictor_tid, inflictor_pointer, amount, damagetype)";
DamageThing = "DamageThing(amount, mod)";
Death = "Script expression Death";
Default = "Default:";
Delay = "Delay(tics)";
Disconnect = "Script expression Disconnect";
Do = "Do";
Door_Animated = "Door_Animated(tag, speed, delay, lock)";
Door_AnimatedClose = "Door_AnimatedClose(tag, speed)";
Door_Close = "Door_Close(tag, speed, lighttag)";
Door_CloseWaitOpen = "Door_CloseWaitOpen(tag, speed, delay, lighttag)";
Door_LockedRaise = "Door_LockedRaise(tag, speed, delay, lock, lighttag)";
Door_Open = "Door_Open(tag, speed, lighttag)";
Door_Raise = "Door_Raise(tag, speed, delay, lighttag)";
Door_WaitClose = "Door_WaitClose(tag, speed, wait, lighttag)";
Door_WaitRaise = "Door_WaitRaise(tag, speed, delay, wait, lighttag)";
DropInventory = "DropInventory(tid, item)";
DropItem = "DropItem(tid, item, dropamount, chance)";
Elevator_LowerToNearest = "Elevator_LowerToNearest(tag, speed)";
Elevator_MoveToFloor = "Elevator_MoveToFloor(tag, speed)";
Elevator_RaiseToNearest = "Elevator_RaiseToNearest(tag, speed)";
Else = "Else";
EndDBTransaction = "EndDBTransaction()";
Enter = "Script expression Enter";
Exit_Normal = "Exit_Normal(pos)";
Exit_Secret = "Exit_Secret(pos)";
FadeRange = "FadeRange(red1, green1, blue1, amount1, red2, green2, blue2, amount2, seconds)";
FadeTo = "FadeTo(red, green, blue, amount, seconds)";
FixedDiv = "FixedDiv(a, b)";
FixedMul = "FixedMul(a, b)";
FixedSqrt = "FixedSqrt(number)";
Floor = "Floor(value)";
Floor_CrushStop = "Floor_CrushStop(tag)";
Floor_Donut = "Floor_Donut(ptag, pspeed, sspeed)";
Floor_LowerByTexture = "Floor_LowerByTexture(tag, speed, change)";
Floor_LowerByValue = "Floor_LowerByValue(tag, speed, height)";
Floor_LowerByValueTimes8 = "Floor_LowerByValueTimes8(tag, speed, height)";
Floor_LowerInstant = "Floor_LowerInstant(tag, unused, height)";
Floor_LowerToHighest = "Floor_LowerToHighest(tag, speed, adjust, force_adjust)";
Floor_LowerToHighestEE = "Floor_LowerToHighestEE(tag, speed, change)";
Floor_LowerToLowest = "Floor_LowerToLowest(tag, speed)";
Floor_LowerToLowestCeiling = "Floor_LowerToLowestCeiling(tag, speed, change)";
Floor_LowerToLowestTxTy = "Floor_LowerToLowestTxTy(tag, speed)";
Floor_LowerToNearest = "Floor_LowerToNearest(tag, speed)";
Floor_MoveToValue = "Floor_MoveToValue(tag, speed, height, neg)";
Floor_MoveToValueAndCrush = "Floor_MoveToValueAndCrush(tag, speed, height, crush, crushmode)";
Floor_MoveToValueTimes8 = "Floor_MoveToValueTimes8(tag, speed, height, neg)";
Floor_RaiseAndCrush = "Floor_RaiseAndCrush(tag, speed, crush, crushmode)";
Floor_RaiseAndCrushDoom = "Floor_RaiseAndCrushDoom(tag, speed, crush, crushmode)";
Floor_RaiseByTexture = "Floor_RaiseByTexture(tag, speed)";
Floor_RaiseByValue = "Floor_RaiseByValue(tag, speed, height)";
Floor_RaiseByValueTimes8 = "Floor_RaiseByValueTimes8(tag, speed, height)";
Floor_RaiseByValueTxTy = "Floor_RaiseByValueTxTy(tag, speed, height)";
Floor_RaiseInstant = "Floor_RaiseInstant(tag, unused, height)";
Floor_RaiseToCeiling = "Floor_RaiseToCeiling(tag, speed, change, crush, gap)";
Floor_RaiseToHighest = "Floor_RaiseToHighest(tag, speed)";
Floor_RaiseToLowest = "Floor_RaiseToLowest(tag, change, crush)";
Floor_RaiseToLowestCeiling = "Floor_RaiseToLowestCeiling(tag, speed)";
Floor_RaiseToNearest = "Floor_RaiseToNearest(tag, speed)";
Floor_Stop = "Floor_Stop(tag)";
Floor_ToCeilingInstant = "Floor_ToCeilingInstant(tag, change, crush, gap)";
Floor_TransferNumeric = "Floor_TransferNumeric(tag)";
Floor_TransferTrigger = "Floor_TransferTrigger(tag)";
Floor_Waggle = "Floor_Waggle(tag, amp, freq, offset, time)";
FloorAndCeiling_LowerByValue = "FloorAndCeiling_LowerByValue(tag, speed, height)";
FloorAndCeiling_LowerRaise = "FloorAndCeiling_LowerRaise(tag, fspeed, cspeed, boomemu)";
FloorAndCeiling_RaiseByValue = "FloorAndCeiling_RaiseByValue(tag, speed, height)";
For = "For(initialization; condition; iteration)";
ForceField = "ForceField()";
FreeDBResults = "FreeDBResults(results)";
FS_Execute = "FS_Execute(script, side, keynum, message)";
Function = "Function Void expression (Void)";
GameSkill = "GameSkill()";
GameType = "GameType()";
Generic_Ceiling = "Generic_Ceiling(tag, speed, height, target, flag)";
Generic_Crusher = "Generic_Crusher(tag, dspeed, uspeed, silent, crush)";
Generic_CrusherDist = "Generic_CrusherDist(tag, dspeed, uspeed, silent, crush)";
Generic_Crusher2 = "Generic_Crusher2(tag, dspeed, uspeed, silent, crush)";
Generic_Door = "Generic_Door(tag, speed, kind, delay, lock)";
Generic_Floor = "Generic_Floor(tag, speed, height, target, flags)";
Generic_Lift = "Generic_Lift(tag, speed, delay, type, height)";
Generic_Stairs = "Generic_Stairs(tag, speed, height, flags, reset)";
GetActorAngle = "GetActorAngle(tid)";
GetActorCeilingZ = "GetActorCeilingZ(tid)";
GetActorClass = "GetActorClass(tid)";
GetActorFloorTerrain = "GetActorFloorTerrain(tid)";
GetActorFloorTexture = "GetActorFloorTexture(tid)";
GetActorFloorZ = "GetActorFloorZ(tid)";
GetActorLightLevel = "GetActorLightLevel(tid)";
GetActorPitch = "GetActorPitch(tid)";
GetActorPowerupTics = "GetActorPowerupTics(tid, powerup)";
GetActorProperty = "GetActorProperty(tid, property)";
GetActorRoll = "GetActorRoll(tid)";
GetActorVelX = "GetActorVelX(tid)";
GetActorVelY = "GetActorVelY(tid)";
GetActorVelZ = "GetActorVelZ(tid)";
GetActorViewHeight = "GetActorViewHeight(tid)";
GetActorX = "GetActorX(tid)";
GetActorY = "GetActorY(tid)";
GetActorZ = "GetActorZ(tid)";
GetAirSupply = "GetAirSupply(playernumber)";
GetAmmoCapacity = "GetAmmoCapacity(ammotype)";
GetArmorInfo = "GetArmorInfo(infotype)";
GetArmorType = "GetArmorType(armortype, playernumber)";
GetChar = "GetChar(string, index)";
GetCVar = "GetCVar(cvarname)";
GetCVarString = "GetCVarString(cvarname)";
GetDBEntries = "GetDBEntries(namespace)";
GetDBEntry = "GetDBEntry(namespace, key)";
GetDBEntryRank = "GetDBEntryRank(namespace, key, order)";
GetDBEntryString = "GetDBEntryString(namespace, key, order)";
GetDBResultKeyString = "GetDBResultKeyString(results, row)";
GetDBResultValue = "GetDBResultValue(results, row)";
GetDBResultValueString = "GetDBResultValueString(results, row)";
GetGamemodeState = "GetGamemodeState()";
GetInvasionState = "GetInvasionState()";
GetInvasionWave = "GetInvasionWave()";
GetLevelInfo = "GetLevelInfo(levelinfo)";
GetLineActivation = "GetLineActivation(lineid)";
GetLineHealth = "GetLineHealth(lineid)";
GetLineRowOffset = "GetLineRowOffset()";
GetLineUDMFFixed = "GetLineUDMFFixed(lineid, key)";
GetLineUDMFInt = "GetLineUDMFInt(lineid, key)";
GetLineX = "GetLineX(unknown parameter list)";
GetLineY = "GetLineY(unknown parameter list)";
GetMaxInventory = "GetMaxInventory(tid, inventory)";
GetNetID = "GetNetID(tid, index, pointer)";
GetPlayerAccountName = "GetPlayerAccountName(player)";
GetPlayerInfo = "GetPlayerInfo(playernumber, playerinfo)";
GetPlayerInput = "GetPlayerInput(playernumber, input)";
GetPlayerLivesLeft = "GetPlayerLivesLeft(player)";
GetPolyobjX = "GetPolyobjX(polyid)";
GetPolyobjY = "GetPolyobjY(polyid)";
GetScreenHeight = "GetScreenHeight()";
GetScreenWidth = "GetScreenWidth()";
GetSectorCeilingZ = "GetSectorCeilingZ(tag, x, y)";
GetSectorFloorZ = "GetSectorFloorZ(tag, x, y)";
GetSectorHealth = "GetSectorHealth(tag, part)";
GetSectorLightLevel = "GetSectorLightLevel(tag)";
GetSectorUDMFFixed = "GetSectorUDMFFixed(tag, key)";
GetSectorUDMFInt = "GetSectorUDMFInt(tag, key)";
GetSideUDMFFixed = "GetSideUDMFFixed(lineid, side, key)";
GetSideUDMFInt = "GetSideUDMFInt(lineid, side, key)";
GetSigilPieces = "GetSigilPieces()";
GetTeamProperty = "GetTeamProperty(team, property)";
GetThingUDMFFixed = "GetThingUDMFFixed(tid, key)";
GetThingUDMFInt = "GetThingUDMFInt(tid, key)";
GetTimeProperty = "GetTimeProperty(timestamp, which, utc)";
GetUserArray = "GetUserArray(tid, name, pos)";
GetUserCVar = "GetUserCVar(playernum, cvarname)";
GetUserCVarString = "GetUserCVarString(playernum, cvarname)";
GetUserVariable = "GetUserVariable(tid, name)";
GetWeapon = "GetWeapon()";
GiveActorInventory = "GiveActorInventory(tid, inventoryitem, amount)";
GiveInventory = "GiveInventory(inventoryitem, amount)";
GlassBreak = "GlassBreak(dontspawnjunk)";
Global = "Global Int expression:identifier";
HealThing = "HealThing(amount)";
HudMessage = "HudMessage(text; type, id, color, x, y, holdtime, alpha)";
HudMessageBold = "HudMessageBold(text; type, id, color, x, y, holdtime, alpha)";
If = "If(expression)";
IncrementDBEntry = "IncrementDBEntry(namespace, key, value)";
Int = "Int expression";
IsMultiplayer = "IsMultiplayer()";
IsNetworkGame = "IsNetworkGame()";
IsOneFlagCTF = "IsOneFlagCTF()";
IsPointerEqual = "IsPointerEqual(ptr_select1, ptr_select2, tid1, tid2)";
IsTIDUsed = "IsTIDUsed(tid)";
KickFromGame = "KickFromGame(player, reason)";
Kill = "Script expression Kill";
Light_ChangeToValue = "Light_ChangeToValue(tag, value)";
Light_Fade = "Light_Fade(tag, value, tics)";
Light_Flicker = "Light_Flicker(tag, upper, lower)";
Light_ForceLightning = "Light_ForceLightning(mode)";
Light_Glow = "Light_Glow(tag, upper, lower, tics)";
Light_LowerByValue = "Light_LowerByValue(tag, value)";
Light_MaxNeighbor = "Light_MaxNeighbor(tag)";
Light_MinNeighbor = "Light_MinNeighbor(tag)";
Light_RaiseByValue = "Light_RaiseByValue(tag, value)";
Light_Stop = "Light_Stop(tag)";
Light_Strobe = "Light_Strobe(tag, upper, lower, u-tics, l-tics)";
Light_StrobeDoom = "Light_StrobeDoom(tag, u-tics, l-tics)";
Lightning = "Script expression Lightning";
Line_AlignCeiling = "Line_AlignCeiling(lineid, side)";
Line_AlignFloor = "Line_AlignFloor(lineid, side)";
Line_SetAutomapFlags = "Line_SetAutomapFlags(lineid, setflags, clearflags)";
Line_SetAutomapStyle = "Line_SetAutomapStyle(lineid, style)";
Line_SetBlocking = "Line_SetBlocking(lineid, setflags, clearflags)";
Line_SetHealth = "Line_SetHealth(lineid, health)";
Line_SetPortalTarget = "Line_SetPortalTarget(sourceline, targetline)";
Line_SetTextureOffset = "Line_SetTextureOffset(lineid, x, y, side, flags)";
Line_SetTextureScale = "Line_SetTextureScale(lineid, x, y, side, flags)";
LineAttack = "LineAttack(tid, angle, pitch, damage, pufftype, damagetype, range, flags, pufftid)";
LineSide = "LineSide()";
LocalAmbientSound = "LocalAmbientSound(sound, volume)";
LocalSetMusic = "LocalSetMusic(song, order, unused)";
Log = "Log(type:expression)";
MorphActor = "MorphActor(tid, playerclass, monsterclass, duration, style, morphflash, unmorphflash)";
Music_Change = "Music_Change(music, pattern)";
NamedRequestScriptPuke = "NamedRequestScriptPuke(script, arg0, arg1, arg2, arg3)";
NamedScriptWait = "NamedScriptWait(script)";
Net = "Script expression Net";
NoiseAlert = "NoiseAlert(target_tid, emiter_tid)";
Open = "Script expression Open";
PickActor = "PickActor(source_tid, angle, pitch, distance, new_tid, actor_mask, wall_mask, flags)";
Pickup = "Script expression Pickup";
Pillar_Build = "Pillar_Build(tag, speed, height)";
Pillar_BuildAndCrush = "Pillar_BuildAndCrush(tag, speed, height, crush, crushmode)";
Pillar_Open = "Pillar_Open(tag, speed, fdist, cdist)";
Plat_DownByValue = "Plat_DownByValue(tag, speed, delay, height)";
Plat_DownWaitUpStay = "Plat_DownWaitUpStay(tag, speed, delay)";
Plat_DownWaitUpStayLip = "Plat_DownWaitUpStayLip(tag, speed, delay, lip, sound)";
Plat_PerpetualRaise = "Plat_PerpetualRaise(tag, speed, delay)";
Plat_PerpetualRaiseLip = "Plat_PerpetualRaiseLip(tag, speed, delay, lip)";
Plat_RaiseAndStayTx0 = "Plat_RaiseAndStayTx0(tag, speed, lockout)";
Plat_Stop = "Plat_Stop(tag)";
Plat_ToggleCeiling = "Plat_ToggleCeiling(tag)";
Plat_UpByValue = "Plat_UpByValue(tag, speed, delay, height)";
Plat_UpByValueStayTx = "Plat_UpByValueStayTx(tag, speed, height)";
Plat_UpNearestWaitDownStay = "Plat_UpNearestWaitDownStay(tag, speed, delay)";
Plat_UpWaitDownStay = "Plat_UpWaitDownStay(tag, speed, delay)";
PlayActorSound = "PlayActorSound(tid, sound, channel, volume, looping, attenuation)";
Player_GiveItem = "Player_GiveItem(unknown parameters list)";
Player_RemoveItem = "Player_RemoveItem(unknown parameters list)";
Player_SetTeam = "Player_SetTeam(team)";
PlayerArmorpoints = "PlayerArmorpoints()";
PlayerClass = "PlayerClass(playernumber)";
PlayerCount = "PlayerCount()";
PlayerFrags = "PlayerFrags()";
PlayerHealth = "PlayerHealth()";
PlayerInGame = "PlayerInGame(playernumber)";
PlayerIsBot = "PlayerIsBot(playernumber)";
PlayerIsLoggedIn = "PlayerIsLoggedIn(playernumber)";
PlayerIsSpectator = "PlayerIsSpectator(player)";
PlayerNumber = "PlayerNumber()";
PlayerTeam = "PlayerTeam()";
PlayMovie = "PlayMovie(moviename)";
PlaySound = "PlaySound(tid, sound, channel, volume, looping, attenuation, local)";
Polyobj_DoorSlide = "Polyobj_DoorSlide(po, speed, angle, dist, delay)";
Polyobj_DoorSwing = "Polyobj_DoorSwing(po, speed, angle, delay)";
Polyobj_Move = "Polyobj_Move(po, speed, angle, dist)";
Polyobj_MoveTimes8 = "Polyobj_MoveTimes8(po, speed, angle, dist)";
Polyobj_MoveTo = "Polyobj_MoveTo(po, speed, pos_x, pos_y)";
Polyobj_MoveToSpot = "Polyobj_MoveToSpot(po, speed, target)";
Polyobj_OR_Move = "Polyobj_OR_Move(po, speed, angle, distance)";
Polyobj_OR_MoveTimes8 = "Polyobj_OR_MoveTimes8(po, speed, angle, distance)";
Polyobj_OR_MoveTo = "Polyobj_OR_MoveTo(po, speed, pos_x, pos_y)";
Polyobj_OR_MoveToSpot = "Polyobj_OR_MoveToSpot(po, speed, target)";
Polyobj_OR_RotateLeft = "Polyobj_OR_RotateLeft(po, speed, angle)";
Polyobj_OR_RotateRight = "Polyobj_OR_RotateRight(po, speed, angle)";
Polyobj_RotateLeft = "Polyobj_RotateLeft(po, speed, angle)";
Polyobj_RotateRight = "Polyobj_RotateRight(po, speed, angle)";
Polyobj_Stop = "Polyobj_Stop(po)";
Polyobj_StopSound = "Polyobj_StopSound(po)";
PolyWait = "PolyWait(polyid)";
Print = "Print(type:expression)";
PrintBold = "PrintBold(type:expression)";
QuakeEx = "QuakeEx(tid, intensity_x, intensity_y, intensity_z, duration, damrad, tremrad, sfx, flags, mulwave_x, mulwave_y, mulwave_z, falloff, highpoint, rollintensity, rollwave, damagemultiplier, thrustmultiplier, damage)";
Radius_Quake = "Radius_Quake(intensity, duration, damrad, tremrad, tid)";
Radius_Quake2 = "Radius_Quake2(tid, intensity, duration, damrad, tremrad, sound)";
Random = "Random(min, max)";
RedCount = "RedCount()";
RedReturn = "Script expression RedReturn";
RedScore = "RedScore()";
RedTeamCount = "RedTeamCount()";
RedTeamScore = "RedTeamScore()";
ReOpen = "Script expression ReOpen";
ReplaceTextures = "ReplaceTextures(oldtexture, newtexture, flags)";
RequestScriptPuke = "RequestScriptPuke(script, arg0, arg1, arg2, arg3)";
ResetMap = "ResetMap()";
Respawn = "Script expression Respawn";
Restart = "Restart";
Return = "Return";
Round = "Round(value)";
Script = "Script expression (Void)";
ScriptCall = "ScriptCall(classname, funcname, args)";
ScriptWait = "ScriptWait(script)";
Scroll_Ceiling = "Scroll_Ceiling(tag, x-move, y-move, unused)";
Scroll_Floor = "Scroll_Floor(tag, x-move, y-move, type)";
Scroll_Texture_Both = "Scroll_Texture_Both(lineid, left, right, down, up)";
Scroll_Wall = "Scroll_Wall(lineid, x, y, side, flags)";
Sector_ChangeFlags = "Sector_ChangeFlags(tag, setflags, clearflags)";
Sector_ChangeSound = "Sector_ChangeSound(tag, newsequence)";
Sector_SetCeilingGlow = "Sector_SetCeilingGlow(tag, height, red, green, blue)";
Sector_SetCeilingPanning = "Sector_SetCeilingPanning(tag, u-int, u-frac, v-int, v-frac)";
Sector_SetCeilingScale = "Sector_SetCeilingScale(tag, u-int, u-frac, v-int, v-frac)";
Sector_SetCeilingScale2 = "Sector_SetCeilingScale2(tag, u-fixed, v-fixed)";
Sector_SetColor = "Sector_SetColor(tag, red, green, blue, desaturation)";
Sector_SetCurrent = "Sector_SetCurrent(tag, amount, angle, useline)";
Sector_SetDamage = "Sector_SetDamage(tag, amount, mod, interval, leaky)";
Sector_SetFade = "Sector_SetFade(tag, red, green, blue)";
Sector_SetFloorGlow = "Sector_SetFloorGlow(tag, height, red, green, blue)";
Sector_SetFloorPanning = "Sector_SetFloorPanning(tag, u-int, u-frac, v-int, v-frac)";
Sector_SetFloorScale = "Sector_SetFloorScale(tag, u-int, u-frac, v-int, v-frac)";
Sector_SetFloorScale2 = "Sector_SetFloorScale2(tag, u-fixed, v-fixed)";
Sector_SetFriction = "Sector_SetFriction(tag, amount)";
Sector_SetGravity = "Sector_SetGravity(tag, ipart, fpart)";
Sector_SetHealth = "Sector_SetHealth(tag, part, health)";
Sector_SetLink = "Sector_SetLink(controltag, tag, surface, movetype)";
Sector_SetPlaneReflection = "Sector_SetPlaneReflection(tag, floor, ceiling)";
Sector_SetRotation = "Sector_SetRotation(tag, floor-angle, ceiling-angle)";
Sector_SetTranslucent = "Sector_SetTranslucent(tag, plane, amount, type)";
Sector_SetWind = "Sector_SetWind(tag, amount, angle, useline)";
SectorDamage = "SectorDamage(tag, amount, type, protectionitem, flags)";
SectorSound = "SectorSound(sound, volume)";
SendToCommunicator = "SendToCommunicator(voc_id, front_only, indentify, nolog)";
SetActivator = "SetActivator(tid, pointer_selector)";
SetActivatorByNetID = "SetActivatorByNetID(netid, pointer)";
SetActivatorToTarget = "SetActivatorToTarget(tid)";
SetActorAngle = "SetActorAngle(tid, angle)";
SetActorFlag = "SetActorFlag(tid, flagname, set)";
SetActorPitch = "SetActorPitch(tid, pitch)";
SetActorPosition = "SetActorPosition(tid, x, y, z, fog)";
SetActorProperty = "SetActorProperty(tid, property, value)";
SetActorRoll = "SetActorRoll(tid, angle)";
SetActorState = "SetActorState(tid, state, exact)";
SetActorTeleFog = "SetActorTeleFog(tid, sourcefog, destfog)";
SetActorVelocity = "SetActorVelocity(tid, velx, vely, velz, add, setbob)";
SetAirControl = "SetAirControl(amount)";
SetAirSupply = "SetAirSupply(playernumber, tics)";
SetAmmoCapacity = "SetAmmoCapacity(ammotype, maxamount)";
SetCameraToTexture = "SetCameraToTexture(cameratid, texture, fov)";
SetCeilingTrigger = "SetCeilingTrigger(tag, height, special, arg1, arg2, arg3, arg4, arg5)";
SetCVar = "SetCVar(cvarname, newvalue)";
SetCVarString = "SetCVarString(cvarname, newvalue)";
SetDBEntry = "SetDBEntry(namespace, key, value)";
SetDBEntryString = "SetDBEntryString(namespace, key, value)";
SetFloorTrigger = "SetFloorTrigger(tag, height, special, arg1, arg2, arg3, arg4, arg5)";
SetFogDensity = "SetFogDensity(tag, amount)";
SetFont = "SetFont(font)";
SetGlobalFogParameter = "SetGlobalFogParameter(property, value)";
SetGravity = "SetGravity(amount)";
SetHUDClipRect = "SetHUDClipRect(x, y, width, height, wrapwidth, aspectratio)";
SetHudSize = "SetHudSize(width, height, statusbar)";
SetHUDWrapWidth = "SetHUDWrapWidth(wrapwidth)";
SetLineActivation = "SetLineActivation(lineid, activation, repeat)";
SetLineBlocking = "SetLineBlocking(lineid, setting)";
SetLineMonsterBlocking = "SetLineMonsterBlocking(lineid, setting)";
SetLineSpecial = "SetLineSpecial(lineid, special, arg1, arg2, arg3, arg4, arg5)";
SetLineTexture = "SetLineTexture(lineid, side, position, texture)";
SetMarineSprite = "SetMarineSprite(tid, actorclass)";
SetMarineWeapon = "SetMarineWeapon(tid, weapon)";
SetMugShotState = "SetMugShotState(state)";
SetMusic = "SetMusic(song, order, unused)";
SetMusicVolume = "volume";
SetPlayerLivesLeft = "SetPlayerLivesLeft(player, amount)";
SetPlayerProperty = "SetPlayerProperty(who, set, which)";
SetPointer = "SetPointer(assign_slot, tid, pointer_selector, flags)";
SetResultValue = "SetResultValue(value)";
SetSectorDamage = "SetSectorDamage(tag, amount, damagetype, interval, leaky)";
SetSectorGlow = "SetSectorGlow(tag, which, red, green, blue, height)";
SetSectorTerrain = "SetSectorTerrain(tag, whichplane, terraintype)";
SetSkyScrollSpeed = "SetSkyScrollSpeed(skynumber, speed)";
SetSubtitleNumber = "SetSubtitleNumber(num, sound)";
SetThingSpecial = "SetThingSpecial(tid, special, arg1, arg2, arg3, arg4, arg5)";
SetTranslation = "SetTranslation(tid, transname)";
SetUserArray = "SetUserArray(tid, name, pos, value)";
SetUserCVar = "SetUserCVar(playernum, cvarname, newvalue)";
SetUserCVarString = "SetUserCVarString(playernum, cvarname, newvalue)";
SetUserVariable = "SetUserVariable(tid, name, value)";
SetWeapon = "SetWeapon(weapon)";
sin = "sin(angle)";
SinglePlayer = "SinglePlayer()";
SortDBEntries = "SortDBEntries(namespace, limit, offset, order)";
SoundSequence = "SoundSequence(sndseq)";
SoundSequenceOnActor = "SoundSequenceOnActor(tid, sndseq)";
SoundSequenceOnPolyObj = "SoundSequenceOnPolyObj(polyid, sndseq)";
SoundSequenceOnSector = "SoundSequenceOnSector(tag, sndseq, location)";
SoundVolume = "SoundVolume(tid, channel, volume)";
Spawn = "Spawn(classname, x, y, z, newtid, angle)";
SpawnDecal = "SpawnDecal(tid, decalname, flags, angle, zoffset, distance)";
SpawnForced = "SpawnForced(classname, x, y, z, newtid, angle)";
SpawnParticle = "SpawnParticle(color, fullbright, lifetime, size, x, y, z, velx, vely, velz, accelx, accely, accelz, startalpha, fadestep, endsize)";
SpawnProjectile = "SpawnProjectile(tid, classname, angle, speed, vspeed, gravity, newtid)";
SpawnSpot = "SpawnSpot(classname, spottid, newtid, angle)";
SpawnSpotFacing = "SpawnSpotFacing(classname, spottid, newtid)";
SpawnSpotFacingForced = "SpawnSpotFacingForced(classname, spottid, newtid)";
SpawnSpotForced = "SpawnSpotForced(classname, spottid, newtid, angle)";
Special = "Special";
Sqrt = "Sqrt(number)";
Stairs_BuildDown = "Stairs_BuildDown(tag, speed, height, delay, reset)";
Stairs_BuildDownDoom = "Stairs_BuildDownDoom(tag, speed, height, delay, reset)";
Stairs_BuildDownDoomSync = "Stairs_BuildDownDoomSync(tag, speed, height, reset)";
Stairs_BuildDownSync = "Stairs_BuildDownSync(tag, speed, height, reset)";
Stairs_BuildUp = "Stairs_BuildUp(tag, speed, height, delay, reset)";
Stairs_BuildUpDoom = "Stairs_BuildUpDoom(tag, speed, height, delay, reset)";
Stairs_BuildUpDoomCrush = "Stairs_BuildUpDoomCrush(tag, speed, height, delay, reset)";
Stairs_BuildUpDoomSync = "Stairs_BuildUpDoomSync(tag, speed, height, reset)";
Stairs_BuildUpSync = "Stairs_BuildUpSync(tag, speed, height, reset)";
StartConversation = "StartConversation(talker_tid, facetalker)";
StartSlideshow = "StartSlideshow(unknown parameter list)";
StopSound = "StopSound(tid, channel)";
Str = "Str expression";
StrArg = "StrArg(unknown parameter list)";
StrCaseCmp = "StrCaseCmp(string1, string2, maxcomparenum)";
StrCmp = "StrCmp(string1, string2, maxcomparenum)";
StrCpy = "StrCpy(a:destination, source, sourceindex)";
Strftime = "Strftime(timestamp, format, utc)";
StrIcmp = "StrIcmp(string1, string2, maxcomparenum)";
StrLeft = "StrLeft(string, length)";
StrLen = "StrLen(string)";
StrMid = "StrMid(string, start, length)";
StrParam = "StrParam(type:expression)";
StrRight = "StrRight(string, length)";
Suspend = "Suspend";
SwapActorTeleFog = "SwapActorTeleFog(tid)";
Switch = "Switch(expression)";
SystemTime = "SystemTime()";
TagWait = "TagWait(tag)";
TakeActorInventory = "TakeActorInventory(tid, inventoryitem, amount)";
TakeInventory = "TakeInventory(inventoryitem, amount)";
Team_GivePoints = "Team_GivePoints(team, points, announce)";
Team_Score = "Team_Score(points, nogrin)";
Teleport = "Teleport(tid, tag, nosourcefog)";
Teleport_EndGame = "Teleport_EndGame()";
Teleport_NewMap = "Teleport_NewMap(map, pos, face)";
Teleport_NoFog = "Teleport_NoFog(tid, useangle, tag)";
Teleport_NoStop = "Teleport_NoStop(tid, tag, nofog)";
Teleport_ZombieChanger = "Teleport_ZombieChanger(tid, tag)";
TeleportGroup = "TeleportGroup(groupid, sourceid, destinationid, movesource, fog)";
TeleportInSector = "TeleportInSector(tag, sourceid, destinationid, fog, groupid)";
TeleportOther = "TeleportOther(tid, destinationid, fog)";
Terminate = "Terminate";
Thing_Activate = "Thing_Activate(tid)";
Thing_ChangeTID = "Thing_ChangeTID(oldtid, newtid)";
Thing_Damage = "Thing_Damage(tid, amount, mod)";
Thing_Damage2 = "Thing_Damage2(tid, amount, damagetype)";
Thing_Deactivate = "Thing_Deactivate(tid)";
Thing_Destroy = "Thing_Destroy(tid, extreme, tag)";
Thing_Hate = "Thing_Hate(hater, hatee, type)";
Thing_Move = "Thing_Move(tid, destid, nofog)";
Thing_Projectile = "Thing_Projectile(tid, type, angle, speed, vspeed)";
Thing_Projectile2 = "Thing_Projectile2(tid, classname, angle, speed, vspeed, gravity, newtid)";
Thing_ProjectileAimed = "Thing_ProjectileAimed(tid, type, speed, target, newtid)";
Thing_ProjectileGravity = "Thing_ProjectileGravity(tid, type, angle, speed, vspeed)";
Thing_ProjectileIntercept = "Thing_ProjectileIntercept(tid, type, speed, target, newtid)";
Thing_Raise = "Thing_Raise(tid)";
Thing_Remove = "Thing_Remove(tid)";
Thing_SetConversation = "Thing_SetConversation(tid, conversationid)";
Thing_SetGoal = "Thing_SetGoal(tid, goal, delay, dontchasetarget)";
Thing_SetSpecial = "Thing_SetSpecial(tid, special, arg1, arg2, arg3)";
Thing_SetTranslation = "Thing_SetTranslation(tid, translation)";
Thing_Spawn = "Thing_Spawn(tid, type, angle, newtid)";
Thing_SpawnFacing = "Thing_SpawnFacing(tid, type, nofog, newtid)";
Thing_SpawnNoFog = "Thing_SpawnNoFog(tid, type, angle, newtid)";
Thing_Stop = "Thing_Stop(tid)";
ThingCount = "ThingCount(type, tid)";
ThingCountName = "ThingCountName(classname, tid)";
ThingCountNameSector = "ThingCountNameSector(classname, tid, tag)";
ThingCountSector = "ThingCountSector(type, tid, tag)";
ThingSound = "ThingSound(tid, sound, volume)";
ThrustThing = "ThrustThing(angle, force, nolimit, tid)";
ThrustThingZ = "ThrustThingZ(tid, speed, up_or_down, add_or_set)";
Timer = "Timer()";
TranslucentLine = "TranslucentLine(lineid, amount, additive, moreflags)";
UniqueTID = "UniqueTID(tid, limit)";
Unloading = "Script expression Unloading";
UnMorphActor = "UnMorphActor(tid, force)";
Until = "Until(expression)";
UseActorInventory = "UseActorInventory(tid, inventoryitem)";
UseInventory = "UseInventory(inventoryitem)";
UsePuzzleItem = "UsePuzzleItem(item, script, arg1, arg2, arg3)";
VectorAngle = "VectorAngle(x, y)";
VectorLength = "VectorLength(x, y)";
Void = "Void";
Warp = "Warp(tid, xofs, yofs, zofs, angle, flags, success_state, exact, heightoffset, radiusoffset, pitch)";
While = "While(expression)";
WhiteReturn = "Script expression WhiteReturn";
World = "World Int expression:identifier";
}

constants
{
...
}
</pre>
[[Category:ACS]][[Category:Tools]]

FOR and WHILE loops

2026-03-07T18:14:15Z

MegaManx3: Criou página com ''''Loops''' podem reduzir dramaticamente o tamanho de um script quando uma ação precisa ser executada repetidamente. Neste script há vários setores, aqui de 1 até X. É claro, X deve ser substituído pelo maior número de ID de setor. Cada setor tem o special Floor_Waggle. Isso é fácil de configurar com copiar e colar, mas aí os IDs dos setores precisam ser alterados manualmente. O script poderia ser escrito assim: #include "zcommon.acs" SCRIPT 1 {{SType...'

'''Loops''' podem reduzir dramaticamente o tamanho de um script quando uma ação precisa ser executada repetidamente.

Neste script há vários setores, aqui de 1 até X. É claro, X deve ser substituído pelo maior número de ID de setor.
Cada setor tem o special [[Floor_Waggle]].

Isso é fácil de configurar com copiar e colar, mas aí os IDs dos setores precisam ser alterados manualmente.
O script poderia ser escrito assim:

#include "zcommon.acs"
SCRIPT 1 {{SType|Open}}
{
[[Floor_Waggle]] (1, 200, 50, 0, 0);
[[delay]] (7);
[[Floor_Waggle]] (2, 200, 50, 0, 0);
[[delay]] (7);
[[Floor_Waggle]] (3, 200, 50, 0, 0);
[[delay]] (7);

|
|
|

[[Floor_Waggle]] (X, 200, 50, 0, 0);
[[delay]] (7);
}

Uma forma mais fácil seria se um script atualizasse os IDs de setor em um loop.
Tanto um loop FOR quanto um loop WHILE podem ser usados.

===Loop FOR===

O loop for pode ser escrito de duas maneiras; a diferença é como a variável é declarada.

#include "zcommon.acs"
SCRIPT 1 {{SType|Open}}
{
for ( int sid = 1; sid < X; sid++ ) // sid é o ID do setor
{
[[Floor_Waggle]] (sid, 200, 50, 0, 0);
[[delay]] (7);
}
}

ou assim

#include "zcommon.acs"
script 1 {{SType|Open}}
{
int sid = 0;

for ( sid = 1; sid < X; sid++ ) // sid é o ID do setor
{
[[Floor_Waggle]] (sid, 100, 20, 0, 0 );
[[delay]] (7);
}
}

A primeira parte da instrução for (aqui <tt>sid = 1</tt>) é executada uma vez antes do loop começar a rodar. A terceira parte da instrução for (aqui <tt>sid++</tt>) é executada a cada iteração do loop, logo antes de ele reiniciar ou terminar. A segunda parte da instrução for (aqui <tt>sid < X</tt>) é a condição que precisa ser verdadeira para continuar repetindo.

Neste exemplo, o loop for define sid como 1 (<tt>sid = 1</tt>) antes que qualquer coisa dentro do loop execute. Depois do delay, ele incrementa sid em um (<tt>sid++</tt>). Enquanto sid for menor que X (<tt>sid < X</tt>), ele repetirá tudo dentro das chaves.

===Loop WHILE===

#include "zcommon.acs"
script 1 {{SType|Open}}
{
int sid = 1; // sid é o ID do setor

while ( sid < X )
{
[[Floor_Waggle]] (sid, 100, 20, 0, 0);
[[delay]] (7);
sid++;
}
}

Num caso como este, a decisão de usar for ou while depende da preferência do programador, porque no for todas as instruções de controle do loop ficam em um único lugar.

===Loop UNTIL===

#include "zcommon.acs"
script 1 {{SType|Open}}
{
int sid = 1; // sid é o ID do setor

until ( sid >= X )
{
[[Floor_Waggle]] (sid, 100, 20, 0, 0);
[[delay]] (7);
sid++;
}
}

Um loop until é o oposto de um loop while. Um until continuará repetindo até que uma condição se torne verdadeira, enquanto um while continuará repetindo até que uma condição se torne falsa.

[[Category:ACS]]

Thing

2026-03-07T18:08:24Z

MegaManx3: Criou página com '{{doomwiki}} Em Doom, '''things''' são usados para representar jogadores, monstros, itens coletáveis e projéteis. Dentro do jogo, eles são conhecidos como atores (actors). Existem três maneiras de colocar um ator no seu mapa. A maioria das things são actors, então os nomes frequentemente são usados de forma intercambiável. Algumas things, no entanto, não são atores, como pontos de player start. ==Referenciando things== DoomEd numbers são os núme...'

{{doomwiki}}
Em Doom, '''things''' são usados para representar jogadores, monstros, itens coletáveis e projéteis. Dentro do jogo, eles são conhecidos como atores (actors). Existem três maneiras de colocar um ator no seu mapa. A maioria das things são [[actor]]s, então os nomes frequentemente são usados de forma intercambiável. Algumas things, no entanto, não são atores, como pontos de [[player start]].

==Referenciando things==
[[DoomEd numbers]] são os números usados no editor para representar um ator. Quando o mapa é carregado, um ator correspondente àquele número será spawned no local daquela thing do mapa. Embora muitos atores tenham números DoomEd, nem todos têm. Por exemplo, um cartão-chave azul tem um número DoomEd, mas um foguete voando pelo ar não tem.

[[Spawn numbers]] são os números usados por specials como [[Thing_Spawn]] para spawnar atores no jogo depois que o usuário começa a jogar o mapa. Embora números DoomEd e números de spawn ambos descrevam atores, eles não são intercambiáveis—você não deve usar um número de spawn em uma thing do mapa, e você não deve usar um número DoomEd, por exemplo, como parâmetro de Thing_Spawn.

[[classes|Nomes de ator]] são os nomes reais que cada ator tem internamente (para testar isso, você pode querer experimentar o [[console commands|comando do console]] '''summon'''). Eles são usados com as funções [[SpawnSpot]] e [[Spawn]], que permitem spawnar qualquer ator disponível com [[Thing_Spawn]] e também todos os outros atores (embora alguns atores não devam ser spawnados), como câmeras, cenário ou qualquer outra coisa que você precisar.

Se você criar um novo ator com o lump [[DECORATE]], você pode especificar tanto o número de spawn (SpawnID) quanto o número DoomEd (DoomEdNum). O nome que você dá ao novo item [[DECORATE]] também é o seu nome de ator, então você também pode spawná-lo usando esse nome.

Há também um terceiro conjunto de números usado para representar atores que é importante apenas para [[DeHackEd]] e similares. Esses números correspondem à ordem em que os atores foram definidos no exe vanilla. Eles não têm significado fora do [[DEHSUPP|carregador DeHackEd]] do ZDoom e, como resultado, não são uma propriedade. Em ''[[Strife]]'', eles eram usados para identificar classes de ator em conversas, mas o ZDoom transformou isso na propriedade {{Property|ConversationID}} porque atores idênticos tinham números diferentes nas diferentes versões de Strife disponíveis.

==Especificação (formato Doom)==
{| {{prettytable}}
!Bytes!!Tipo de dado!!Descrição!!Notas
|-
|0-1||Signed short||Posição X||
|-
|2-3||Signed short||Posição Y||
|-
|4-5||Unsigned short||Ângulo||0=Leste, 45=NE, 90=Norte 135=NO, 180=Oeste, 225=SO, 270=Sul
|-
|6-7||Unsigned short||Tipo||Veja a lista de [[standard editor numbers]]
|-
|8-9||Unsigned Short||Flags de spawn||
|}

==Especificação (formato Hexen)==
{| {{prettytable}}
!Bytes!!Tipo de dado!!Descrição!!Notas
|-
|0-1||Unsigned short||[[Thing ID]]||Este valor é usado para scripts e specials
|-
|2-3||Signed short||Posição X||
|-
|4-5||Signed short||Posição Y||
|-
|6-7||Signed short||Posição Z||
|-
|8-9||Unsigned short||Ângulo||0=Leste, 45=NE, 90=Norte 135=NO, 180=Oeste, 225=SO, 270=Sul
|-
|10-11||Unsigned short||Tipo||Veja a lista de [[standard editor numbers]]
|-
|12-13||Unsigned short||Flags de spawn||
|-
|14||Unsigned byte||[[Action special]]||Uma ação a ser executada quando esta thing for destruída ou coletada
|-
|15||Unsigned byte||Argumento de ação 1||
|-
|16||Unsigned byte||Argumento de ação 2||
|-
|17||Unsigned byte||Argumento de ação 3||
|-
|18||Unsigned byte||Argumento de ação 4||
|-
|19||Unsigned byte||Argumento de ação 5||
|}

==Flags de spawn==
Há vários conflitos na lista de flags, dependendo do jogo. [[Map translator]]s são usados para definir como os valores são associados às flags em um mapa binário. [[UDMF]] permite resolver esses conflitos por não usar um array de bitfield e, em vez disso, referir-se a cada flag pelo nome. Várias flags só estão disponíveis neste [[map format|formato de mapa]].

{| {{PrettySortable}}
!Flag!!Z-Bit!!Z-Hex!!D-Bit!!D-Hex!!S-Bit!!S-Hex!!Descrição!!Nome em [[UDMF]]
|-
|EASY||0||0x0001||0||0x0001||0||0x0001||Thing é spawnada nas habilidades #1 e #2 ||<tt>skill1</tt> + <tt>skill2</tt>
|-
|MEDIUM||1||0x0002||1||0x0002||1||0x0002||Thing é spawnada na habilidade #3||<tt>skill3</tt>
|-
|HARD||2||0x0004||2||0x0004||2||0x0004||Thing é spawnada nas habilidades #4 e #5||<tt>skill4</tt> + <tt>skill5</tt>
|-
|AMBUSH||3||0x0008||3||0x0008||5||0x0020||Thing fica em emboscada (a flag {{flag|AMBUSH}} está definida)||<tt>ambush</tt>
|-
|DORMANT||4||0x0010|| || || || ||Thing fica {{flag|DORMANT}} até ser ativada||<tt>dormant</tt>
|-
|FIGHTER||5||0x0020|| || || || ||Thing é spawnada quando a classe de jogador #1 está presente||<tt>class1</tt>
|-
|CLERIC||6||0x0040|| || || || ||Thing é spawnada quando a classe de jogador #2 está presente||<tt>class2</tt>
|-
|MAGE||7||0x0080|| || || || ||Thing é spawnada quando a classe de jogador #3 está presente||<tt>class3</tt>
|-
|SINGLE||8||0x0100|| || || || ||Thing aparece em jogos single-player||<tt>single</tt>
|-
|COOPERATIVE||9||0x0200|| || || || ||Thing aparece em jogos cooperativos||<tt>coop</tt>
|-
|DEATHMATCH||10||0x0400|| || || || ||Thing aparece em jogos deathmatch||<tt>dm</tt>
|-
|SHADOW||11||0x0800|| || ||8||0x0100||Thing é 25% translúcida||<tt>translucent</tt>
|-
|ALTSHADOW||12||0x1000|| || ||9||0x0200||Thing é invisível||<tt>invisible</tt>
|-
|FRIENDLY||13||0x2000|| || ||6||0x0040||Isto é um monstro {{Flag|FRIENDLY}} usando a lógica de [[Strife]]||<tt>strifeally</tt>
|-
|STANDSTILL||14||0x4000|| || ||3||0x0008||Thing fica parada (só útil para monstros específicos de Strife ou friendlys)||<tt>standing</tt>
|-
|SECRET|| || || || || || ||Thing é um item de [[secret]]||<tt>countsecret</tt>

|-
|NOTSINGLE|| || ||4||0x0010||4||0x0010||Thing não aparece no single player
|-
|NOTDEATHMATCH|| || ||5||0x0020|| || ||Thing não aparece no deathmatch single
|-
|NOTCOOPERATIVE|| || ||6||0x0040|| || ||Thing não aparece no cooperativo
|-
|FRIEND|| || ||6||0x0040|| || ||Thing é um monstro amigável usando a lógica [[MBF]] (remapeado para FRIENDLY)||friend
|-
|BADEDITORCHECK|| || ||8||0x0100|| || ||Thing foi colocada em um editor de mapas que define flags indefinidas||
|-
| || || || || || || ||Thing é spawnada na habilidade #1||skill1
|-
| || || || || || || ||Thing é spawnada na habilidade #2||skill2
|-
| || || || || || || ||Thing é spawnada na habilidade #4||skill4
|-
| || || || || || || ||Thing é spawnada na habilidade #5||skill5
|-
| || || || || || || ||Thing é spawnada na habilidade #6||skill6
|-
| || || || || || || ||Thing é spawnada na habilidade #7||skill7
|-
| || || || || || || ||Thing é spawnada na habilidade #8||skill8
|-
| || || || || || || ||Thing é spawnada na habilidade #9||skill9
|-
| || || || || || || ||Thing é spawnada na habilidade #10||skill10
|-
| || || || || || || ||Thing é spawnada na habilidade #11||skill11
|-
| || || || || || || ||Thing é spawnada na habilidade #12||skill12
|-
| || || || || || || ||Thing é spawnada na habilidade #13||skill13
|-
| || || || || || || ||Thing é spawnada na habilidade #14||skill14
|-
| || || || || || || ||Thing é spawnada na habilidade #15||skill15
|-
| || || || || || || ||Thing é spawnada na habilidade #16||skill16
|-
| || || || || || || ||Thing é spawnada quando a classe de jogador #4 está presente||class4
|-
| || || || || || || ||Thing é spawnada quando a classe de jogador #5 está presente||class5
|-
| || || || || || || ||Thing é spawnada quando a classe de jogador #6 está presente||class6
|-
| || || || || || || ||Thing é spawnada quando a classe de jogador #7 está presente||class7
|-
| || || || || || || ||Thing é spawnada quando a classe de jogador #8 está presente||class8
|-
| || || || || || || ||Thing é spawnada quando a classe de jogador #9 está presente||class9
|-
| || || || || || || ||Thing é spawnada quando a classe de jogador #10 está presente||class10
|-
| || || || || || || ||Thing é spawnada quando a classe de jogador #11 está presente||class11
|-
| || || || || || || ||Thing é spawnada quando a classe de jogador #12 está presente||class12
|-
| || || || || || || ||Thing é spawnada quando a classe de jogador #13 está presente||class13
|-
| || || || || || || ||Thing é spawnada quando a classe de jogador #14 está presente||class14
|-
| || || || || || || ||Thing é spawnada quando a classe de jogador #15 está presente||class15
|-
| || || || || || || ||Thing é spawnada quando a classe de jogador #16 está presente||class16
|}

==Propriedades UDMF==
Além das flags de spawn exclusivas de UDMF acima, as seguintes propriedades só podem ser usadas em uma thing no modo UDMF. A menos que especificado de outra forma, os valores padrão para inteiros e float são 0, e {{c|false}} para booleanos. Elas incluem:
{| {{prettytable}}
!Nome!!Tipo!!Descrição
|-
|{{c|alpha}}||float||Define a {{Property|Alpha|translucência}} do ator. Ela só se aplica aos estilos de renderização {{c|Translucent}}, {{c|Add}}, {{c|Subtract}} e {{c|TranslucentStencil}}. O padrão é 1.0.
|-
|{{c|arg0str}}||string||Atribui um valor string ao primeiro argumento. Isso é usado para [[named script]]s e [[Hexen breakable items]].
|-
|{{c|arg1str}}||string||Atribui um valor string ao segundo argumento. Isso é usado por certos [[:Category:Thing specials|specials de spawn de thing]].
|-
|{{c|conversation}}||integer||Atribui um ID de [[ZDoom Strife Dialog Format|conversa]] à thing. Isso corresponde à propriedade {{c|id}} de uma conversa, permitindo árvores de diálogo específicas para uma determinada thing, em vez de para uma classe de ator inteira.
|-
|{{c|fillcolor}}||integer||Define o {{Property|StencilColor|fillcolor}} do ator, que é usado pelos estilos de renderização {{c|Stencil}} e {{c|TranslucentStencil}}, como valor {{c|RRGGBB}}.
|-
|{{c|floatbobphase}}||integer||Define o {{Property|FloatBobPhase|floatbobphase}} do ator. Valores de fase válidos estão no intervalo 0-63. Definir isso como -1 fará com que seja usado o próprio valor da propriedade do ator. O padrão é -1.
|-
|{{c|friendlyseeblocks}}||integer||Define o {{Property|FriendlySeeBlocks|friendlyseeblocks}} do ator. Se isso for definido como 0 ou menos, o padrão do ator para essa propriedade, conforme definido na sua definição de ator, é usado no lugar. O padrão é -1.
|-
|{{c|gravity}}||float||Define a [[gravity|gravidade]] do ator. Valores positivos são multiplicados pelo valor da {{Property|Gravity|propriedade gravity}} da classe; valores negativos são usados pelo seu valor absoluto. O padrão é 1.0.
|-
|{{c|health}}||float||Define a [[health|vida]] do ator. Valores positivos são multiplicados pela propriedade {{c|{{Property|Health}}}} da classe e valores negativos são usados pelo seu valor absoluto. Se o valor for definido como 0, o ator nasce morto (útil para cadáveres de monstros ressuscitáveis). O padrão é 1.0.
|-
|{{c|pitch}}||integer||Define o pitch do ator em graus (útil para [[model]]s).
|-
|{{c|renderstyle}}||string||Define o {{Property|RenderStyle|estilo de renderização}} do ator, substituindo o padrão da classe. Os valores possíveis podem ser:
*{{c|Normal}}
*{{c|None}}
*{{c|Add}} ou {{c|Additive}}
*{{c|Subtract}} ou {{c|Subtractive}}
*{{c|Stencil}}
*{{c|AddStencil}}
*{{c|TranslucentStencil}}
*{{c|Translucent}}
*{{c|Fuzzy}}
*{{c|OptFuzzy}}
*{{c|Soultrans}}
*{{c|Shaded}}
*{{c|AddShaded}}
*{{c|Shadow}}
O valor padrão é uma string vazia para não alterar.
|-
|{{c|roll}}||integer||Define o roll do ator em graus (útil para [[model]]s).
|-
|{{c|scale}}||float||Define a escala vertical e horizontal do ator.
|-
|{{c|scalex}}||float||Define a escala vertical do ator.
|-
|{{c|scaley}}||float||Define a escala horizontal do ator.
|-
|{{c|score}}||integer||Define o [[score]] do ator, substituindo o padrão da classe.
|}
[[Category:Glossary]]

Tag

2026-03-06T20:42:35Z

MegaManx3: Criou página com 'O '''tag''' é um número anexado a um sector, uma linedef ou um thing. O tag de uma coisa (thing) geralmente é chamado de TID. O tag é usado para se referir ao setor, linedef ou thing marcado por meio de vários action specials e built-in ACS functions. Vários objetos podem compartilhar o mesmo tag e serão afetados pelos mesmos efeitos. Mapas UDMF têm a capacidade de ter múltiplos tags por linha ou setor. Os formatos de mapa Doom e Hexen n...'

O '''tag''' é um número anexado a um [[sector]], uma [[linedef]] ou um [[thing]]. O tag de uma coisa (thing) geralmente é chamado de [[TID]]. O tag é usado para se referir ao setor, linedef ou thing marcado por meio de vários [[action specials]] e [[built-in ACS functions]]. Vários objetos podem compartilhar o mesmo tag e serão afetados pelos mesmos efeitos.

Mapas UDMF têm a capacidade de ter múltiplos tags por linha ou setor. Os formatos de mapa Doom e Hexen não permitem isso. Things não podem ter múltiplos TIDs independentemente do formato do mapa.

Veja a seção de propriedades UDMF de [[Sector|esta página]] para mais informações sobre como aplicar múltiplos IDs a setores e [[linedef|linhas]].
[[Category:Glossary]]

TID

2026-03-06T20:38:48Z

MegaManx3: Criou página com 'O '''TID''', ou '''Thing ID''', é o tag de uma coisa (thing). Este identificador não deve ser confundido com nenhum dos outros números mágicos que podem se referir a um thing: um mesmo TID pode ser compartilhado por vários actors de diferentes classes, e ele não corresponde a uma classe de ator em particular. Category:Glossary'

O '''TID''', ou '''Thing ID''', é o [[tag]] de uma coisa (thing). Este identificador não deve ser confundido com nenhum dos outros [[magic numbers|números mágicos]] que podem se referir a um [[thing]]: um mesmo TID pode ser compartilhado por vários [[actor]]s de diferentes [[classes]], e ele não corresponde a uma classe de ator em particular.
[[Category:Glossary]]

ActivatorTID

2026-03-06T20:38:23Z

MegaManx3: Criou página com 'int '''ActivatorTID''' (void) == Uso == Retorna o TID do ator que ativou o script. === Valor de retorno === O TID do ator que ativou o script. == Exemplos == Pode ser usado para uma linha que monstros podem acionar, para verificar se foi um monstro que a acionou. script 1 (void) { if (ActivatorTID () == 999) Print (s:"Você não é um zumbi"); else DamageThing (0); // mata ele } script 10 {{SType|ENTER}} { ...'

int '''ActivatorTID''' (void)

== Uso ==

Retorna o [[TID]] do ator que ativou o script.

=== Valor de retorno ===

O TID do ator que ativou o script.

== Exemplos ==

Pode ser usado para uma linha que monstros podem acionar, para verificar se foi um monstro que a acionou.

script 1 (void)
{
if ([[ActivatorTID]] () == 999)
[[Print]] (s:"Você não é um zumbi");
else
[[DamageThing]] (0); // mata ele
}

script 10 {{SType|ENTER}}
{
[[Thing_ChangeTID]] (0, 999);
}

O script ENTER define os TIDs do jogador como 999 (já que 0 normalmente implica o ativador do script). O script número 1 verifica se o ativador tem TID 999, ou seja, se é um jogador, e se for, avisa isso. Caso contrário, ele mata.

Isso pode ser útil se você tiver marines com script como aliados e não quiser que eles sejam submetidos ao mesmo tratamento que outros monstros.

[[category:ACS Information functions]]

VectorAngle

2026-03-06T20:28:00Z

MegaManx3: Criou página com '__NOTOC__ {{note|Esta página é sobre uma função de ACS. Para uma expressão {{c|atan2}} em ZScript, veja '''aqui'''.}} fixed '''VectorAngle''' (int ''x'', int ''y'') == Uso == Retorna o ângulo em ponto fixo do vetor (''x'',''y''). Os ângulos são medidos a partir do leste e avançando no sentido anti-horário. Esta função é mais comumente conhecida como ''atan2''. Para obter o valor de '...'

__NOTOC__
{{note|Esta página é sobre uma função de [[ACS]]. Para uma expressão {{c|atan2}} em [[ZScript]], veja [[DECORATE_expressions#Trigonometry_functions|'''aqui''']].}}

fixed '''VectorAngle''' (int ''x'', int ''y'')

== Uso ==

Retorna o [[Definitions|ângulo em ponto fixo]] do vetor (''x'',''y''). Os ângulos são medidos a partir do leste e avançando no sentido anti-horário.

Esta função é mais comumente conhecida como ''atan2''. Para obter o valor de ''atan(x)'', use <tt>VectorAngle(1.0, x)</tt>

=== Parâmetros ===

* ''x'', ''y'': Coordenadas do ponto final do vetor.

=== Valor de retorno ===

[[Definitions|Ângulo em ponto fixo]] do vetor (''x'',''y'').

== Exemplos ==

Este script vai imprimir um pequeno ^ na parte de baixo da tela do jogador apontando para o ator com TID definido como 1:

script 1 [[Script types|ENTER]]
{
int vang, angle;
while({{const|TRUE}})
{
vang = [[VectorAngle]] ([[GetActorX]] (1) - [[GetActorX]] (0), [[GetActorY]] (1) - [[GetActorY]] (0));
angle = (vang - [[GetActorAngle]] (0) + 1.0) % 1.0;

if (angle < 0.2 || angle > 0.8)
{
int sx = 320 - (320 * [[Sin]] (angle) / [[Cos]] (angle));

[[SetHudSize]] (640, 480, 0);
[[HudMessage]] (s:"^"; {{const|HUDMSG_PLAIN}}, 1, {{const|CR_RED}}, sx * 1.0, 480.2, 0);
}
else
{
[[HudMessage]] (s:""; {{const|HUDMSG_PLAIN}}, 1, 0, 0, 0, 0);
}

[[Delay]] (1);
}
}

[[category:ACS Math functions]]

StrLen

2026-03-06T18:48:16Z

MegaManx3: Criou página com '__NOTOC__ int '''StrLen''' (str ''string'') == Uso == Retorna o comprimento da string especificada por ''string''. Note que todas as strings em ACS são estáticas, ou seja, elas não são criadas dinamicamente, então não é realmente necessário usar esta função a menos que você tenha muitas strings armazenadas em uma library em algum lugar — como em ''Daedalus'' — e você precise de delays corretos para um HudMessage. A existência...'

__NOTOC__
int '''StrLen''' (str ''string'')

== Uso ==

Retorna o comprimento da string especificada por ''string''. Note que todas as strings em ACS são estáticas, ou seja, elas não são criadas dinamicamente, então não é realmente necessário usar esta função a menos que você tenha muitas strings armazenadas em uma [[library]] em algum lugar — como em ''Daedalus'' — e você precise de delays corretos para um [[HudMessage]]. A existência de [[StrParam]] torna esta função mais útil, no entanto.

=== Parâmetros ===

* ''string'': A string cujo comprimento queremos saber.

=== Valor de retorno ===

Comprimento (a contagem de caracteres) da string fornecida.

== Exemplos ==

Este script imprime uma string e seu comprimento:

script 1 (void)
{
str thestring = "This is the string.";

[[Print]] (s:thestring, i:[[StrLen]] (thestring));
}

[[category:ACS Math functions]] [[category:ACS String operations]]

Sqrt

2026-03-06T18:47:40Z

MegaManx3: Criou página com 'int '''Sqrt''' (int ''number'') fixed '''FixedSqrt''' (fixed ''number'') == Uso == Retorna a raiz quadrada de um número inteiro ou de ponto fixo. === Parâmetros === * ''number'': Valor do qual obter a raiz quadrada. === Valor de retorno === Ou a raiz quadrada arredondada do número como inteiro, ou como ponto fixo. == Cálculo manual == Em versões antigas do ZDoom, a função não é embutida no ACS, então aqui estão várias que funcionam bem. Note que, pa...'

int '''Sqrt''' (int ''number'')

fixed '''FixedSqrt''' (fixed ''number'')

== Uso ==

Retorna a raiz quadrada de um número inteiro ou de ponto fixo.

=== Parâmetros ===

* ''number'': Valor do qual obter a raiz quadrada.

=== Valor de retorno ===

Ou a raiz quadrada arredondada do número como inteiro, ou como ponto fixo.

== Cálculo manual ==
Em versões antigas do ZDoom, a função não é embutida no ACS, então aqui estão várias que funcionam bem. Note que, para a distância entre dois objetos, a função [[distance]] pode ser mais rápida.

Esta versão usa o método de Newton, em que a solução converge quadraticamente a partir do chute inicial. Esta função foi comparada com as duas seguintes e é pelo menos 5 a 10 vezes mais rápida em uso normal.
function int sqrt(int number)
{
if(number <= 3) { return number > 0; }

int oldAns = number >> 1, // chute inicial
newAns = (oldAns + number / oldAns) >> 1; // primeira iteração

// método iterativo principal
while(newAns < oldAns)
{
oldAns = newAns;
newAns = (oldAns + number / oldAns) >> 1;
}

return oldAns;
}

Esta é uma versão mais simples, porém mais lenta, de uma função de raiz quadrada. Ela arredonda a raiz para cima ou para baixo.

function int sqrt (int x)
{
int r;
x = x + 1 >> 1;
while (x > r)
x -= r++;
return r;
}

Se você precisar de uma função que arredonde para baixo, esta funcionará. Baseada em [http://snippets.dzone.com/posts/show/2715 este algoritmo].
function int isqrt (int n)
{
int a;
for (a=0;n>=(2*a)+1;n-=(2*a++)+1);
return a;
}

Esta fórmula baseada em amostragem processa valores fixos e retorna um resultado fixo cuja precisão é definida pelo inteiro ''samples'', e retorna zero se o número de entrada for negativo.
function int sqrt(int number)
{
int samples=15; // Amostras para precisão

if (number == 1.0) return 1.0;
if (number <= 0) return 0;
int val = samples<<17 + samples<<19; //x*10 = x<<1 + x<<3
for (int i=0; i<samples; i++)
val = (val + FixedDiv(number, val)) >> 1;

return val;
}

Este é o mesmo de cima, mas otimizado para 15 amostras
function int sqrt(int number)
{
if (number == 1.0) return 1.0;
if (number <= 0) return 0;
int val = 150.0;
for (int i=0; i<15; i++)
val = (val + FixedDiv(number, val)) >> 1;

return val;
}

[[category:Sample ACS functions]]
[[category:ACS Math functions]]

Sin

2026-03-06T18:46:54Z

MegaManx3: Criou página com '__NOTOC__ fixed '''Sin''' (int ''angle'') == Uso == Retorna o valor do seno de ''angle''. === Parâmetros === * ''angle'': O valor de ângulo em ponto fixo para o qual calcular o seno. === Valor de retorno === Retorna o valor do seno em ponto fixo. == Exemplo == Este script spawna dois {{Class|Medikit}}s à esquerda e à direita do ativador quando ativado. script 1 (void) { int x = GetActorX (0...'

__NOTOC__
fixed '''Sin''' (int ''angle'')

== Uso ==

Retorna o valor do seno de ''angle''.

=== Parâmetros ===

* ''angle'': O valor de [[Definitions#Fixed point angles|ângulo em ponto fixo]] para o qual calcular o seno.

=== Valor de retorno ===

Retorna o valor do seno em [[Fixed point number|ponto fixo]].

== Exemplo ==

Este script spawna dois {{Class|Medikit}}s à esquerda e à direita do ativador quando ativado.

script 1 (void)
{
int x = [[GetActorX]] (0);
int y = [[GetActorY]] (0);
int z = [[GetActorZ]] (0) + 32.0;
int angle = [[GetActorAngle]] (0);

[[Spawn]] ("{{Class|Medikit}}", x + [[cos]] (angle + 0.25) * 32, y + [[sin]] (angle + 0.25) * 32, z);
[[Spawn]] ("{{Class|Medikit}}", x + [[cos]] (angle + 0.75) * 32, y + [[sin]] (angle + 0.75) * 32, z);
}

==Veja também==
* [[Cos]]
[[category:ACS Math functions]]

Round

2026-03-06T18:46:17Z

MegaManx3: Criou página com '__NOTOC__ fixed '''Round''' (fixed ''value'') ==Uso== Arredonda o valor especificado para o número inteiro mais próximo. ===Valor de retorno=== O valor após o arredondamento, como um número de ponto fixo. ==Função customizada== {{note|A seguir está uma implementação não nativa da função, para versões do GZDoom anteriores à 2.4.0.}} Esta função implementa arredondamento. Ao realizar a operação de bitshift em um número de ponto fixo, o...'

__NOTOC__
fixed '''Round''' (fixed ''value'')

==Uso==
Arredonda o valor especificado para o número inteiro mais próximo.

===Valor de retorno===
O valor após o arredondamento, como um número de ponto fixo.

==Função customizada==
{{note|A seguir está uma implementação não nativa da função, para versões do GZDoom anteriores à 2.4.0.}}
Esta função implementa arredondamento. Ao realizar a operação de bitshift em um número de [[fixed point|ponto fixo]], o que você está fazendo na prática é simplesmente cortar o final do número, a parte que é menor que 1. Então '''0.5 >> 16''' retornará '''0'''. Pode haver casos em que você queira, em vez disso, arredondar valores de 0.5 ou maiores para o inteiro mais próximo ao convertê-los para um inteiro, por exemplo ao definir uma posição absoluta para um hudmessage.

Se você precisa arredondar um número para o inteiro mais próximo, mas precisa que o número resultante seja um [[fixed point|ponto fixo]], você pode simplesmente fazer o bitshift de volta na direção oposta usando '''round(number) << 16'''.

// Retorna valor inteiro
function int round(int fixedNumber)
{
return (fixedNumber + 0.5) >> 16;
}
Versão que corta a parte decimal
// Retorna valor em ponto fixo
function int floor(int fixedNumber)
{
return fixedNumber & 0xFFFF0000;
}

==Exemplos==
{{noexamples}}

[[category:ACS Math functions]]
[[category:Sample ACS functions]]

Random

2026-03-06T18:45:13Z

MegaManx3: Criou página com '__NOTOC__ {{note|Esta página é sobre uma função de ACS. Para funções de geração aleatória em ZScript, veja '''aqui'''.}} int '''Random''' (int ''min'', int ''max'') == Uso == Retorna um inteiro aleatório entre ''min'' e ''max'' (inclusive). === Parâmetros === * ''min'': O valor mínimo a retornar. * ''max'': O valor máximo a retornar. === Valor de retorno === Um inteiro aleatório entre ''min'' e...'

__NOTOC__
{{note|Esta página é sobre uma função de [[ACS]]. Para funções de geração aleatória em [[ZScript]], veja '''[[DECORATE_expressions#Random_number_functions|aqui]]'''.}}

int '''Random''' (int ''min'', int ''max'')

== Uso ==

Retorna um inteiro aleatório entre ''min'' e ''max'' (inclusive).

=== Parâmetros ===

* ''min'': O valor mínimo a retornar.
* ''max'': O valor máximo a retornar.

=== Valor de retorno ===

Um inteiro aleatório entre ''min'' e ''max'' (inclusive).

== Exemplos ==

Este script causa dano ao ativador com um valor de 1 a 10 quando ativado:

script 1 (void)
{
[[DamageThing]] ([[Random]] (1, 10));
}

Você também pode usar números de ponto fixo; este script faz o ativador olhar para uma direção aleatória:

script 1 (void)
{
[[SetActorAngle]] (0, [[Random]] (0, 1.0));
}

[[category:ACS Math functions]]

Floor (ACS function)

2026-03-06T18:44:28Z

MegaManx3: Criou página com '__NOTOC__ fixed '''Floor''' (fixed ''value'') ==Uso== Arredonda o valor especificado para o menor número inteiro. ===Valor de retorno=== O valor após o arredondamento, como um número de ponto fixo. ==Exemplos== Isto irá print "Value is 2": <syntaxhighlight lang="csharp"> script "FlooredTest" (void) { PrintBold(s: "Value is ", f: Floor(2.5)); } </syntaxhighlight> category:ACS Math functions'

__NOTOC__
fixed '''Floor''' (fixed ''value'')

==Uso==
Arredonda o valor especificado para o menor número inteiro.

===Valor de retorno===
O valor após o arredondamento, como um número de ponto fixo.

==Exemplos==
Isto irá [[print]] "Value is 2":
<syntaxhighlight lang="csharp">
script "FlooredTest" (void)
{
PrintBold(s: "Value is ", f: Floor(2.5));
}
</syntaxhighlight>

[[category:ACS Math functions]]

FixedSqrt

2026-03-06T15:18:48Z

Cos

2026-03-06T15:17:42Z

MegaManx3: Criou página com '__NOTOC__ fixed '''Cos''' (int ''angle'') == Uso == Retorna o valor do cosseno de ''angle''. === Parâmetros === * ''angle'': O valor de ângulo em ponto fixo para o qual calcular o cosseno. === Valor de retorno === Retorna o valor do cosseno em ponto fixo. == Exemplo == Este script spawna dois {{Class|Medikit}}s à esquerda e à direita do ativador quando ativado. script 1 (void) { int x = GetAc...'

__NOTOC__
fixed '''Cos''' (int ''angle'')

== Uso ==

Retorna o valor do cosseno de ''angle''.

=== Parâmetros ===

* ''angle'': O valor de [[Definitions#Fixed point angles|ângulo em ponto fixo]] para o qual calcular o cosseno.

=== Valor de retorno ===

Retorna o valor do cosseno em [[fixed point number|ponto fixo]].

== Exemplo ==

Este script spawna dois {{Class|Medikit}}s à esquerda e à direita do ativador quando ativado.

script 1 (void)
{
int x = [[GetActorX]] (0);
int y = [[GetActorY]] (0);
int z = [[GetActorZ]] (0) + 32.0;
int angle = [[GetActorAngle]] (0);

[[Spawn]] ("{{Class|Medikit}}", x + [[cos]] (angle + 0.25) * 32, y + [[sin]] (angle + 0.25) * 32, z);
[[Spawn]] ("{{Class|Medikit}}", x + [[cos]] (angle + 0.75) * 32, y + [[sin]] (angle + 0.75) * 32, z);
}

==Veja também==
* [[Sin]]
[[category:ACS Math functions]]

Ceil

2026-03-06T15:17:02Z

MegaManx3: Criou página com '__NOTOC__ fixed '''Ceil''' (fixed ''value'') ==Uso== Arredonda o valor especificado para o maior número inteiro. ===Valor de retorno=== O valor após o arredondamento, como um número de ponto fixo. ==Função customizada== {{note|A seguir está uma implementação não nativa da função, para versões do GZDoom anteriores à 2.4.0.}} Mapeia um valor de ponto fixo para o maior número inteiro. function int ceil (Data_types#In...'

__NOTOC__
fixed '''Ceil''' (fixed ''value'')

==Uso==
Arredonda o valor especificado para o maior número inteiro.

===Valor de retorno===
O valor após o arredondamento, como um número de ponto fixo.

==Função customizada==
{{note|A seguir está uma implementação não nativa da função, para versões do GZDoom anteriores à 2.4.0.}}
Mapeia um valor de ponto fixo para o maior número inteiro.
[[Functions|function]] [[Data_types#Integer|int]] ceil ([[Data_types#Integer|int]] x)
{
return (x + 65535) & 0xFFFF0000;
}

==Exemplos==
{{noexamples}}

[[category:ACS Math functions]]
[[category:Sample ACS functions]]

TagWait

2026-03-06T15:15:01Z

MegaManx3: Criou página com 'void '''TagWait''' (int ''tag''); == Uso == Atrasa o script de onde '''TagWait''' é chamado até que o setor com o tag especificado por ''tag'' tenha parado de se mover (certifique-se de não fazer isso com um setor oscilando (waggling) ou um que esteja em movimento perpétuo, porque o script ficará aguardando para sempre). '''TagWait''' sempre aguardará 1 tic mesmo que o setor não esteja se movendo. ===...'

void '''TagWait''' (int ''tag'');

== Uso ==

Atrasa o script de onde '''TagWait''' é chamado até que o setor com o tag especificado por ''tag'' tenha parado de se mover (certifique-se de não fazer isso com um setor [[Floor_Waggle|oscilando (waggling)]] ou um que esteja em movimento [[Plat_PerpetualRaise|perpétuo]], porque o script ficará aguardando para sempre). '''TagWait''' sempre aguardará 1 [[Definitions#Tic|tic]] mesmo que o setor não esteja se movendo.

=== Parâmetros ===
* ''tag'': O tag de setor a aguardar.

== Exemplos ==

Este script faz uma porta com tag abrir e imprime uma mensagem para todos os jogadores quando isso estiver concluído.

script 1 (int sector)
{
[[PrintBold]] (s:"Abrindo as portas do hangar...");
[[Door_Open]] (sector, 5, 0);
[[TagWait]] (sector);
[[PrintBold]] (s:"Portas do hangar agora abertas!");
}

As duas primeiras linhas iniciam a abertura da porta e avisam ao(s) jogador(es) que isso está acontecendo. Note que a porta está abrindo a uma velocidade de 5, que é bem lenta (o que você esperaria para uma grande porta de hangar). O script então usa '''TagWait''' para esperar um tempo não especificado antes de a porta realmente abrir. Quando abre, isso é informado.

A vantagem de '''TagWait''' aqui é que você pode usar o mesmo script em muitas portas de hangar apesar de diferenças de altura e, portanto, de tempo de abertura. Ou então, você pode modificar o tamanho da sua própria porta de hangar ou a velocidade do script e a mensagem de “aberta” sempre chegará exatamente no momento certo.

Note que, ao usar isso com um elevador, o script esperará até que o elevador tenha terminado completamente sua sequência de movimento, isto é, até que ele tenha retornado com sucesso à sua posição inicial.

[[category:ACS Wait functions]]

ScriptWait

2026-03-06T15:13:51Z

MegaManx3: Criou página com 'void '''ScriptWait''' (int ''script''); == Uso == Atrasa o script em que ele está contido até que o script especificado por ''script'' tenha concluído a execução. Se o script especificado não estiver em execução, este comando aguardará até que ele seja executado. Para named scripts, use NamedScriptWait. === Parâmetros === * ''script'': O número do script a aguardar. == Exemplos == A vantagem de '''ScriptWait''' é que ele pode segurar um scr...'

void '''ScriptWait''' (int ''script'');

== Uso ==

Atrasa o [[script]] em que ele está contido até que o script especificado por ''script'' tenha concluído a execução. Se o script especificado não estiver em execução, este comando aguardará até que ele seja executado. Para [[named script]]s, use [[NamedScriptWait]].

=== Parâmetros ===

* ''script'': O número do script a aguardar.

== Exemplos ==

A vantagem de '''ScriptWait''' é que ele pode segurar um script que só deve rodar uma vez. Digamos que exista um script que deve ser executado apenas uma vez para abrir uma porta (por exemplo, ele ativa quando o jogador destrói um painel de controle, o que só pode ser feito uma vez), mas o mapa exige que a porta seja destrancada antes disso. Caso a porta ainda esteja trancada, '''ScriptWait''' pode ser usado para segurar o script de execução única até que o script que destranca a porta tenha começado e terminado.

A seguir está um exemplo de implementação desse código. Ele é um tanto longo, mas bem direto.

bool locked = {{const|TRUE}};
script 1 (int sector)
{
if (locked)
{
[[Print]] (s:"Acesso de segurança necessário!");
[[ScriptWait]] (2);
}

[[Door_Open]] (sector, 20);
}

script 2 (int count)
{
while (count > 0)
{
[[HudMessage]] (i:count--; {{const|HUDMSG_PLAIN}}, 1,
{{const|CR_RED}}, 0.05, 0.95, 1.0);
[[Delay]] (1);
}

[[HudMessage]] (s:"Verificado!"; {{const|HUDMSG_PLAIN}}, 1,
{{const|CR_GOLD}}, 0.05, 0.95, 1.0);

locked = {{const|FALSE}};
}

O primeiro script é o script de execução única. Se a porta estiver trancada, ele avisa o usuário e espera o script de destrancar rodar e terminar. Depois disso, ou se a porta já estiver destrancada, a porta abre.

O segundo script recebe um parâmetro, que é a quantidade de frames para contar antes de destrancar. Note que count é exibido como <code>count--</code>, onde os dois sinais de menos são o operador de decremento. Depois que a contagem termina, a porta é destrancada.

{{script functions}}
[[category:ACS Wait functions]]

PolyWait

2026-03-06T15:12:38Z

MegaManx3: Criou página com 'void '''PolyWait''' (int ''polyid''); == Uso == '''PolyWait''' atrasa o script em que ele está até que o polyobject com o número de id especificado (''polyid'') tenha terminado seu movimento. Por exemplo, se for especificada uma porta de polyobject, então o script irá aguardar até que ela tenha sido redefinida para sua localização original. Esta função é útil se você quer que algo aconteça exatamente depois que um polyobject para de se mover (ou algo...'

void '''PolyWait''' (int ''polyid'');

== Uso ==

'''PolyWait''' atrasa o script em que ele está até que o [[polyobject]] com o número de id especificado (''polyid'') tenha terminado seu movimento. Por exemplo, se for especificada uma porta de polyobject, então o script irá aguardar até que ela tenha sido redefinida para sua localização original. Esta função é útil se você quer que algo aconteça exatamente depois que um polyobject para de se mover (ou algo semelhante).

=== Parâmetros ===

* ''polyid'': O id do [[polyobject]] a aguardar.

== Exemplos ==

O uso mais direto deste comando seria após [[Polyobj_Move]].

script 1 (void)
{
[[Polyobj_Move]] (0, 10, 128, 64);
[[PolyWait]] (0);
[[Print]] (s:"Entryway is open.");
}

Este script pode ser usado em uma adaptação do [http://zdoom.org/wiki/upload/polyexample.zip wad de exemplo (729 bytes)] na página [[polyobject]]. Em vez de usar um action special de linha nas portas, este script poderia ser acessado via um switch ou um thing special. Ele abre a porta e informa ao jogador que isso aconteceu.

[[category:ACS Wait functions]]

NamedScriptWait

2026-03-06T15:11:22Z

MegaManx3: Criou página com 'void '''NamedScriptWait''' (string ''script'') == Uso == Atrasa o script em que ele está contido até que o named script especificado por ''script'' tenha concluído a execução. Se o script especificado não estiver em execução, este comando aguardará até que ele seja executado. Para scripts numerados, use ScriptWait. === Parâmetros === * ''script'': O nome do script a aguardar. == Exemplos == {{noexamples}} {{script functions}} category:ACS Wait...'

void '''NamedScriptWait''' (string ''script'')

== Uso ==

Atrasa o script em que ele está contido até que o [[named script]] especificado por ''script'' tenha concluído a execução. Se o script especificado não estiver em execução, este comando aguardará até que ele seja executado. Para scripts numerados, use [[ScriptWait]].

=== Parâmetros ===

* ''script'': O nome do script a aguardar.

== Exemplos ==
{{noexamples}}

{{script functions}}
[[category:ACS Wait functions]]

Delay

2026-03-06T15:10:39Z

MegaManx3: Criou página com 'void '''Delay''' (int ''tics''); == Uso == Atrasa o script pelo tempo especificado. === Parâmetros === * ''tics'': A quantidade de tempo para esperar em tics. == Exemplos == '''Delay''' é um comando muito comum. Uma aplicação útil dele é evitar loops infinitos e o consequente erro “Runaway script x terminated”. Por exemplo: script 1 {{SType|Enter}} { int health; while ({{const|TRUE}}) { health = GetActorPr...'

void '''Delay''' (int ''tics'');

== Uso ==

Atrasa o script pelo tempo especificado.

=== Parâmetros ===

* ''tics'': A quantidade de tempo para esperar em [[Definitions#Tics|tics]].

== Exemplos ==

'''Delay''' é um comando muito comum. Uma aplicação útil dele é evitar loops infinitos e o consequente erro “Runaway script x terminated”. Por exemplo:

script 1 {{SType|Enter}}
{
int health;
while ({{const|TRUE}})
{
health = [[GetActorProperty]] (0, {{const|APROP_HEALTH}});
[[Print]] (s:"You have ", d:health, s:" health!");
}
}

Este script causará um erro de runaway porque ele tentará dizer ao jogador a vida dele infinitamente em um único tic, sem parar. Adicionar um pequeno delay resultará no efeito desejado: uma atualização inútil de vida que dura para sempre, informando ao jogador a própria vida.

script 1 {{SType|Enter}}
{
int health;
while ({{const|TRUE}})
{
health = [[GetActorProperty]] (0, {{const|APROP_HEALTH}});
[[Print]] (s:"You have ", d:health, s:" health!");
[[Delay]] (1); // Espera o próximo frame
}
}

----

O outro uso óbvio é atrasar eventos em um script. Por exemplo, o comportamento da porta usada na armadilha para a primeira chave em E1M6 de Doom pode ser simulado com um script assim:

script 12 (int sector, int speed, int seconds)
{
[[Door_Close]] (sector, speed);
[[Delay]] (35*seconds);
[[Door_Open]] (sector, speed);
}

Embora esse comportamento possa ser obtido usando [[Door_CloseWaitOpen]] de qualquer forma.

[[category:ACS Wait functions]]

ACS NamedExecuteWait

2026-03-06T15:09:19Z

MegaManx3: Criou página com '{{DISPLAYTITLE:ACS_NamedExecuteWait}}__NOTOC__ void '''ACS_NamedExecuteWait''' (string ''script'', int ''unused'', int ''arg1'', int ''arg2'', int ''arg3'') == Uso == Usar '''ACS_NamedExecuteWait''' é exatamente equivalente aos dois comandos a seguir: ACS_NamedExecute (script, 0, arg1, arg2, arg3); NamedScriptWait (script); Note que, enquanto você especificaria um número de mapa com ACS_NamedExecute, aqui você deve especificar 0 porque você só pod...'

{{DISPLAYTITLE:ACS_NamedExecuteWait}}__NOTOC__
void '''ACS_NamedExecuteWait''' (string ''script'', int ''unused'', int ''arg1'', int ''arg2'', int ''arg3'')

== Uso ==

Usar '''ACS_NamedExecuteWait''' é exatamente equivalente aos dois comandos a seguir:

[[ACS_NamedExecute]] (script, 0, arg1, arg2, arg3);
[[NamedScriptWait]] (script);

Note que, enquanto você especificaria um número de mapa com [[ACS_NamedExecute]], aqui você deve especificar 0 porque você só pode esperar por scripts no mapa atual.

=== Parâmetros ===

*''script'': O nome do script a executar.
*''unused'': Não é usado atualmente. Deve sempre ser definido como 0.
*''arg1'': Primeiro argumento passado para o script.
*''arg2'': Segundo argumento passado para o script.
*''arg3'': Terceiro argumento passado para o script.

==Exemplos==
Assim como [[ACS_ExecuteWait]], frequentemente há outras soluções para atingir o efeito desejado; no entanto, este método pode economizar repetição desnecessária de código.
script "WaitOnMonsters" (int tid)
{
while (ThingCount(T_NONE, tid))
;
}

script "MonsterChallengeA" (int tid, int tag, int speed)
{
[[print]](s:"Mate todos os monstros para abrir a porta.");
ACS_NamedExecuteWait("WaitOnMonsters", 0, tid);
[[Door_Open]](tag, speed, TRUE);
}

script "MonsterCallengeB" (int tid, int tag, int speed)
{
Print(s:"Mate todos os monstros para baixar o chão.");
ACS_NamedExecuteWait("WaitOnMonsters", 0, tid);
[[Floor_LowerToLowest]](tag, speed);
}

{{script functions}}
[[category:ACS Wait functions]]

ACS ExecuteWait

2026-03-06T15:08:18Z

MegaManx3: Criou página com 'void '''ACS_ExecuteWait''' (int ''script'', int ''unused'', int ''arg1'', int ''arg2'', int ''arg3''); == Usage == Using '''ACS_ExecuteWait''' is exactly equivalent to the following two commands: ACS_Execute (script, 0, arg1, arg2, arg3); ScriptWait (script); Note that where you would specify a map number with ACS_Execute, you must specify 0 here because you can only wait on scripts in the current map. === Parameters === *''script'': The script number...'

void '''ACS_ExecuteWait''' (int ''script'', int ''unused'', int ''arg1'', int ''arg2'', int ''arg3'');

== Usage ==

Using '''ACS_ExecuteWait''' is exactly equivalent to the following two commands:

[[ACS_Execute]] (script, 0, arg1, arg2, arg3);
[[ScriptWait]] (script);

Note that where you would specify a map number with [[ACS_Execute]], you must specify 0 here because you can only wait on scripts in the current map.

=== Parameters ===

*''script'': The script number to execute.
*''unused'': Not currently used. Should always be set to 0.
*''arg1'': First argument passed to the script.
*''arg2'': Second argument passed to the script.
*''arg3'': Third argument passed to the script.

==Examples==

This function is rather uncommon, but does have its uses. A common use would be to wait on a scripted event. For example, if there were some sort of event or challenge that used a script at various points in the level, and at one point the player had to complete the event as part of another script, this command can be used rather than copying the challenge script twice. To elaborate, here is a script.

script 15 (int armytid, int sector)
{
[[Print]] (s:"Defeat the monsters for a prize!");

[[ACS_ExecuteWait]] (5, 0, armytid, 0, 0);

[[Ceiling_RaiseByValue]] (sector, 10, 64);
}

This script tells the player to defeat the monsters for a prize. Then it executes script 5 which could be script 5 as used [[ThingCount|here]]. After the success of script 5, a ceiling is raised, supposedly to reveal a prize. As this script can be used elsewhere, script 15 is like a wrapper for script 5 which offers a prize.

{{script functions}}
[[category:ACS Wait functions]]
{{DISPLAYTITLE:ACS_ExecuteWait}}

ScriptCall

2026-03-06T15:07:09Z

MegaManx3: Criou página com '__NOTOC__ '''ScriptCall''' (str ''classname'', str ''funcname'', ''args'') ==Uso== Executa uma função definida em script. Se o primeiro argumento da função a executar for do tipo {{c|Actor}}, o ativador do script é passado e armazenado nesse argumento. Isso permite que o ativador seja acessado por essa função. ===Parâmetros=== *''classname'': o nome da classe de actor em que a função está definida. *''funcname'': o nome da função a executar. Ap...'

__NOTOC__
'''ScriptCall''' (str ''classname'', str ''funcname'', ''args'')

==Uso==
Executa uma função [[ZScript|definida em script]]. Se o primeiro argumento da função a executar for do tipo {{c|Actor}}, o ativador do script é passado e armazenado nesse argumento. Isso permite que o ativador seja acessado por essa função.

===Parâmetros===
*''classname'': o nome da classe de actor em que a função está definida.
*''funcname'': o nome da função a executar. Apenas funções '''[[ZScript_functions#Static|static]]''' são executáveis.
*''args'': os argumentos, se houver, a serem passados para a função especificada. Os tipos de argumentos que a função pode ter são ''int'', ''bool'', ''double'', ''string'', ''name'', ''color'' e ''sound''. ''double'' é passado como um valor de ponto fixo, ''color'' como um valor inteiro, e ''name'' e ''sound'' como strings.

===Valor de retorno===
O valor que a função executada retorna. O tipo do valor é o mesmo dos tipos dos argumentos passados, além de ''void''.

==Exemplos==
Este script dá ao jogador um [[TID]] único. Isso é obtido executando {{c|[[FindUniqueTid]]}}, que é definido em {{c|{{Class|Actor}}}}.
script "SetPlayerTID" {{SType|Enter}}
{
// Apenas se o jogador ainda não tiver um TID.
if([[ActivatorTID]]() == 0)
{
int ptid = [[ScriptCall]]("Actor", "FindUniqueTid", 0, 0);
[[Thing_ChangeTID]](0, ptid);
[[Log]](s:"TID alterado para ", d:ptid); // Mostra uma mensagem.
}
}

Note que o ACS já tem [[UniqueTID|uma função que pode obter um TID único]]. O exemplo acima é para fins educacionais.

Se executada, esta função {{c|GivePresent}} dá ao ativador do script um item e registra uma mensagem. O item é especificado pelo argumento ''present''.
// Em [[ZScript]]:
class ExampleClass
{
static void GivePresent (Actor activator, string present)
{
// Apenas jogadores recebem o item.
if(activator && activator.player)
{
activator.[[A_GiveInventory]](present);
activator.[[A_Log]]("You received a wonderful present!", true);
}
}
}

// Em [[ACS]]:
script "GetGift" (void)
{
[[ScriptCall]]("ExampleClass", "GivePresent", "{{Class|Soulsphere}}");
}

[[Category:ACS]]

ACS NamedExecuteAlways

2026-03-06T15:06:06Z

MegaManx3: Criou página com '{{DISPLAYTITLE:ACS_NamedExecuteAlways}} bool '''ACS_NamedExecuteAlways''' (string ''script'', int ''map'', int ''s_arg1'', int ''s_arg2'', int ''s_arg3'') '''ACS_NamedExecuteAlways''' (string ''script'', int ''map'', int ''s_arg1'', int ''s_arg2'', int ''s_arg3'') == Uso == Variante de ACS_ExecuteAlways para named scripts. Há uma versão desta função em ACS e outra em DECORATE. Ambas se comportam de forma idêntica. No entanto, ela não está...'

{{DISPLAYTITLE:ACS_NamedExecuteAlways}}

bool '''ACS_NamedExecuteAlways''' (string ''script'', int ''map'', int ''s_arg1'', int ''s_arg2'', int ''s_arg3'') 
'''ACS_NamedExecuteAlways''' (string ''script'', int ''map'', int ''s_arg1'', int ''s_arg2'', int ''s_arg3'')

== Uso ==
Variante de [[ACS_ExecuteAlways]] para [[named script]]s.

Há uma versão desta função em [[ACS]] e outra em [[DECORATE]]. Ambas se comportam de forma idêntica.

No entanto, ela não está disponível como um [[action special]]: para chamar scripts nomeados a partir de um [[special]] de line ou thing, você precisa usar a variante não nomeada ([[ACS_ExecuteAlways]]) em [[UDMF]], com o argumento customizado <tt>arg0str</tt> definido para o nome do script — isso sobrescreverá o primeiro parâmetro.

=== Parâmetros ===
* ''script'': Nome do script a executar
* ''map'': Mapa que contém o script
* ''s_arg1'': Primeiro argumento passado para o script
* ''s_arg2'': Segundo argumento passado para o script
* ''s_arg3'': Terceiro argumento passado para o script

=== Valor de retorno ===
Retorna true se o script pôde ser executado com sucesso, false caso contrário. [[Deferred script]]s são sempre considerados bem-sucedidos.

==Exemplos==
Este exemplo dá uma cura completa única a um jogador quando ele está quase morto, se o jogador pegou um item especial. O item executa o script, enquanto o script monitora o status do jogador e ativa quando a vida do jogador é reduzida a 1.

Item em Decorate:
Actor AvoidDeath : {{Class|CustomInventory}}
{
{{Property|Inventory.MaxAmount}} 0
+{{flag|INVENTORY.AUTOACTIVATE}}
States
{
Use:
TNT1 A 0 [[ACS_NamedExecuteAlways]]("AvoidDeathScript", 0)
[[Stop]]
}
}
Script ACS:
script "AvoidDeathScript" (void)
{
[[SetPlayerProperty]](0, 1, {{const|PROP_BUDDHA}}); // Ativa o modo buddha para o jogador
while(1) // Loop permanente
{
if([[GetActorProperty]](0, {{const|APROP_HEALTH}}) <= 1) // Verifica se o jogador está ferido o suficiente para curar
{
[[SetPlayerProperty]](0, 0, {{const|PROP_BUDDHA}}); // Remove o modo buddha
[[GiveInventory]]("{{Class|Health}}", 100); // e cura o jogador
[[terminate]];
}
;
}
}

{{DEFAULTSORT:ExecuteAlways}}[[Category:ACS Script functions]][[Category:Decorate Script functions]]

{{script functions}}

ACS NamedExecuteWithResult

2026-03-06T15:04:57Z

MegaManx3: Criou página com '{{DISPLAYTITLE:ACS_NamedExecuteWithResult}}__NOTOC__ int '''ACS_NamedExecuteWithResult''' (string ''script'', int ''s_arg1'', int ''s_arg2'', int ''s_arg3'', int ''s_arg4'') == Uso == Variante de ACS_ExecuteWithResult para named scripts. Há uma versão desta função em ACS e outra em DECORATE. Ambas se comportam de forma idêntica. A versão DECORATE também pode ser chamada pelo alias mais curto '''CallACS''' em DECORATE expressions. Outro alias...'

{{DISPLAYTITLE:ACS_NamedExecuteWithResult}}__NOTOC__
int '''ACS_NamedExecuteWithResult''' (string ''script'', int ''s_arg1'', int ''s_arg2'', int ''s_arg3'', int ''s_arg4'')

== Uso ==
Variante de [[ACS_ExecuteWithResult]] para [[named script]]s.

Há uma versão desta função em [[ACS]] e outra em [[DECORATE]]. Ambas se comportam de forma idêntica. A versão DECORATE também pode ser chamada pelo alias mais curto '''CallACS''' em [[DECORATE expressions]]. Outro alias para esta função é '''ACS_ScriptCall''', que introduz a capacidade de a função ser chamada por objetos actor arbitrários, assim como pelo objeto {{c|self}} (veja o segundo exemplo abaixo). Este alias é exclusivo de DECORATE e [[ZScript]].

ACS_(Named)ExecuteWithResult tem uma pequena diferença além de retornar um valor. Eles executam imediatamente assim que são chamados, enquanto os outros tipos geralmente esperam um tic antes de agir.

No entanto, ela não está disponível como um [[action special]]: para chamar scripts nomeados a partir de um [[special]] de line ou thing, você precisa usar a variante não nomeada ([[ACS_ExecuteWithResult]]) em [[UDMF]], com o argumento customizado <tt>arg0str</tt> definido para o nome do script — isso sobrescreverá o primeiro parâmetro.

=== Parâmetros ===
* ''script'': Nome do script a executar
* ''s_arg1'': Primeiro argumento passado para o script
* ''s_arg2'': Segundo argumento passado para o script
* ''s_arg3'': Terceiro argumento passado para o script
* ''s_arg4'': Quarto argumento passado para o script

=== Valor de retorno ===
Retorna o valor de retorno do script executado. Veja [[SetResultValue]].

==Exemplos==
Este exemplo mostra um item similar ao item {{Class|ArtiHealingRadius|Mystic Ambit}} de ''[[Hexen]]'': verifica qual classe de jogador usa um item e aplica um efeito diferente.

Item em Decorate:
Actor ClassBoost : CustomInventory
{
{{Property|Inventory.MaxAmount}} 25
{{Property|Inventory.InterHubAmount}} 25
+{{flag|INVENTORY.INVBAR}}
{{Property|Inventory.Icon}} "ARTIHRAD"
States
{
Spawn:
HRAD ABCDEFGHIJKLMNOP 4 Bright
[[Loop]]
Use:
TNT1 A 0 [[A_JumpIf]]([[ACS_NamedExecuteWithResult|CallACS]]("CheckPlayerClass", 0, 0, 0) == 0, "NormalPlayer")
TNT1 A 0 [[A_JumpIf]]([[ACS_NamedExecuteWithResult|CallACS]]("CheckPlayerClass", 0, 0, 0) == 1, "AlternatePlayer")
[[Fail]]
NormalPlayer:
TNT1 A 0 [[A_RadiusGive]]("{{Class|Health}}", 256, {{const|RGF_PLAYERS}} | {{const|RGF_GIVESELF}}, random(50, 90))
[[Stop]]
AlternatePlayer:
TNT1 A 0 [[A_RadiusGive]]("PowerImproveDamage", 256, {{const|RGF_PLAYERS}} | {{const|RGF_GIVESELF}}, 1)
[[Stop]]
}
}
Script ACS:
script "CheckPlayerClass" (void)
{
if([[CheckActorClass]](0, "DoomPlayer"))
{
;
[[terminate]];
}
else if([[CheckActorClass]](0, "AlternateDoomPlayer"))
{
;
[[terminate]];
}
}

Este item de exemplo demonstra o uso de ACS_ScriptCall. Ao ser pego, ele spawna um {{Class|BaronOfHell|baron of hell}} e faz duas chamadas de script ACS: uma feita pelo próprio baron of hell, e outra feita pelo actor que pegou o item.
class BaronSummoner : [[CustomInventory]]
{
States
{
Spawn:
SOUL ABCD 6 Bright;
Loop;

Pickup:
TNT1 A 0
{
bool res;
Actor mobj;
[res, mobj] = [[A_SpawnItemEx]]("{{Class|BaronOfHell}}", 100);

if (res && mobj)
{
// O chamador é o objeto baron of hell.
// Usar '''ACS_NamedExecuteWithResult''', em vez disso, é inaceitável aqui.
mobj.'''ACS_ScriptCall'''("SomeScript");

// O chamador é o objeto ''self'' (o actor que pegou o item).
// Usar '''ACS_NamedExecuteWithResult''', em vez disso, é aceitável aqui.
'''ACS_ScriptCall'''("SomeOtherScript");
}
}
Stop;
}
}

{{DEFAULTSORT:ExecuteWithResult}}[[Category:ACS Script functions]][[Category:Decorate Script functions]]

{{script functions}}

Predefinição:Noexamples

2026-03-06T15:03:20Z

MegaManx3: Criou página com '<noinclude>Place this template on action functions, ACS functions, and relevant action specials pages where no examples are listed. The proper location for this is under an Examples heading, which will of course be blank — otherwise this template wouldn't be needed. For instance: ==Examples== <nowiki>{{noexamples}}</nowiki> This code will result in this: ==Examples== </noinclude>{{note|image=link=...'

<noinclude>Place this template on [[action functions]], [[built-in ACS functions|ACS functions]], and relevant [[action specials]] pages where no examples are listed. The proper location for this is under an Examples heading, which will of course be blank — otherwise this template wouldn't be needed. For instance:

==Examples==
<nowiki>{{noexamples}}</nowiki>
This code will result in this:
==Examples==
</noinclude>{{note|image=[[File:Nuvolachalk.png|link=]]|text=This article lists no examples. If you make use of this feature in your own project(s) or know of any basic examples that could be shared, please {{plainlink|[{{SERVER}}{{localurl:{{NAMESPACE}}:{{PAGENAME}}|action=edit}} add them]}}. This will make it easier to understand for future authors seeking assistance. Your contributions are greatly appreciated.}}<noinclude>

The template should be removed when any examples are added.

===Exceptions===
Do not use this template on pages that cannot list a practical example (Ex: [[Line_SetIdentification]] can't be used in a script, so the only example we could provide would be a map, which is not practical for a wiki manual). This template is also unnecessary for articles that are unlikely to be updated, such as for features that have been [[:Category:Deprecated features|deprecated]] or are superseded and obsolete.</noinclude><includeonly>[[category:Articles without examples]]</includeonly>
<noinclude>[[Category:Maintenance templates]]</noinclude>

ACS NamedLockedExecuteDoor

2026-03-06T15:02:59Z

MegaManx3: Criou página com '{{DISPLAYTITLE:ACS_NamedLockedExecuteDoor}} bool '''ACS_NamedLockedExecuteDoor''' (string ''script'', int ''map'', int ''s_arg1'', int ''s_arg2'', int ''lock'') '''ACS_NamedLockedExecuteDoor''' (string ''script'', int ''map'', int ''s_arg1'', int ''s_arg2'', int ''lock'') == Uso == Variante de ACS_LockedExecuteDoor para named scripts. Há uma versão desta função em ACS e outra em DECORATE. Ambas se comportam de forma idêntica. No entanto, el...'

{{DISPLAYTITLE:ACS_NamedLockedExecuteDoor}}

bool '''ACS_NamedLockedExecuteDoor''' (string ''script'', int ''map'', int ''s_arg1'', int ''s_arg2'', int ''lock'') 
'''ACS_NamedLockedExecuteDoor''' (string ''script'', int ''map'', int ''s_arg1'', int ''s_arg2'', int ''lock'')

== Uso ==
Variante de [[ACS_LockedExecuteDoor]] para [[named script]]s.

Há uma versão desta função em [[ACS]] e outra em [[DECORATE]]. Ambas se comportam de forma idêntica.

No entanto, ela não está disponível como um [[action special]]: para chamar scripts nomeados a partir de um [[special]] de line ou thing, você precisa usar a variante não nomeada ([[ACS_LockedExecuteDoor]]) em [[UDMF]], com o argumento customizado <tt>arg0str</tt> definido para o nome do script — isso sobrescreverá o primeiro parâmetro.

=== Parâmetros ===
* ''script'': Nome do script a executar
* ''map'': Mapa que contém o script
* ''s_arg1'': Primeiro argumento passado para o script
* ''s_arg2'': Segundo argumento passado para o script
* ''lock'': Chave necessária, se houver (veja [[key types]])

=== Valor de retorno ===
Retorna true se o script pôde ser executado com sucesso, false caso contrário. [[Deferred script]]s são sempre considerados bem-sucedidos.

==Exemplos==
{{noexamples}}
{{DEFAULTSORT:LockedExecuteDoor}}[[Category:ACS Script functions]][[Category:Decorate Script functions]]

{{script functions}}

ACS NamedLockedExecute

2026-03-06T15:02:09Z

MegaManx3: Criou página com '{{DISPLAYTITLE:ACS_NamedLockedExecute}} bool '''ACS_NamedLockedExecute''' (string ''script'', int ''map'', int ''s_arg1'', int ''s_arg2'', int ''lock'') '''ACS_NamedLockedExecute''' (string ''script'', int ''map'', int ''s_arg1'', int ''s_arg2'', int ''lock'') == Uso == Variante de ACS_LockedExecute para named scripts. Há uma versão desta função em ACS e outra em DECORATE. Ambas se comportam de forma idêntica. No entanto, ela não está dis...'

{{DISPLAYTITLE:ACS_NamedLockedExecute}}

bool '''ACS_NamedLockedExecute''' (string ''script'', int ''map'', int ''s_arg1'', int ''s_arg2'', int ''lock'') 
'''ACS_NamedLockedExecute''' (string ''script'', int ''map'', int ''s_arg1'', int ''s_arg2'', int ''lock'')

== Uso ==
Variante de [[ACS_LockedExecute]] para [[named script]]s.

Há uma versão desta função em [[ACS]] e outra em [[DECORATE]]. Ambas se comportam de forma idêntica.

No entanto, ela não está disponível como um [[action special]]: para chamar scripts nomeados a partir de um [[special]] de line ou thing, você precisa usar a variante não nomeada ([[ACS_LockedExecute]]) em [[UDMF]], com o argumento customizado <tt>arg0str</tt> definido para o nome do script — isso sobrescreverá o primeiro parâmetro.

=== Parâmetros ===
* ''script'': Nome do script a executar
* ''map'': Mapa que contém o script
* ''s_arg1'': Primeiro argumento passado para o script
* ''s_arg2'': Segundo argumento passado para o script
* ''lock'': Chave necessária, se houver (veja [[key types]])

=== Valor de retorno ===
Retorna true se o script pôde ser executado com sucesso, false caso contrário. [[Deferred script]]s são sempre considerados bem-sucedidos.

==Exemplos==
{{noexamples}}
{{DEFAULTSORT:LockedExecute}}[[Category:ACS Script functions]][[Category:Decorate Script functions]]

{{script functions}}