Levelord - Doom Bible

Guia do Levelord – Black Edition

- 1 -


- 2 -

DOOM: Guia do Levelord

Construindo e Modificando o DOOM

por Laete Meireles ‘Drak[X]’

1° Edição .:. Black Edition .:.

.:. REVISÃO FINAL .:.

BrDOOM – Portal brasileiro dedicado ao jogo DOOM ( http://www.brdoom.com )

BrDOOM Fórum – Fórum oficial do portal ( http://www.brdoom.com/_forum )

[DBR] Clan – Primeiro Clã brasileiro de jogadores ( http://www.dbr.brdoom.com )

[DRB] DOOM Resources Brasil ( http://www.brdoom.com/drb )

.:. DOOM Resources Brasil .:.

Todos os direitos reservados.

© Copyright 2006-2008 por Laete Meireles “Drak[X]”

DOOM, DOOM II e Ultimate DOOM, são marcas registradas de id Software, Inc., Atualizado: Domingo 24, Fevereiro, 2008


- 3 -

AGRADECIMENTOS Faltariam folhas para agradecer e parabenizar todas as pessoas que contribuem para o desenvolvimento e a disseminação do DOOM aqui no Brasil. Parabéns a todos, desde os jogadores que se agarram a esse ideal com unhas e dentes, até aos programadores que elaboraram softwares que facilitam a vida dos jogadores. É somente com essa união que faremos do DOOM, não um simples jogo em 3° dimensão que marcou o início dos FPS com mais realismo, mas sim, o jogo que marcou uma nova era. A era dos doomers! CHANGELOG 1° edição .:. Black Edition .:. REVISÃO FINAL - 24/02/2008 Geral - Revisão final do guia sob o título Black Edition Geral - Correções ortográficas. 1° edição .:. Black Edition .:. 4/10/2007 Geral - Relançamento do guia como 1º edição sob o título Black Edition Geral - Reestruturação Geral. Geral - Acréscimo de texto sobre ACS Script. Geral - Acréscimo de texto sobre Source Ports. Geral - Correções ortográficas. 3° edição .:. Volume Especial .:. Geral - Acréscimo de texto. Geral - Exclusão do jogo Heretic (será lançado numa versão futura ou num guia em separado). Geral - Reorganizado o livro de forma a facilitar sua impressão. Geral - Correções ortográficas. 2° edição .:. Exclusão de diversos projetos, por estarem defasados. Geral - Reestruturação. Geral - Inclusão do jogo Heretic. Geral - Exclusão do apêndice Internet. Geral - Correção ortográfica. 1° edição .:. Lançamento oficial


- 4 -

ÍNDICE INTRODUÇÃO............................................................................................................................6 1 - O que é DOOM? ....................................................................................................................7 2 - Características do DOOM........................................................................................................9 3 - História (Enredo) ................................................................................................................10 4 - Elementos do Jogo ..............................................................................................................11 5 – Produção...........................................................................................................................15 5.1 - Níveis .............................................................................................................................16 5.2 - Gráficos ..........................................................................................................................16 5.3 - Som ...............................................................................................................................16 5.4 - Tecnologia.......................................................................................................................16 5.5 - Controvérsia....................................................................................................................17 5.6 - Plataformas .....................................................................................................................17 6 - Portabilização .....................................................................................................................19 6.1 - Confusão entre Portabilização e Emulação............................................................................19 6.2 - Exemplo de "O que seria uma portabilização" .......................................................................20 6.3 - Limite entre Portabilização e a Reescritura de Software..........................................................20 7 - Liberação do Código Fonte (Source-Code) ..............................................................................22 8 - Source-Ports ......................................................................................................................23 9 - Principais Source Ports.........................................................................................................24 9.1 - Boom e Variantes.............................................................................................................24 9.2 - PrBoom...........................................................................................................................24 9.3 - PrBoom + (PrBoom Plus)..................................................................................................24 9.4 - Marine’s Best Friend (MBF) ................................................................................................25 9.5 - Eternity Engine ................................................................................................................25 9.6 - ZDoom e Variantes...........................................................................................................25 9.7 - GZDoom .........................................................................................................................25 9.8 - csDoom ..........................................................................................................................26 9.9 - ZDaemon........................................................................................................................26 9.10 - Skulltag ........................................................................................................................26 9.11 - Odamex ........................................................................................................................26 9.12 - DOSDoom e Variantes.....................................................................................................27 9.13 - Doom Legacy.................................................................................................................27 9.14 - EDGE............................................................................................................................27 9.15 – Doomsday Engine ..........................................................................................................27 9.16 - nxDoom ........................................................................................................................28 10 – Jogos em Rede ou Internet ................................................................................................29 11 – Qual é a diferença entre IWAD e PWAD? ..............................................................................30 12 - Tirando Screenshots do Jogo...............................................................................................31 13 - Jogando Off-line (Single-Player) ..........................................................................................32 14 - Usando arquivos WAD externos...........................................................................................33 15 - Jogando através da linha de comando (Terminal)...................................................................34 16 - Códigos de Trapaça (Cheat Code) ........................................................................................37 17 - Editores de Mapas .............................................................................................................39 18 - Conhecendo o WadAuthor...................................................................................................40 18.1 - A Aparência do WadAuthor...............................................................................................40 18.2 - Guia de Botões...............................................................................................................41 19 - Configurando o WadAuthor .................................................................................................42 19.1 - Localização dos Arquivos WADs ........................................................................................42 19.2 - Opções (Options)............................................................................................................42 19.3 - Cores (Colors)................................................................................................................42 19.4 - Arquivos (Files) ..............................................................................................................43 19.5 - Geral (General) ..............................................................................................................43 19.6 - Barras de Ferramentas (Toolbars).....................................................................................44 19.7 - Visualizar (Views) ...........................................................................................................44


- 5 -

20 - Selecionando um Jogo .......................................................................................................45 21 - Criando um Mapa ..............................................................................................................46 21.1 - Criando a Primeira Sala ...................................................................................................46 23.2 - Mudando o Formato da Sala.............................................................................................47 23.3 - Girando e Redimensionando (Escalando) a Sala ..................................................................48 23.4 - Adicionando Jogadores e Inimigos.....................................................................................48 24 - Editando Propriedades dos Objetos do Mapa..........................................................................50 25 - Criando um Corredor .........................................................................................................51 25.1 - Conectando o Corredor a Sala Principal..............................................................................51 25.2 - Criando uma Porta Local..................................................................................................52 25.3 - Providenciando uma Saída ...............................................................................................53 25.4 - Jogando o Mapa .............................................................................................................55 26 - Edição Avançada de Mapas .................................................................................................56 26.1 - Criando uma Sala Secreta................................................................................................56 26.2 - Criando um Teleporter.....................................................................................................57 26.3 - Criando uma Escada Básica..............................................................................................58 26.4 - Criando uma Janela Padrão ..............................................................................................60 26.5 - Ajustes Finais.................................................................................................................65 27 - O Que é ACS Script? ..........................................................................................................67 28 - Dominando ACS Script .......................................................................................................69 28.1 - ACS Script Básico ...........................................................................................................69 28.2 - Estrutura de um Script ....................................................................................................69 28.3 - Comentários ..................................................................................................................70 28.4 - Variáveis .......................................................................................................................71 28.5 - Usando Variáveis ............................................................................................................72 29 - Criando um Script .............................................................................................................79 29.1 - Um Script Básico ............................................................................................................79 29.2 - Executando Ações num Script...........................................................................................82 30 - Criando um Script no Doom Builder .....................................................................................85 31 - Lista de Comandos ACS (ZDoom) ........................................................................................91 32 - PolyObjects ......................................................................................................................96 32.1 - Porta Dupla ...................................................................................................................96 33 - LUMPS.............................................................................................................................99 33.1 - Lumps Textuais ..............................................................................................................99 33.2 - Lumps Compilados..........................................................................................................99 34 – Operadores ( Apêndice ) .................................................................................................. 100 35 - Links Interessantes ......................................................................................................... 105 36 - Bibliografia..................................................................................................................... 107


- 6 -

INTRODUÇÃO

Desde o princípio, inúmeras pessoas fizeram muito mais que somente aceitar mudanças no suporte a arquivos no DOOM. Muitas pessoas trabalharam para criar programas utilitários e editores para tornar mais fácil para qualquer pessoa efetuar mudanças. Estas pessoas se tornaram mestres peritos no trabalho de construir arquivos (WAD) suplementares carregados pela engine de DOOM.

Após uma longa pesquisa na Internet e um ano de trabalho na construção e teste de arquivos

extras (WADs), eu resolvi colocar todo o meu conhecimento adquirido neste livro, você irá conhecer um pouco da história de DOOM – e seus sucessores – aprenderá a criar e modificar arquivos WADs, criando mapas novos e modificando os mapas já existentes.

Este livro também inclui um estudo básico sobre DOOM II (futuras versões deste livro também

irão tratar do Heretic e Hexen). Você perceberá depressa que este não é um livro ensinando como jogar estes jogos, nem será um livro sobre como jogar os add-ons (WADs extras) para estes jogos. Nem é um livro de documentação para um arquivo WAD particular ou programa utilitário em especial, com exceção dos programas WadAuthor e Doom Builder, estes serão os programas usados para criar mapas para DOOM, DOOM II.

Este livro não só lhe ensinará as dicas e truques de um dos maiores fenômenos de jogos para

computador de todos os tempos, mas também o apresentará a alguns dos mais altamente aclamados arquivos WADs disponíveis, também lhe ensinará a desenvolver seus próprios mundos através da observação e análise dos mapas criados por outros jogadores.

Em resumo, o colocará no caminho para o esclarecimento por meio de trabalho duro,

perseverança e claro, esforço próprio, você pode um dia se tornas um completo desenvolvedor de mapas para DOOM.

Este livro também inclui uma seleção de editores e outras ferramentas para você usar. Você

aprenderá a usar estas ferramentas com as pessoas que de fato os criaram. Como nenhum livro, website ou CD-ROM pode conter todos os arquivos que podem ser achados

ou usados, o episódio final do livro contém informações de onde você pode obter mais arquivos de DOOM. Também há informação de como e onde você pode distribuir seus próprios arquivos de DOOM. (Se você estiver interessado em DOOM, definitivamente há muitos lugares para ir e pessoas para ver!).

Bom, vamos iniciar a nossa jornada rumo ao Inferno! Jogadores! Atirem em tudo que se mover!!!


- 7 -

1 - O que é DOOM? DOOM. Quem teria pensado que esta simples palavra se tornaria o padrão pelo quais todos os outros jogos seriam analisados? Mas, afinal o que é DOOM? DOOM é um fenômeno! DOOM é um jogo rápido, com realidade virtual e uma espécie de efeito 3D, criado pela produtora ‘id Software’. DOOM também é muito, muito mais! Como nós esperamos mostrar para você neste livro.

DOOM (e seus add-ons - seqüências e níveis extras) é considerado o Estado de Arte dos jogos de

computador. DOOM é tremendamente popular e possui uma legião enorme de seguidores por todo mundo. Porém, este livro não é um manual para o jogador. Este livro é para as pessoas que querem criar os seus próprios níveis para DOOM (e para os jogos baseados nele!). São discutidos muitas características deste jogo, e muitos dos melhores editores e outros utilitários serão examinados em detalhes, porém, os editores que serão utilizados neste livro são o WadAuthor e Doom Builder. Todo esforço será feito para apresentar técnicas provadas e eficientes para que você possa fazer o que quiser com DOOM - de como a criar seus próprios níveis Singleplayer ou Multiplayer, ou mesmo alterar os níveis já existentes para o jogo. Também lhe será mostrado como continuar se divertindo com o jogo depois que você completar todos os seus níveis.

DOOM é um jogo produzido pela empresa ‘id Software’ seguindo o modelo lançado pelo jogo

Wolfenstein 3D. DOOM é um jogo de perspectiva em primeira pessoa, e alcançou um sucesso surpreendente conquistando uma legião de fãs.

DOOM é um jogo de computador lançado em 1993 pela id Software, e um dos títulos seminais do

gênero first-shot (‘tiro em primeira pessoa’). Combinando gráficos 3D com violência gráfica, ele tornou-se tanto controverso quanto imensamente popular, com um lançamento em versão shareware que estima-se ter sido jogada por 15 milhões de pessoas. Além de definir muitos elementos de jogo dos games de tiro em primeira pessoa, Doom estabeleceu uma sub-cultura por popularizar os jogos em rede e permitir expansões criadas pelos jogadores (WADs). O sucesso do jogo influenciou a explosão de jogos nos anos 90 até o ponto desses jogos serem algumas vezes chamados de "clones do DOOM".

A franquia DOOM continuou com ‘DOOM II: Hell on Earth’ (lançado em 1994) e numerosos

pacotes de expansão, incluindo ‘The Ultimate Doom’ (lançado em 1995), ‘Master Levels for Doom II’ (lançado em 1995), e ‘Final Doom’ (lançado em 1996). Originalmente lançado para o PC/DOS, esses jogos foram subseqüentemente portados para várias outras plataformas, incluindo nove diferentes jogos para consoles. A série perdeu o apelo tão logo o mecanismo gráfico do Doom se tornou obsoleto no final dos anos 90, mas foi revivido em 2004 com o lançamento do ‘DOOM 3’, uma releitura do jogo original usando nova tecnologia.

Em 2004 foi lançada uma versão em tabuleiro, pela Fantasy Flight Games, com miniaturas dos

monstros e personagens. Já em 2005, foi lançada uma adaptação cinematográfica de DOOM, batizada no Brasil de ‘DOOM:

A Porta do Inferno’. DOOM possui as seguintes seqüências oficiais: DOOM (Original) - Primeira versão do jogo, contendo três sangrentos episódios, com vários

níveis cada. DOOM 2: Hell on Earth - Seqüência do jogo, agora já não existe mais o esquema de episódios.

Os níveis são lineares, ou seja, você deve atravessar 32 níveis!


- 8 -

Final DOOM (TNT / Plutonia) - Versão especial de DOOM contendo dois episódios (TNT: Evilution & The Plutonia Experiment), cada episódio com 32 níveis! Este é um pacote especial contendo níveis criados por jogadores de várias partes do mundo!

Ultimate DOOM - Trata-se de um add-on (upgrade) para o jogo DOOM (para a versão original).

Este upgrade adiciona um quarto episódio (Thy Flesh Consumed). The Master Levels for Doom II - Um pacote especial contendo 21 níveis criados por jogadores

de várias partes do mundo! DOOM 3 - Uma releitura do jogo original com nova tecnologia e gráficos espetaculares! DOOM 3: Resurrection of Evil - Pacote de expansão com mais carnificina!

Fig. 1 - Genealogia original de DOOM


- 9 -

2 - Características do DOOM

A engine de DOOM não é apenas um upgrade da engine do Wolfenstein 3D. Ao contrário, ele foi totalmente reescrito linha por linha e melhorou incrivelmente. A estrutura de dados usada pela engine também foi completamente redesenhada, de tal modo que permita um uso muito mais flexível. Os vários capítulos deste livro irão mostra para você como é flexível (ou não!) essa nova engine usada pelo DOOM.

Foram adicionadas texturas de chão e teto para tornar o DOOM muito mais realístico que

Wolfenstein 3D. Texturas de céu foram adicionadas para transmitir a sensação de áreas amplas ao ar livre. As texturas de céu são adições muito bem-vindas ao DOOM; áreas ao ar livre são fáceis de fazer, e elas adicionam a ilusão de espaços amplos. Também foram adicionadas texturas especiais de chão e teto animadas que dão a impressão de movimento, enquanto permitem áreas com água e até mesmo fluídos venenosos como ácido! O primeiro nível de abertura do DOOM apresenta o jogador a estas novas características do jogo, como você pode ver na imagem abaixo. Fig. 2 - A janela, a arena e o céu.


- 10 -

3 - História (Enredo)

DOOM tem um tema de ficção-de-horror, e um enredo bem simples. No entanto, o enredo só aparece no manual, e a história dentro do jogo em si é mostrada em mensagens entre os episódios.

O jogador recebe o papel de um fuzileiro espacial, "one of Earth's toughest, hardened in

combat and trained for action", (Um dos mais durões na terra, endurecido em combate e treinado para a ação) que foi deportado para Marte por atirar num oficial superior quando ordenado a matar civis desarmados.

Ele é forçado a trabalhar para a Union Aerospace Corporation (UAC), um complexo militar-

industrial que está realizando experiências secretas em teleportação entre as luas de Marte, Fobos e Deimos. De súbito, algo dá errado e criaturas do Inferno começam a vir das áreas de teleporte. Uma resposta defensiva da segurança da base falha em deter a invasão, é rapidamente dominada por demônios, com toda a guarnição morta ou transformada em zumbis.

Ao mesmo tempo, Deimos desaparece inteiramente. Um time da UAC em Mars é enviado a

Phobos para investigar o incidente, mas o contato pelo rádio cessa em breve e apenas permanece vivo; o jogador, cuja tarefa é escapar vivo.

Para terminar o jogo, o jogador precisa batalhar em três episódios contendo nove fases cada.

Knee-Deep in the Dead, o primeiro episódio (e o único, na versão shareware), se passa numa base militar high-tech em Phobos.

Ele termina com o jogador lutando contra os Barons of Hell, entrando no teleportador que leva a

Deimos, onde ele é estraçalhado por monstros e aparentemente morre. No segundo episódio, Shores of Hell, o jogador faz uma jornada através das instalações em

Deimos, cujas áreas mostram uma arquitetura bestial. Depois de encontrar o Cyberdemon (um demônio com uma bazuca no lugar de um braço), a verdade sobre a lua desaparecida é descoberta: ela flutua sobre o Inferno!

O jogador desce até a superfície e o episódio final, Inferno, começa. Depois de destruir o chefão final, Spider Mastermind (uma espécie de cérebro com patas,

altamente armado), uma porta secreta se abre para o herói, "proved too tough for Hell to contain" ("que provou ser macho demais para o Inferno conter"), ser levado de volta à Terra. O pacote de expansão ‘Ultimate Doom’ adiciona um quarto episódio contando as peripécias da volta ao lar do fuzileiro.


- 11 -

4 - Elementos do Jogo

Sendo um jogo de tiro em primeira pessoa, DOOM é sentido através do ponto-de-vista do personagem principal. O objetivo de cada fase é simplesmente encontrar a saída que leva ao próximo nível (convidativamente rotulada com um sinal de EXIT em vermelho), enquanto se sobrevive a todos os perigos ao longo do caminho. Entre os obstáculos estão monstros, tanques com lixo tóxico, tetos que vêm abaixo e esmagam o jogador e portas trancadas por um cartão-chave ou interruptor que precisa ser encontrado. Os níveis são às vezes labirínticos (o auto-mapa é uma ajuda crucial ao navegá-los), e apresentam uma abundância de áreas secretas com power-ups como recompensa para que o jogador as explore.

DOOM é notável pelo arsenal disponível, que se tornou uma espécie de protótipo para os jogos de

tiro em primeira pessoa. O jogador começa armado apenas com uma pistola, e punhos com soco inglês, mas podem-se apanhar armas melhores: a motoserra, a escopeta, a metralhadora giratória, o lança foguetes, o rifle de plasma, e a imensamente poderosa BFG 9000 (acrônimo de ‘Big Fucking' Gun ou, numa versão adaptada pelos jogadores brasileiros ao português ‘Bola de Fogo Gigante’). Há uma grande variedade de power-ups, como a mochila que aumenta a capacidade de carregar munição, armadura, kit de primeiros-socorros para restaurar a saúde, e esferas azuis demoníacas que aumentam a saúde do jogador além de 100%, até um total de 200%.

Os inimigos no DOOM são os elementos principais do jogo. O jogador os encara em grandes

números - no mais difícil dos níveis de dificuldade encontra até 12 inimigos numa mesma sala. Existem 10 tipos de monstros (DOOM II dobra essa quantia), incluindo tanto humanos possessos quanto demônios de diferentes forças, indo desde os fracos, mas onipresentes Imp (monstros marrons com espinhos) e Cacodemon (espécie de almôndega flutuante que cospe bolas matéria incandescente) até os chefões de final de fase, que agüentam múltiplos ataques mesmo das armas mais potentes.

Os monstros têm comportamento simples, que consiste entre ou andar ao redor do jogador ou

atacar atirando bolas-de-fogo, mordendo, e rasgando a pele (a sua, não a deles!), apesar de eles poderem também lutar entre si.

Além do modo single-player, DOOM apresenta dois modos multiplayer: Cooperative, em que 2 a

4 jogadores (usando o engine original - mais de 32 usando engines mais modernas!) lutam contra as legiões do Inferno, ou Deathmatch (engines mais modernas permitem outras modalidades de jogo!), em que os jogadores lutam entre si.

Lista de todos os inimigos:

Former Guard (Former Human /Zombieman) - O mais fraco dos inimigos ataca com uma pistola. Basta dois tiros de pistola para neutralizar este inimigo.

Former Sarge (Former Human Sergeant / Shotgun Guy) - Zumbi armado com uma escopeta, muito perigoso de perto. Porém de longe o efeito do poder do tiro é neutro, devido às partículas da munição da escopeta espalhar, assim como a escopeta real.

Former Commando (Heavy Weapons Dude / Chaingunner) - O mais poderoso da classe dos zumbis. Armado com uma metralhadora giratória (Chaingun), é muito perigoso. Em bandos são difíceis de derrotar, pelo fato deles metralharem o jogador. Exclusivo do DOOM II.


- 12 -

Imp - O mais comum dos inimigos ao decorrer do jogo. Tem o poder de lançar bolas de fogo no jogador, mas tem poder fraco. Seu golpe mais poderoso é o talho, que ele usa ao se aproximar do jogador.

Demon (Pinky Demon / Shaved Gorilla / Bull Demon) - Criatura que não têm ataque á distância, porém ataca suas vítimas mordendo-as e estraçalhando-as. Ele também se move bem rápido e é resistente. Andam em bandos na maioria dos casos.

Spectre - Idêntico ao Demon, porém transparente. Muito perigoso em mapas escuros por ser difícil a percepção dele pelo jogador.

Cacodemon - O nome deste demônio vem da palavra grega caco (que significa feio), esta criatura pode voar e atira bolas de matéria incandescente contra o jogador. Muito difíceis de matar com as armas primárias, normalmente estão em bando, assim como os Demons.

Lost Soul - Almas aprisionadas que estão condenadas a servir ao inferno. Um dos mais odiados inimigos do jogo. Não possui ataque á distância, mas possui uma velocidade incrível. São invocados pelas Pain Elementals, ou podem ser encontrados soltos no jogo.

Pain Elemental - Esse demônio é semelhante ao Cacodemon. Ele invoca Lost Souls para te atacar. Não tem ataque próprio. Quando ele invoca 20 Lost Souls em um local, ele não invoca mais, a não ser que elas sejam mortas. Exclusivo do Doom II.

Baron of Hell - Este ser pertence á classe mais poderosa de demônios. Um escudo vivo que possui uma vitalidade grande e ataque alto. Atira bolas de fogo incandescentes, que apesar de serem lentas e facilmente desviáveis, causam muito dano se acertam o jogador. Seu talho é muito mais mortal que o do Imp. No primeiro Doom, são os "chefes" do primeiro episódio ‘Knee-Deep in Dead’. Você deve enfrentar dois desses monstros, que foram apelidados pela própria id Software de Bruiser Brothers, em uma clara referência aos Hammer Brothers, de Super Mario Bros. 3.

Hell Knight - Uma versão mais fraca do Baron of Hell, que tem menos vitalidade, porém o ataque é tão poderoso quanto o do Baron of Hell. Exclusivo do Doom II.

Arachnotron - Cérebros que se locomovem com pernas mecânicas, como se fossem aranhas. Atacam com uma plasma gun, e em grupo podem te matar facilmente. Exclusivo do Doom II.


- 13 -

Revenant - Demônios mortos têm seus esqueletos revividos, é colocado uma armadura e dois lança-mísseis em seus ombros, e são mandados de volta á batalha. Apesar da vitalidade baixa, têm três tipos de ataques. O primeiro é lançar um foguete. O segundo também é um foguete, porém te segue, o que exige que o jogador se esconda. O terceiro é um soco, o mais mortal dos ataques desse demônio. Exclusivo do Doom II.

Mancubus - Criaturas lentas, mas perigosas. Lançam uma sequência de bolas de fogo, porém são rápidas e difíceis de desviar. Por serem lentos, é fácil de escapar deles, porém difíceis de matar. Exclusivo do Doom II.

Arch-Vile - Uma das mais perigosas e odiadas criaturas do jogo. Além de imolar o jogador em chamas e atirar uma bola de fogo hitscan (atinge o jogador instantaneamente, como os tiros dos zumbis), necessitando que o jogador se esconda atrás de paredes, pode ressuscitar inimigos já mortos pelo jogador. Por isto são odiados pelos fãs do jogo. Exclusivo do Doom II.

Spider Mastermind (Spiderdemon) - Este cérebro gigante, além de controlar os Arachnotrons, controla também todos os outros demônios. Foi o grande responsável pelo ataque do Inferno ás luas de Marte, Phobos e Deimos, comandando a invasão. Possuem uma gigantesca metralhadora giratória que pode matar o jogador em segundos. É o último chefe do primeiro jogo, no episódio Inferno, e também no episódio Thy Flesh Consumed, exclusivo do Ultimate Doom. São muito difíceis de matar com armas normais, você precisará da BFG 9000 para matar este demônio.

Cyberdemon - Este demônio é o mais forte do jogo, atira rockets (mísseis) em você, altamente destrutivos, podendo matar você com um único disparo. O "chefe" do episódio The shores of Hell, do primeiro Doom. É quase impossível derrotá-lo com armas comuns e mesmo com a rocket launcher ou a plasma gun vai levar muito tempo para destruir este grotesco monstro. Necessitará vários tiros da BFG 9000 para destruí-lo.

The Icon of Sin (The Baphomet) - Não é necessariamente um inimigo. Está como uma "parede". Aparece na fase 30 do Doom II, como o último "chefe". Ele não tem ataque. Porém, invoca todos os tipos de demônios (com exceção da Spider Mastermind, Cyberdemon e os zumbis). Para derrotá-lo, é preciso atirar com uma arma potente no "cérebro" dele. Repita o processo até ele explodir todo. Há um easter egg dentro dele, que só é possível descobrir usando o cheat #idclip. Entre no cérebro do Baphomet. Você verá a cabeça de John Romero, um dos criadores do jogo. É ela que você realmente atinge quando você atira no cérebro, e é ela que você deve matar na verdade. Quando você entra na grande sala para derrotar o Baphomet, ele emite uma voz demoníaca. Na verdade, é a voz de John Romero, invertida e distorcida. Ele diz "To win the game, you must kill me, John Romero." (Para vencer o jogo, você deve matar a mim, John Romero.)


- 14 -

The Wolfenstein SS Soldiers (SS Nazi) - Outro easter egg. Ele apenas aparece nas fases 31-Wolfenstein e 32-Grosse. É um inimigo do clássico jogo Wolfenstein 3D. Quando você termina o jogo, ele não aparece na lista dos monstros que existem, por ser secreto. Na versão alemã, nem ele e nem as fases secretas aparecem, por determinação do governo alemão.

Commander Keen - Este também não é um inimigo, é um easter egg. Ele está presente na fase 32-Grosse. Para liberar a saída, você deve matar os quatro destes, que estão pendurados numa corda. Diz a id Software que este boneco é de Billy Blaze. Quando você vai para a fase 32, antes de você começar, ele fala: "Better blaze this one!", em uma clara referência ao Billy Blaze.


- 15 -

5 - Produção

Fig. 3 – A Escultura

A produção de DOOM começou em 1992, com John Carmack construindo o mecanismo gráfico

enquanto a id terminava Spear of Destiny, a continuação de Wolfenstein 3D. As grandes influências dos criadores foram os filmes Aliens e Evil Dead II, com os demônios tendo saído de uma partida de Dungeons & Dragons que terminou com o planeta infestado deles. O título fora escolhido por Carmack:

Tem uma cena de "A Cor do Dinheiro" onde Tom Cruse [sic] aparece no bar com seu taco de sinuca.

Perguntam: "O que você tem aí?", "Perdição" (Doom) Cruse responde sorrindo. “Aquilo, e a carnificina resultante, foi como eu vi a incursão de nosso jogo na indústria”.

Tom Hall criou um documento chamado ‘Bíblia de Doom’, com uma história complexa, no qual 5

soldados numa base militar no planeta Tei Tenga enfrentam os demônios, e viajariam ao Inferno. Mas Carmack rejeitou, dizendo que "história num jogo é tão importante quanto à história num filme pornô".

Conflitos com a equipe (Hall queria mais realismo em vez de jogabilidade melhor) levaram Hall a

sair em 1993. A ‘Bíblia’ foi rejeitada, mas diversas idéias ficariam: também começa numa base militar, ficaram

as luas de Marte; as viagens ao inferno; e apenas um protagonista soldado. Muitos níveis e criaturas também ficariam com algumas alterações.


- 16 -

5.1 - Níveis

Os níveis de Tom Hall, muito realistas e inspirados em Wolf 3D, começaram a ser feitos, mas adaptados a medida que progredia para serem mais "legais" e mostrarem a capacidade do jogo. Os níveis do primeiro episódio foram feitos por John Romero, mas como ele não podia fazer os outros 2 episódios, Sandy Petersen fora contratado 10 semanas antes do lançamento.

Fig. 4 - Doomguy

5.2 - Gráficos Adrian Carmack e Kevin Cloud foram os artistas principais. Don Ivan Punchatz criou o logo e

capa, e seu filho Gregor esculpiu alguns monstros. A maioria das imagens foi feita á mão, mas alguns foram esculturas digitalizadas, como o personagem jogável, o Cyberdemon, os Barons of Hell e o Spider Mastermind. As armas vieram de fotos de armas de brinquedo e a motoserra fora emprestada pela namorada de Tom Hall. As mãos do personagem jogável são de Kevin Cloud.

5.3 - Som As músicas de fundo foram feitas por Bobby Prince, que já fizera Wolfenstein 3D. Algumas

músicas são versões de Metallica, Pantera, AC/DC, e Slayer.

5.4 - Tecnologia A principal característica que distinguiu DOOM em seu lançamento foi à qualidade de seu

mecanismo gráfico, sem paralelo em outros jogos da época. O avanço em relação ao jogo anterior da id Software, Wolfenstein 3D, foi conseguido graças a um novo mecanismo gráfico criado por John Carmack.

Após o sucesso do jogo, a sua tecnologia ainda serviu como "exemplo" para outros jogos do

mesmo gênero como Heretic, Hexen e Duke Nukem 3D. Suas principais características são:


- 17 -

• Diferenças de altura (todas as salas em Wolfenstein 3D são da mesma altura); • Paredes não-perpendiculares (todas as paredes em Wolfenstein 3D correm ao longo de um

grid quadrangular); • Mapeamento de textura em todas as superfícies (em Wolfenstein 3D, o teto e o chão não

tinham texturas); • Níveis variados de luz (todas as áreas em Wolfenstein 3D são completamente iluminadas

com o mesmo brilho). Apesar de também contribuir para a autenticidade visual do jogo, isso provavelmente e mais importante ainda adicionou à atmosfera do jogo; o uso da escuridão como meio de amedrontar e confundir o jogador foi um elemento inédito nos jogos.

Em contraste com as fases estáticas do Wolfenstein 3D, as do DOOM são altamente interativas:

• Plataformas podem subir e descer; • O chão pode subir em seqüência para formar degraus; • Pontes podem subir e descer.

A sensação de realidade do ambiente foi aperfeiçoada ainda mais pelo sistema de som estéreo,

que tornou possível dizer de que direção e distância o som se origina. Como o som estéreo não proporciona um senso de 360º perfeito, no desenvolvimento de Doom 3 exigiu-se o uso do som Dolby Surround 5.1 para passar o realismo ao jogador que os produtores desejavam. Com esse sistema de som, o jogador pode sentir todos os efeitos sonoros com fidelidade extrema ao que se vê na tela, desde que possua esse sistema sonoro em seu local de jogo.

5.5 - Controvérsia DOOM foi e permanece notório por seus níveis de sangue e imagens satânicas, vistas pela

primeira vez naquela época, gerando então controvérsias num amplo número de grupos. Ele foi criticado numerosas vezes por organizações cristãs por suas tonalidades satânicas e

chamado de "simulador de assassino em massa" ("mass murder simulator") pelo Col. David Grossman, crítico e fundador do Killology Research Group.

DOOM causou temores quanto ao uso da então emergente tecnologia de realidade virtual para

simular matanças extremamente realistas, e, em 1994 levou as tentativas mal-sucedidas pelo senador estadual de Washington Phil Talmadge de introduzir o cadastramento compulsório para uso de RV.

O jogo causou controvérsia novamente no Massacre de Columbine quando se soube que Eric

Harris e Dylan Klebold, que cometeram o massacre em 1999, eram ávidos jogadores de DOOM. Nota: O título pode também ser escrito "DOOM", tudo maiúscula, a id Software é inconsistente

entre escolher "Doom" e "DOOM". A variação "DooM", estilizada a partir do logotipo, ainda é encontrada, mas caiu em desuso geral nos últimos anos.

5.6 - Plataformas DOOM fora "portado" para diversas plataformas:

Computador • MS-DOS - Doom - 1993 • Windows 95 - 1996 • Amiga PC - 1997 - ? • Macintosh - 1995 - ?


- 18 -

• Linux - 2005 • Windows XP - Doom 3 - 2004 Video Games • Sega 32X - 1994 • Playstation - 1995 • Super Nintendo - 1996 • 3DO - 1996 • Atari Jaguar - 1996 • Sega Saturn - 1997 • Nintendo 64 - 1997 • Game Boy Advance - 2001 • Xbox (como bônus de DOOM 3) - 2005 • Xbox 360 (Xbox Live Arcade) - 2006 • Dreamcast - 2002 • Playstation Portable (PSP) - 2005 Celulares • DOOM RPG - 2005 - ? Arcade (Fliperama) ??? Sério eu já vi imagens em sites estrangeiros de máquinas de arcade com o jogo DOOM rodando,

porém não tenho dados oficiais para confirmar a autenticidade das imagens.


- 19 -

6 - Portabilização Portabilização é a palavra adaptada para o português baseada no inglês "porting", que significa

"adaptar" ou "tornar compatível". Na informática e outros sistemas eletrônicos como vídeo-games, por exemplo, ocorre por vezes a necessidade de se executar um determinado software que não seja compatível com o sistema em que se está trabalhando no momento. Um bom exemplo disso são os jogos, como o Doom, que é um grande clássico dos PC’s da década de 90, porém é um software de MS-DOS, e grande parte dos usuários de PC’s passaram a usar o Windows XP na década seguinte, que por sua vez não oferece suporte total à aplicativos de MS-DOS.

Para resolver esse problema, diversos fãs do jogo, que entendiam de programação, aproveitaram

o fato de os donos originais do software (a empresa Id Software) terem liberado o código fonte do jogo, e fizeram pequenas alterações no código para que ele fosse transformado em um software nativo de Windows.

Esses programas adaptados são os Source-Ports.

6.1 - Confusão entre Portabilização e Emulação Muito se confunde quando o assunto é portabilização e emulação, simplesmente pelo fato de que

o resultado final, em linhas gerais, é quase que idêntico. Esse resultado final é:

• Conseguir rodar um software em uma plataforma diferente de sua original.

Porém a maneira na qual esse resultado é obtido difere completamente entre a emulação e a portabilização.

Emulação Emular é "recriar" virtualmente um componente físico de um aparelho eletrônico como, por

exemplo, um processador. Ou seja, emulador é uma "Réplica Virtual de um Processador ou um Sistema Operacional", o que dá margem a possibilidade de interpretar um emulador como o próprio sistema, porém convertido em software.

Exemplo: Tanto o console "Super Nintendo", quanto o emulador "ZSnes" são ambos um SUPER

NINTENDO e aptos a interpretar softwares feitos para ele, porém o primeiro é um hardware, é físico, e o segundo é um software.

Portabilização Portabilizar é mexer no software original a fim de fazer algumas modificações necessárias de

forma que ele consiga ser lido e interpretado em uma outra plataforma, geralmente uma plataforma para a qual ele não tenha sido projetado originalmente.

Quando se está jogando um ROM de GameBoy Advance, por exemplo, no computador, usando o Windows XP, não é o computador que está lendo, interpretando e processando o jogo. O computador está apenas lendo o Emulador, e esse sim é que está lendo o jogo. O computador executa o software do emulador que lê o arquivo da ROM, executando as instruções do jogo contidas neste arquivo.


- 20 -

Fig. 5 – Esquema de Emulação

No caso de um software que foi portabilizado para uma determinada plataforma, ele foi

realmente transformado e naturalmente adaptado para ser rodado nela sem a necessidade de uma máquina virtual.

6.2 - Exemplo de "O que seria uma portabilização" Pegando como exemplo uma ROM de Super Nintendo. Se um usuário desejar jogar esse game no

Windows, ele precisaria usar um emulador, afinal o Windows por si só não tem a capacidade de interpretar um software desenvolvido para a plataforma "Super Nintendo".

Porém, se o jogo for portabilizado, significará que um programador que teve acesso ao código

fonte do jogo, o abriu e modificou sutilmente a fim de fazê-lo poder ser entendido diretamente pelo Windows, sem que se precise ter um emulador.

Seria como poder jogar, por exemplo, o ROM do jogo "Mortal Kombat" do Super Nintendo sem a

necessidade de um emulador, ou seja, a própria ROM por si só seria um software naturalmente executado pelo Sistema Operacional.

Isso tudo resultaria num desempenho bem mais realista do Software, 100% fiel ao original (pois

é o original) e exigiria menos esforço do processador e menor utilização de memória RAM, pois o software estaria sendo rodado diretamente, sem a necessidade de um software intermediário, que exigiria muito mais do processador e da memória RAM.

6.3 - Limite entre Portabilização e a Reescritura de Software Em geral tem-se que portabilizar é fazer o menor número possível de modificações no código

original de forma que ele funcione perfeitamente bem em outra plataforma, sem precisar alterar mais nada, ou reescrever qualquer outra parte do código.

Porém em alguns casos não basta que sejam apenas portabilizados para uma nova plataforma,

mas exige-se que mude mais alguma coisa no conteúdo devido a algum tipo de limitação ou exigência da plataforma em questão.


- 21 -

Por exemplo, um jogo que poderia ser naturalmente portabilizado para ser rodado numa outra

plataforma, porém essa nova plataforma possui um limite de memória RAM inferior ao da plataforma original desse software. Nesse caso provavelmente será necessário mexer nos arquivos de som e imagem do game diminuindo seu tamanho, resolução, nível de detalhe, etc, a fim de conseguir rodar sem empecilhos.

No universo dos jogos é exatamente isso que está sempre acontecendo quando os

programadores de uma empresa estão envolvidos em um projeto de um game que será lançado para diversas plataformas diferentes ao mesmo tempo, sendo que cada uma delas tem características técnicas superiores ou inferiores em relação umas às outras.

No caso de jogos feitos originalmente para arcade na década de 90, era necessário fazer diversas

modificações adicionais ao resto do jogo a fim de portabilizá-lo para os consoles de 16 bits, pois esses aparelhos caseiros possuíam características técnicas amplamente inferiores aos arcades, portanto não bastava apenas fazer com que o software seja legível pelo vídeo game, mas também dar um tratamento em todas as imagens, diminuir números de layers, a resolução do jogo, número de cores, e até mesmo retirar alguns frames (quadros de animação).

Também era necessário recriar os menus, afinal arcades utilizam fichas e um único nível de

dificuldade, e em consoles caseiros é possível mexer nas opções do jogo. Por muitas vezes os joysticks tem mais ou menos botões em relação ao arcade, e essas diferenças todas obrigavam os programadores a fazer tantas outras modificações no conteúdo do game, além de simplesmente portabilizá-lo neutramente, que se chega num nível em que em certos casos é difícil definir se um determinado software é tido como portabilizado, ou como reescrito.


- 22 -

7 - Liberação do Código Fonte (Source-Code) O código fonte da engine do jogo Doom foi liberado ao público em 1997. Embora o Doom fosse

criado originalmente para o MS-DOS, a liberação original da fonte era para a versão subseqüente de Linux. Isto ocorreu devido ao uso de uma biblioteca de som proprietária na versão para MS-DOS. Como o código fonte teve que inicialmente ser portado de volta para o DOS, o termo "source port" foi usado. Fora do costume, este termo veio a ser usado para todas as modificações da fonte do Doom, mesmo aquelas que não movem a modificação para uma outra plataforma.

A finalidade original das portabilizações da fonte era compatibilidade entre plataformas, mas logo

depois a liberação da fonte do Doom, programadores resolveram corrigir velhos erros do Doom e deficiências em suas próprias portabilizações da fonte, e mais tarde fizeram adição de mais características ao código fonte para adicionar novas modalidades de jogo, bem como alterar o fator diversão.

Os ports da fonte do Doom foram criados para permitir que o Doom funcione em muitos sistemas

operacionais e arquiteturas de computador diferentes, incluindo Linux, Mac OSX, e Windows. Os ports foram criados também para permitir que o Doom funcione em tipos diferentes de

máquinas. Um desses ports é Game Park 32. Uma companhia britânica chamada WildPalm produziu um port para os telefones celulares Nokia 7650 e 9210. Há um port para Sega Dreamcast, bem como para o videogame Xbox.

O código fonte foi liberado originalmente sob uma licença proprietária que proibia o uso comercial

e não requeria que os programadores liberassem o código fonte com as modificações efetuadas no arquivo executável do jogo. Em conseqüência disso, o código fonte para GLDoom, (primeiro port à adicionar gráficos de OpenGL) ao Doom, perdeu-se numa falha de hardware do disco rígido, o código foi re-liberado em 1999 sob a GNU General Public License, após pedidos da comunidade.

Como os ports da fonte do Doom romperam as limitações da engine original do Doom, o termo

Vanilla Doom foi inventado para referir-se a engine original do Doom com todas as limitações intactas. Esse termo foi inventado por fãs após o aumento da popularidade dos diversos ports do Doom. O termo Vanilla é usado na referência do tipo "unmodified", ou seja, não modificado. Isto foi estendido para o port nomeado Chocolate Doom, uma portabilização entre plataformas que busca emular exatamente o Vanilla Doom e as suas limitações.


- 23 -

8 - Source-Ports Source Port é o nome dado à portabilização de um programa, que é geralmente apenas um

arquivo executável que foi modificado a partir do código fonte do programa original, e substitui o executável original, para que possa ser rodado em uma outra plataforma para a qual não foi originalmente escrito.

Com certeza você deve possuir um daqueles excelentes jogos de aventura da década de 90 que

roda em DOS, porém nos dias de hoje onde a maioria das pessoas utiliza Windows XP, que é da família NT (tecnologia NT), muitos aplicativos de DOS não rodam com perfeição. Em casos como esse, se o software tiver código fonte aberto, ele poderá ser modificado por qualquer um que entenda de programação, de forma a se transformar em um software compatível com Windows XP. Quando isso ocorre, dizemos que esse software foi "portabilizado" para a plataforma Windows.

Essas modificações permitem melhorar muitas características do jogo, permitindo até mesmo a

inclusão de recursos que não estão disponíveis na engine original do jogo, como mira automática, efeitos de luz e transparência, etc.

Fig. 6 - Genealogia atual do Doom baseada nos ports mais importantes


- 24 -

9 - Principais Source Ports Estes são os ports de DOOM baseados no número de usuários ou no número de modificações

disponíveis, ou naqueles que possuem as características originais e interessantes, alguns que foram consideradas técnicas impossíveis dentro dos confins da engine do Doom.

9.1 - Boom e Variantes Boom é um port do código fonte de Doom criado por TeamTNT. Boom corrigiu numerosos erros

aleatórios do software e adicionaram numerosas outras características a engine, a tal grau que suas adições estão incorporadas na maioria da engines modernas do Doom existentes atualmente (tais como ZDoom e Doom Legacy).

Embora Boom seja mais simples do que os outros ports e não seja mais atualizado (ultima

atualização ocorrida em 22 de outubro de 1998), ele ainda é o preferido por muitos fãs de Doom, porque permaneceu relativamente próxima do comportamento dos jogos originais, incluindo suporte a demonstração do jogo (tela de demo). Alguns jogadores sustentam que a correção de erros e mudanças do comportamento dos outros ports, pode desequilibrar o comportamento dos mapas feitos para os jogos originais, dando aos jogadores determinadas vantagens ou desvantagens.

Link: http://www.teamtnt.com/boompubl/boom2.htm

9.2 - PrBoom PrBoom é um port derivado do Boom original que é projetado para o uso em Windows. Foi

portado também para Linux, Sega Dreamcast, GP2X, Nintendo DS, e Rockbox. O PrBoom possui em seu código fonte todas as melhores características dos seguintes projetos, Boom, MBF, LxDoom e ISDLDoom.

Link: http://prboom.sourceforge.net/index.html

9.3 - PrBoom + (PrBoom Plus) PrBoom+ é um port da fonte do Doom desenvolvido a partir do projeto original PrBoom. É

baseado atualmente no código fonte de sua versão estável mais recente, 2.4.8 (SVN). O alvo do projeto está em estender o port original com características que são necessárias ou úteis para todos aqueles interessados em novas maneiras de jogar. Vale a pena anotar que todas as mudanças introduzidas não prejudicam em nada a compatibilidade com o PrBoom atual, também mantendo compatibilidade com as engines originais de Doom e Doom2. O criador também adverte que jamais irá permitir desvios no PrBoom+, pois a compatibilidade é extremamente importante para o projeto PrBoom.

Link: http://prboom-plus.sourceforge.net/


- 25 -

9.4 - Marine’s Best Friend (MBF) Marine's Best Friend (MBF) é um port feito para DOS. É baseado no Boom, e adiciona diversas

características novas incluindo gráficos de alta resolução, monstros com AI melhorada, e a emulação das pré-liberações das versões beta do Doom. Foi desenvolvido por Lee Killough em 1998 e atualmente não é mais mantida.

Seu código foi usado mais tarde como base do port Smack My Marine Up (SMMU), que foi usado

por sua vez na construção da engine Eternity. Em 2004 James Haley e Steven McGranahan portaram o Marine's Best Friend para Windows como WinMBF.

Link: NÃO DISPONÍVEL :-(

9.5 - Eternity Engine A engine Eternity é um port da fonte para Windows licenciada sob a GNU General Public License.

Originalmente criada para mostrar o poder de uma conversão total do Doom, esse projeto tornou-se um “fogo de palha” (a última versão disponível data de 17 de maio de 2006), apenas a engine transformou-se no foco principal.

A engine é baseada no Smack My Marine Up (SMMU). Inclui características como ‘scripting’ (uma

espécie de linguagem de programação), ‘portals’, ‘polyobjects’, suporte ao jogo Heretic, e suporte total as modificações Millennium and Mordeth TC. Segundo algumas fontes do universo dos jogos, o projeto foi cancelado.

Link: http://doomworld.com/eternity/

9.6 - ZDoom e Variantes ZDoom é um port do código fonte oficial do Doom tendo como alvo o Microsoft Windows, com

versões não muito atualizadas para o MS-DOS e Linux. É um dos mais avançados e populares ports para Doom, suportando BEE (Boom Editing Extensions – Extensões de Edição do Boom), mais todas as extensões feitas pela engine do jogo Hexen, bem como a adição de 3D Floor (multi-pisos, ou seja, um andar em cima de outro andar) simulando os andares de um prédio, características novas não encontradas no Doom original. Além, do suporte ao Heretic, Hexen e Strife.

Link: http://www.zdoom.org

9.7 - GZDoom GZDoom é um port para Windows baseado no ZDoom que estende as características do jogo ao

incluir suporte a OpenGL. Também inclui suporte a 3D Floor (multi-pisos) usados no Doom Legacy, suporte a céus com 360º (skyboxes), modelos em 3D, e outras características.

Link: http://grafzahl.drdteam.org/


- 26 -

9.8 - csDoom csDoom, ou "Doom Client/Server", era um port GPL para Windows baseado no ZDoom construído

expressamente para jogos multiplayer do Doom através da Internet. Foi o primeiro port a usar o código de rede cliente/servidor (do Quakeworld) para facilitar a criação de jogos mais rápidos e tranqüilos através da Internet. O projeto foi encerrado pelo criador em 31 de janeiro de 2001.

Link: http://csdoom.sourceforge.net/eng.html

9.9 - ZDaemon ZDaemon é um port, originalmente baseado no csDoom, para Windows e * NIX (somente

servidor), propositalmente construído para jogos multiplayer do Doom através da Internet. Originalmente o código fonte estava liberado sob a GPL, como medida de segurança, o código fonte foi fechado devido aos incidentes com trapaceiros. O jogo inclui o código de rede cliente/servidor para jogos na Internet, um launcher (programa gráfico) para ajudar os usuários a encontrar jogos na rede, uma lista dos favoritos para ajudar a revisitar seus servidores preferidos, e um utilitário que automaticamente procura e efetua o download dos WADs personalizados necessários para jogar em diversos servidores.

Link: http://zdaemon.org/

9.10 - Skulltag Skulltag é um outro port multiplayer centrado no Doom para Windows que é baseado também

em ZDoom. Além do código de rede cliente/servidor, Skulltag inclui bots (jogadores controlados pelo computador) para jogos multiplayer offline (sem rede ou Internet); modalidades novas do jogo tais como Capture the Flag (Capturar a Bandeira), Instagib, Invasion (Invasão), e outros; bem como novas armas, monstros, itens, powerups, e objetos.

Link: http://skulltag.com/

9.11 - Odamex Odamex é um outro port multiplayer baseado no csDoom. Odamex inclui as características da

engine Boom, e atualmente suporta a modalidade Capture the Flag (Capturar a Bandeira). O objetivo de Odamex é expandir a base de jogadores possíveis às plataformas computacionais múltiplas, incluindo Windows, Linux, Mac OSX, e outros sistemas operacionais. Odamex é open source (código fonte disponível), e está atualmente em desenvolvimento.

Link: http://odamex.net/


- 27 -

9.12 - DOSDoom e Variantes DOSDoom era um dos primeiros ports da fonte do Doom, criado através da liberação original do

código fonte de Doom para Linux e portado para o DOS. Evoluiu para incluir diversas características novas, que não foram incluídas originalmente no código fonte original do jogo Doom, tal como transparências, alta resolução, e renderização de cores em 16-bit.


9.13 - Doom Legacy Doom Legacy é um port de Doom originalmente escrito como um fork do DOSDoom, introduzindo

mouse-look, jumping (pulo), um console (terminal), deathmatch para 32 jogadores, skins (peles), ports nativos para Windows e Mac OSX. Evoluiu também para suportar muitas características do Boom. Adicionou também algumas características novas, notavelmente a habilidade para que os níveis contenham pisos sobre pisos (múltiplos andares), o que significa que os níveis não estão presos ao modo 2D como no Doom original.

Link: http://legacy.newdoom.com/

9.14 - EDGE Enhanced Doom Gaming Engine, ou EDGE, é um port derivado do DOSDoom. A característica

mais atrativa do EDGE é seu sistema de DDF, que descreve todo o comportamento do jogo dentro de um arquivo de texto externo que é lido pelo arquivo executável do jogo. Em conseqüência, é popular entre os modders (pessoas que fazem modificações em jogos) que usam essa característica para adicionar muitas armas e características novas com muito menos trabalho do que os apresentados pelos limites atuais dos outros ports existentes. EDGE inclui ports para muitos sistemas operacionais, incluindo MS-DOS, Windows, Linux, BeOS e Mac OS X.

Link: http://edge.sourceforge.net/

9.15 - Doomsday Engine A engine Doomsday é um port sob a licença GPL que funciona em Linux, Mac OS X, e Windows. O

port suporta também o Heretic e o Hexen. Essa engine oferece suporte a aceleração por hardware para modelos 3D, objetos e movimentos com smoothing (suaviza o contorno dos objetos), shadows (sombras), dynamic lighting (iluminação dinâmica), e outras características. Também oferece suporte a extensões para edição XG e setores aprimorados, bem como um launcher. Infelizmente, sofre com numerosos erros de programação e ainda não é completamente estável.

Link: http://www.doomsdayhq.com/


- 28 -

9.16 - nxDoom nxDoom é um port do código fonte de Doom para Sega Dreamcast, baseado no DoomDC. Inclui

uma lista de mod’s, que permite a seleção de arquivos WAD e patches DeHacked para jogar. Também suporta salvamento diretamente para o VMU, suporta som e música quando os arquivos WADs de músicas são carregados.



- 29 -

10 - Jogos em Rede ou Internet Atualmente existem vários ‘launchers’, ou seja, programas gráficos que permitem jogos através de uma Rede TCP/IP ou via Internet. Abaixo estão listados alguns destes programas, sendo que atualmente os mais utilizados são o IDE - Internet Doom Explorer (para partidas através das engines ZDaemon, Skulltag e Odamex) e o ZDaemon Launcher (para partidas através da engine ZDaemon).

• IDE - Internet Doom Explorer http://nfdfn.jinr.ru/~bond/csdoom/ • ZDaemon Launcher

http://www.zdaemon.org/ Nota: A engine Skulltag é a mais poderosa atualmente, pois possui mais opções de jogos, porém a engine ZDaemon é a mais utilizada, portanto, eu recomendo que você instale o programa para essa engine. Após instalar um desses 'launchers', ao iniciar o programa pela primeira vez, você deverá criar uma conta dentro do provedor de partidas on-line para poder jogar.


- 30 -

11 - Qual é a diferença entre IWAD e PWAD? Antes de entrarmos na edição de mapas, vou dar uma breve explicação sobre um conceito que todo mapper é obrigado a conhecer. "IWAD" é o "WAD interno". Basicamente é o arquivo WAD original e principal do jogo 'doom2.wad, doom.wad, hexen.wad, plutonia.wad, tnt.wad e heretic.wad' são todos exemplos de WADs internos. "PWAD" é como um "patch WAD", ou seja, grosso modo podemos dizer que é um 'remendo'. Os "PWAD" são essencialmente todos os WADs que não são produzidos ou suportados oficialmente pela produtora do jogo. Os WADs de 'remendo' adicionam novas características ao jogo original. Normalmente são novos mapas, texturas, sons, sprites, etc. Basicamente qualquer coisa que substitua o material original. ‘dwango5.wad, zdctfmp.wad, dweller2.wad, icarus.wad, zvox.wad e udm2.wad’ são exemplos de PWADs. Existem milhares de PWADs e você também pode fazer o seu! Nota: Modificar o conteúdo dos arquivos IWADs e redistribuí-lo é crime! Se você quer distribuir os seus mapas, eles devem ser criados no formato PWAD.


- 31 -

12 - Tirando Screenshots do Jogo Todos os engines (Ports) e inclusive o engine original de DOOM (Vanilla Doom) possui um comando especial usado para tirar screenshots das telas do jogo. Na linha de comando digite '-devparm'. Alguns ports possuem um local apropriado para a digitação de comandos extras! Ex: [source_port] <comando><arquivo_wad> zdoom.exe -devparm -iwad plutonia.wad Esse comando irá permitir que você tire screenshots de qualquer mapa do Plutonia Experiment. Nota: A qualidade da imagem irá depender da resolução utilizada pelo seu Port. Quanto maior a resolução, melhor será a imagem. O comando '-devparm' pode ser utilizado em qualquer versão do DOOM.


- 32 -

13 - Jogando Off-line (Single-Player) O jogo DOOM foi originalmente projetado para ser jogado em modo Dual Game, ou seja, off-line e on-line. Com partidas Singleplayer e Multiplayer. Para jogar off-line, basta que você rode o executável principal do Vanilla Doom ou do seu Port preferido (ZDoom.exe, ZDaemon.exe, Legacy.exe, jDoom.exe, etc...). Por padrão, será rodado o jogo DOOM 2. Para rodar outro DOOM, use os comandos -file e -iwad na linha de comando. Ex: [source_port] <comando> <aquivo_wad> zdoom.exe -iwad tnt.wad (irá rodar o TNT:Evilution) zdaemon.exe -file mywads.wad (irá rodar o WAD 'mywads.wad') Nota: Os comandos mostrados acima supõem que os arquivos WADs estejam no diretório raiz do seu Port, caso os arquivos WADs estejam em outro diretório, você deve especificar o caminho até eles. Ex: O comando abaixo irá carregar o arquivo TNT.wad localizado no subdiretório 'wads' dentro do diretório raíz do seu Port. zdoom.exe -iwad \wads\tnt.wad Nota: Ao carregar a engine ZDoom será exibido um launcher gráfico que permitirá que você escolha qual versão de Doom você irá querer rodar, esse launcher somente será exibido se você tiver mais que um IWAD instalado no mesmo diretório da engine.


- 33 -

14 - Usando arquivos WAD externos Existem apenas 2 tipos de arquivos WADs e 2 comandos para carregar um arquivo WAD externo. Lembre-se que os arquivos WADs podem ser PWAD ou IWAD. Os comandos para usar esses arquivos são respectivamente -file e –iwad A maioria dos Ports possui uma interface gráfica que facilita na hora de utilizar um arquivo WAD externo. No entanto, eu vou explicar apenas como utilizar à 'Linha de Comando (Terminal)', para carregar um arquivo WAD externo. Se você já leu os tópicos anteriores, deve estar sabendo que a maneira correta de utilizar comando no terminal é: [source_port] <comando> <arquivo_wad> OBS: Para os exemplos abaixo, é admitido que os arquivos WADs estejam dentro do diretório raiz do seu Port. Carregando um arquivo PWAD No prompt do terminal, digite: zdaemon.exe -file armagedom.wad Esse comando irá carregar o arquivo PWAD 'armagedom.wad', que é um arquivo criado por outro jogador ou por você mesmo. Agora: zdaemon.exe -iwad plutonia.wad Esse comando irá carregar o arquivo IWAD 'plutonia.wad', que é um arquivo oficial do jogo (The Plutonia Experiment), criado pela produtora do jogo. Agora você deve estar se perguntando: 'Mas qual é a diferença entre esses comandos?' É muito simples! O comando -file, carrega arquivos WADs que possuem monstros, sprites, músicas, efeitos e muitos mais. Porém esses arquivos não possuem todos os recursos necessários para serem executados sem o arquivo WAD principal do jogo (que é um arquivo IWAD - doom.wad, doom2.wad, tnt.wad e plutonia.wad). Esse arquivo basicamente possui apenas as instruções necessárias para carregar corretamente o seu mapa. Já o comando -iwad, carrega os arquivos do tipo IWAD (criados pela produtora do jogo ou por empresas licenciadas pela produtora), esses arquivos possuem todos os recursos necessários para a execução do jogo, não necessitando de nenhum outro arquivo WAD adicional. Portanto, para você carregar os arquivos 'doom.wad, doom2.wad, tnt.wad e plutonia.wad, você deve utilizar o comando -iwad, pois esses são arquivos do tipo IWAD (Internal WAD). E para você carregar arquivos criados por outros jogadores ou por você (como dwango5.wad, frags.wad e torment.wad), você deve utilizar o comando -file, pois esses são arquivos do tipo PWAD (Patch WAD).


- 34 -

15 - Jogando através da linha de comando (Terminal) Todas as engines jogo DOOM possuem opções exclusivas que funcionam apenas em determinadas engines, porém, elas também possuem comandos padronizados derivados da engine original do jogo. Abaixo estão listadas algumas das opções disponíveis: Para usar um comando digite: [source_port] <comando> <arquivo_wad> Exemplo: zdaemon.exe -file mywads.wad zdaemon.exe -iwad tnt.wad Comandos Gerais para Controle de Configuração

• @filename Especifica um arquivo de resposta (Response File), com um ou mais comandos que serão lidos durante o carregamento do jogo.

• -avg

Restringe a operação do jogo para 20 minutos. Usado normalmente para torneios. (Veja também a opção '-timer').

• -cdrom

Usado apenas caso o jogo esteja gravado em CD-ROM. A configuração do jogo e os arquivos de salvamento serão gravados no disco rígido (drive C).

• -config <filename> Carrega um arquivo de configuração alternativo. Usado normalmente para jogos em rede,

onde cada máquina requer uma configuração diferente. • -episode <episodeNo> Permite iniciar o jogo diretamente na primeira fase do episódio especificado (válido somente

para DOOM). Os episódios disponíveis vão do 1 ao 3 (4 para o Ultimate DOOM). • -loadgame <game_munber> Permite carregar o jogo e iniciar a partir de um jogo já salvo. As opções válidas vão de 0 à 5.

(Note que um jogo salvo em uma versão de DOOM não poderá ser usado em outra versão do jogo.)

• -file <wadname> Carrega um arquivo PWAD externo. Ou seja, um arquivo WAD criado por terceiros. • -iwad

Carrega um arquivo IWAD original. Ou seja, os arquivos 'tnt.wad, plutonia.wad, doom.wad e doom2.wad'

• -nojoy

Desliga o uso do joystick.


- 35 -

• -nomouse

Desliga o uso do mouse. • -nomusic

Desliga a música. • -nosfx

Desliga os efeitos especiais de áudio. • -nosound

Desliga todos os efeitos de áudio. • -timer <minutes> Obriga o jogo a sair da fase atual depois de ‘x’ minutos especificados. Essa opção é muito

usada em torneios. • -turbo <boost> Aumenta a velocidade do jogo. Os valores válidos vão de 0 até 250. Essa opção é muito

utilizada em Deathmatchs.

Comandos para Controle de Multiplayer

• -altdeath Inicia uma partida Deathmatch usando DM v2.0 como padrão. Neste modo, todos os itens de energia, munição e armadura que forem coletados pelos jogadores, reaparecem após 30 segundos. Os artefatos de invulnerabilidade e as mega esferas de energia não reaparecem. Neste modo, o suicídio é considerado ilegal, e você perderá um ponto para cada suicídio cometido.

• -deathmatch

Inicia uma partida no modo Deathmatch. Se este comando não for utilizado, o jogo irá iniciar uma partida single-player no modo cooperativo.

• -net <players> Inicia o jogo no modo Multiplayer, com um número específico de jogadores. Para funcionar, o

número de jogadores válidos deve estar entre 1 e 4. Para iniciar uma partida em modo Cooperativo, não utilize a opção ‘-deathmatch’.

• -nodes <players> Trabalha como -net. Se não for especificado o número de jogadores, DOOM assumirá o valor

2 como padrão. • -port <port_no> Especifica a porta que será usada. Deve ser usada somente em partidas multiplayer. Comandos para Desenvolverdores • -debugfile <id> Obriga o jogo a gravar informações em um arquivo .txt • -devparm

Utilizado no desenvolvimento de mapas, útil para tirar screenshots e verificar slow-down nas partidas.


- 36 -

• -warp <episode><mission> Serve para iniciar o jogo diretamente dentro de uma fase específica no DOOM e Ultimate

DOOM. Os valores válidos são: para episódios de 1 até 4, para missões de 1 até 9 (sendo 9 a fase secreta de cada episódio).

• -warp <map> Serve para iniciar o jogo dentro de uma fase específica no DOOM 2, e nos outros arquivos

WADs que usam a engine do DOOM 2. Os valores válidos vão de 1 até 32 (sendo os mapas 31 e 32 secretos).

• -fast

Faz com que os monstros reajam como no modo Nightmare, ou seja, eles estarão extremamente rápidos.

• -nomonsters

Inicia um jogo sem nenhum tipo de monstro. Ideal para partidas Deathmatch. • -respawn

Faz com que os monstros ressuscitem após um determinado tempo. Como no modo Nightmare.

• -skill <level> Seleciona o nível de dificuldade do jogo. Os valores válidos vão de 1 até 5.

Comandos para Gravação de Demos e Screenshots

• -devparm Utilizado no desenvolvimento de mapas, útil para tirar screenshots e verificar slow-down nas partidas. Os screenshots tirados serão colocados no diretório raíz do jogo, sendo numerados de forma crescente.

• -maxdemo <size> Especifica o tamanho em kilobytes do demo que será gravado. Se você não especificar um

valor, será assumido o tamanho padrão de 128K. • -playdemo <filename> Executa um demo previamente gravado (arquivo LMP). Todo os demos possuem .LMP como

extensão. • -record <filename> Grava um demo com o nome especificado em ‘filename’. Você não precisa colocar a extensão

.LMP pois ela será colocada automaticamente. • -recordfrom <slot> <filename> Faz com que a engine grave um demo diretamente para um slot de salvamento (0-5).


- 37 -

16 - Códigos de Trapaça (Cheat Code) Abaixo estão listados os códigos oficias da engine original do jogo Doom (Vanilla Doom). DOOM & Ultimate DOOM

• God Mode iddqd - Modo Deus (Invulnerável) • Very Happy Ammo idkfa - Todas as armas e munição completa • Acquire Chainsaw idchoppers - Pegar a motoserra • Acquire item idbehold - Pegar todos os itens • No Clipping idspispopd - Atravessar paredes • Map Information

iddt - Mapa completo com informações (digite uma vez para exibir o mapa, digite duas vezes para exibir os monstros e jogadores)

• Warp

idclev <level> <episode> - Seleção de níveis (ex: 'idclev 2 3' - pula para o terceiro nível do episódio 2)

• Report Location idmypos - Exibe a sua localização

DOOM 2 (TNT & Plutonia Experiment)

• God Mode iddqd - Modo Deus (Invulnerável) • Very Happy Ammo idkfa - Todas as armas e munição completa • All Weapons idfa - Todas as armas • Acquire Chainsaw idchoppers - Pegar a motoserra • Acquire item idbehold - Pegar todos os itens • No Clipping idspispopd - Atravessar paredes


- 38 -

• Map Information iddt - Mapa completo com informações (digite uma vez para exibir o mapa, digite duas vezes para exibir os monstros e jogadores)

• Warp

idclev <level> - Seleção de níveis (ex: 'idclev 26' - pula para o mapa 26 - os valores aceitos vão de 01 até 32)

• Report Location idmypos - Exibe a sua localização em coordenadas


- 39 -

17 - Editores de Mapas Você deve estar perguntando se é fácil criar ou modificar mapas para o DOOM. Bom, a resposta é simples: DEPENDE! Mas, depende do que ou de quem? Depende apenas de você, pois é você quem irá criar ou modificar um mapa, portanto, depende da sua vontade em aprender a criar os mais incríveis efeitos para o jogo DOOM. Milhares de pessoas em todo mundo que jogam DOOM gostam de criar os seus próprios níveis para o jogo. Essas pessoas fazem níveis conforme o seu conhecimento em edição de mapas, por isso eu resolvi criar esse guia, para ajudá-lo a aprender e expandir os seus conhecimentos sobre edição de mapas. Abaixo estão listados alguns editores de mapas para o DOOM.

• DOOM Builder - OpenSource - Gratuito (Windows) http://www.doombuilder.com/ • DeepSea - Shareware (Windows) http://www.sbsoftware.com/ • WadAuthor - Shareware (Windows) http://www.gamers.org/pub/idgames/utils/level_edit/ • Yadex - OpenSource - Gratuito (Linux - *nix)

http://www.teaser.fr/~amajorel/yadex/ Nota: Atualmente o melhor e mais poderoso editor de mapas para o DOOM é o DOOM Builder.


- 40 -

18 - Conhecendo o WadAuthor

18.1 - A Aparência do WadAuthor A imagem abaixo mostra a aparência do WadAuthor v1.30.

Fig. 7 – Tela principal do WadAuthor

Observe que o programa é muito semelhante à dos demais programas encontrados no Windows

(como o Word, por exemplo), isso torna o aprendizado muito mais simples e fácil. Iremos agora entrar na parte realmente divertida, que é a criação de um novo mapa para o

DOOM.


- 41 -

18.2 - Guia de Botões A tabela abaixo mostra todos os botões disponíveis no WadAuthor (v1.30):

TABELA DE BOTÕES ÍCONE INGLÊS PORTUGUÊS DESCRIÇÃO

New Wadfile Novo arquivo WAD Cria um novo arquivo WAD vazio.

Open Abrir… Abre um arquivo WAD já existente.

Save Salvar Salva o arquivo atualmente aberto.

Cut Cortar Apaga a seleção copiando para a área de transferência.

Copy Copiar Copia a seleção para a área de transferência.

Paste Colar Cola o conteúdo da área de transferência.

Undo Desfazer Desfaz a última ação.

Print Imprimir Imprime o mapa do arquivo WAD aberto.

Check Map Checar Mapa Procura erros e exibe um relatório dos dados.

Run Map Iniciar Mapa Inicia o jogo com o mapa atualmente aberto.

Help Topics Tópicos de Ajuda Exibe os tópicos da ajuda do programa.

Help Ajuda Exibe a ajuda do WadAuthor.

New Rectangular Sector

Novo Setor Retangular

Insere um novo setor retangular.

New Polygonal Sector

Novo Setor Poligonal Insere um novo setor poligonal.

New Thing Novo Objeto Insere um novo objeto.

Zoom In Mais Zoom Aumentar Zoom.

Zoom Out Menos Zoom Diminuir Zoom.

Best Fit Melhor Ajuste Ajusta a exibição para uma melhor visualização.

Increase Grid Aumentar Grade Aumenta a grade de trabalho.

Decrease Grid Diminuir Grade Diminui a grade de trabalho.

Show Thing Bitmaps

Exibir Imagens dos Objetos

Exibe imagens dos objetos existentes do mapa.

Show Grid Exibir Grade Exibe a grade padrão.

Show Floor Grid Exibir Grade Exibe as intercessões da grade.

Snap To Grid Ajustar a Grade Ajusta os vértices automaticamente nas intercessões da grade.


- 42 -

19 - Configurando o WadAuthor Aqui será mostrada a maneira correta de configurar o WadAuthor (v1.30). Leia atentamente.

19.1 - Localização dos Arquivos WADs Na primeira vez que o programa WadAuthor for aberto, provavelmente a janela abaixo irá

aparecer. Nessa janela você deverá indicar o local exato de cada arquivo WAD dos jogos DOOM (Ultimate DOOM), DOOM II, Heretic e Hexen. Lembre-se de utilizar somente arquivos originais, não utilize arquivos piratas!

Indique o local do arquivo WAD

(Wadfile), o nome do jogo (Name) e o nome do mapa a ser criado ou aberto (New Map). Para evitar problemas, altere apenas à primeira opção indicando o local correto para o arquivo WAD. Pronto! A configuração básica está completa. Fig. 8 – Configuração Inicial

19.2 - Opções (Options) Para configurar as opções do WadAuthor clique em Tools → Options... Na janela que aparece

você poderá ver várias abas, cada uma possui diversas opções de configuração, que poderão ajudar você no processo de edição de mapas.

19.3 - Cores (Colors) A primeira aba é a Colors (Cores), nessa

opção, todas as cores já estão pré-definidas para um melhor aproveitamento.

Portanto, não é necessário alterar nada (eu mesmo não recomendo isso!). Veja cada uma das cores e suas respectivas definições associadas. Se algo não te agradar, simplesmente mude!

Fig. 9 – Aba Colors (Cores)


- 43 -

19.4 - Arquivos (Files) Na aba Files (Arquivos), clique em Make Backups e no quadro Node Building clique em

Internal. A primeira opção irá criar cópias de segurança

(backups) de cada arquivo WAD salvo. Os arquivos de backup do WadAuthor possuem a extensão BAK.

Já a opção Node Building trabalha a estrutura

interna dos arquivos WADs, através de um processo de otimização que é complementado com o Reject Table.

Nessa parte existem três opções: ‘None (Nenhum)’, ‘Internal (Interno)’ e ‘External

(Externo)’, explicadas a seguir. Em ‘None’, nenhuma ação será realizada. Em ‘Internal’, o próprio programa WadAuthor irá

realizar o trabalho de ‘Node Building’. Fig. 10 – Aba Files (Arquivos) Em ‘External’, você poderá escolher um programa externo que fará todo o trabalho de ‘Node

Bulding’, para isso basta digitar o nome do arquivo executável na opção ‘Command’, bem como as opções extras necessárias, e se você desejar poderá ver todo o trabalho que está sendo realizado ativando a opção ‘Show External Node Build’. Caso você resolva usar um programa externo, o executável desse programa deve estar dentro do mesmo diretório do WadAuthor. Para evitar possíveis problemas ative apenas às opções Make Backups e Internal.

19.5 - Geral (General) Essa é bem simples, afinal são apenas duas

opções. Ative as duas opções. ‘Restore Main Window Position’: Restabelecer a posição da janela principal.

‘Unlimited Undo’: Desfazer Ilimitado A primeira opção não tem segredo, ela apenas

irá restaurar a posição original da janela principal do programa.

A segunda opção é a que realmente interessa,

essa opção irá permitir que você possa desfazer qualquer ação efetuada quantas vezes forem necessárias.

Fig. 11 – Aba General (Geral)


- 44 -

19.6 - Barras de Ferramentas (Toolbars) Este também é muito fácil, basta ativar as

opções Standard, View e Status Bar. A opção User Tools, permite que você insira uma barra com botões extras que podem ser configurados manualmente por você. Com isso, você pode iniciar um programa externo para executar alguma função que você achar apropriado. Para configurar cada botão clique em Tools → Customize... e configure conforme as suas necessidades.

Standard: Padrão View: Visualizar User Tools: Utilitários do Usuário Status Bar: Barra de Status

Fig. 12 – Aba Toolbars (Barra de Utilitários)

19.7 - Visualizar (Views) Aqui não há muito que explicar ative todas as opções e configure a opção Default Grid para 64.

Mas, como já é costume, vamos lá: Start Maximized: Iniciar Maximizado Show Thing Bitmaps: Exibir Imagens dos

Objetos Use Drag Cursor: Usar Opção Drag’n’Drop

(Arrastar e Soltar) Show Grid: Exibir a Grade Padrão Show Floor Grid: Exibe as intercessões da

grade Snap To Grid: Ajusta os vértices

automaticamente nas intercessões da grade.

Fig. 13 – Aba Views (Visualizar)

Bom, chega de configurações (por enquanto...). Vamos ao que interessa a edição de mapas!


- 45 -

20 - Selecionando um Jogo Para selecionar um jogo, você deve iniciar o programa WadAuthor, na tela principal do programa

clique em File → Select Configuration File, na janela que aparece (fig. 14), escolha o arquivo correspondente ao jogo que você quer editar.

As opções são: DOOM (Ultimate DOOM), DOOM 2, Heretic e Hexen. OBS: A opção Select Configuration File somente irá aparecer se não existir nenhum arquivo

WAD aberto! Tudo o que você aprender neste livro sobre edição de mapas para o DOOM e DOOM 2 também

servem para o Heretic (Algumas coisas também funcionam no Hexen, porém a edição de mapas para ele é muito mais complexa!). Bom, selecione o arquivo DOOM2.WCF e vamos prosseguir...

Fig. 14 – Caixa de seleção de configuração


- 46 -

21 - Criando um Mapa

A criação de um novo arquivo WAD é muito simples. Clique no botão na barra de ferramentas ou selecione New no menu File. Uma nova janela será criada com um mapa vazio pronto para editar, maximize a janela. A janela devera se parecer com a figura 15:

Fig. 15 – Novo mapa vazio

21.1 - Criando a Primeira Sala Para criar a primeira sala, clique com o botão direito do mouse no lugar onde a sala devera ser

criada. Um pequeno menu de contexto suspenso deverá aparecer. Este menu sempre trará as operações que são mais apropriadas para o objeto clicado.

Selecione a opção New Polygonal Sector... no menu de contexto, e digite a informação pedida

na caixa de diálogo resultante. Clique no botão OK para completar o processo e criar o novo setor.

Um setor corresponde ‘simplesmente’ a uma única sala. Eu digo ‘simplesmente’, porque uma sala, da perspectiva do jogador, pode ser composta de muitos setores diferentes para alcançar efeitos diferentes.

Na ilustração abaixo, eu criei um setor com 5 sides (lados), 256 radius (diâmetro) para o mapa.

O WadAuthor irá ajustar a janela para a melhor visão possível quando você pressionar a tecla ‘Home’. Pressione ‘Home’ e ajuste o zoom usando as teclas menos (-) e mais (+) até que você esteja satisfeito com a exibição.

Fig. 16 – Sala com 5 lados


- 47 -

Fig. 17 – Sala com 5 lados e 256 de diâmetro

23.2 - Mudando o Formato da Sala Para mudar a forma de um setor existente, clique e segure o botão esquerdo do mouse num dos

retângulos pequenos onde duas ou mais paredes de um setor se encontram (esse retângulo é o ponto de vértice!).

Ao fazer isso, terá início o sistema de Arrastar e Soltar (Drag’n’Drop), que lhe permitirá

posicionar o determinado o vértice onde você quiser.

As linhas (linedefs), de um setor são chamadas de paredes, e os pequenos retângulos onde as linhas se encontram são chamados vértices. As linhas sempre conectam no mínimo dois vértices, ao mover um vértice você estará mudando a forma global de um determinado setor. Note que cada linha tem uma outra pequena linha em seu centro apontando para dentro do setor. Estas linhas indicam qual é o lado frontal da linha. Isso se mostrará ser importante mais tarde no decorrer deste guia.

Você também pode mudar o número de lados que um determinado setor simplesmente mudando

o número de linhas. Clique com o botão direito do mouse em qualquer linha e selecione a opção Split Linedef(s) no menu de contexto. Isto criará um novo vértice no centro da linha, enquanto divide a linha pela metade. Você pode posicionar o novo vértice onde quiser como descrito acima, e modificar a forma da sala. Na ilustração abaixo, eu dividi uma das linhas e arrastei o novo vértice.

Fig. 18 – movendo um vértice


- 48 -

23.3 - Girando e Redimensionando (Escalando) a Sala O WadAuthor torna isto muito fácil de fazer, possibilitando que você mude a forma de uma sala

enquanto altera o seu tamanho global e orientação. Tentemos um exemplo. Clique com o botão direito do mouse em qualquer lugar dentro do setor, e selecione a opção

Rotate Sector... no menu de contexto. Na caixa de diálogo resultante, digite um valor para o ângulo e clique no botão OK.

O setor foi girado ao redor de seu centro conforme o número especificado de graus. Agora mudaremos o tamanho. Clique com o botão direito do mouse em qualquer lugar dentro do

setor, e selecione a opção Scale Sector... no menu de contexto. Na caixa de diálogo resultante, digite um valor para a porcentagem e clique no botão OK. O setor foi escalado ao redor de seu centro pelo valor especificado.

Aplicando escalas diferentes e rotações diferentes a setores diferentes, você poderá criar

virtualmente qualquer setor que desejar. Na ilustração abaixo, eu apliquei o valor de 30° graus para a rotação do setor e escalei o setor com um valor de 150%.

Fig. 19 – Redimensionando um setor

23.4 - Adicionando Jogadores e Inimigos Para especificar onde o jogador começará dentro do mapa, nós temos que criar um objeto que

indica o jogador no local desejado. Clique com o botão direito do mouse em qualquer lugar dentro do setor e selecione a opção New Thing... no menu de contexto.

Na caixa de diálogo resultante, selecione Start na caixa Class, Player 1 na caixa Type, e a

direção na qual o jogador estará olhando quando o jogo começar. Tenha certeza que as opções denominadas Level 1/2, 3, e 4/5 estão selecionadas e clique no botão OK.

Um mapa sem inimigos realmente seria muito chato, sendo assim antes de continuar, coloque

pelo menos um inimigo em algum lugar dentro do setor. Para fazer isto, repita o procedimento anterior para adicionar jogadores, selecione Enemy na caixa Class, e coloque algum inimigo da caixa Type.


- 49 -

Na terminologia de edição de um arquivo WAD, um objeto é qualquer objeto (diferente de paredes, chãos, etc.) com os quais o jogador pode interagir. Alguns objetos podem ser apanhados e usados (munição, energia, etc.), outros funcionam como paisagem (árvores, pilares, etc.), e alguns são completamente perigosos à saúde do jogador!

Na ilustração abaixo, eu adicionei um objeto de início para o jogador, um inimigo e uma arma. Fig. 20 - O jogador, um inimigo e uma arma Fig. 21 - Observando os Objetos Colocados (Nota: Você não pode ver o jogador porque ele é você!)


- 50 -

24 - Editando Propriedades dos Objetos do Mapa A edição de propriedades é uma das coisas mais básicas e compreende a maioria das operações

flexíveis no WadAuthor. Para editar as propriedades de um objeto existente no mapa, selecione um objeto e escolha Properties... no menu de contexto, ou escolha Properties... no menu Edit, ou tecle Alt+Enter para exibir a caixa de diálogo apropriada.

Nessa janela, você poderá editar diversos aspectos que definem as características do objeto

selecionado. Essa janela é diferente para objetos e para linhas, ou seja, cada um tem a sua janela própria com

opções próprias.


- 51 -

25 - Criando um Corredor Clique com o botão direito do mouse em uma seção em branco do mapa perto de um setor, e

selecione a opção New Rectangular Sector no menu de contexto. Digite a informação pedida na caixa de diálogo resultante, e tecle o botão OK para completar o processo. Clique e segure o botão esquerdo do mouse sobre uma linha, arraste e solte até que você obtenha um corredor semelhante ao mostrado na ilustração abaixo.

Fig. 22 – Criando um setor adicional

25.1 - Conectando o Corredor a Sala Principal Agora o nosso mapa caracteriza-se por possuir dois setores: a sala e o corredor. Nós precisamos

conectá-los de forma que o jogador possa mover-se entre eles. O WadAuthor automatiza este processo para você lhe permitindo unir duas linhas facilmente. Siga as instruções seguintes:

• Clique com o botão esquerdo do mouse na primeira linha a ser unida; • Pressione e segure a tecla Ctrl, clique o botão esquerdo do mouse na segunda linha para a

qual a primeira será unida; • Solte a tecla Ctrl e clique com o botão direito do mouse em qualquer uma das duas linhas

selecionadas; • Selecione a opção Join Linedefs no menu de contexto.

Você também pode executar essa operação clicando em um vértice, como botão esquerdo do

mouse, mantendo o botão pressionado arraste até um outro vértice e solte. Uma caixa de diálogo irá aparecer perguntando se você deseja unir esses vértices, clique OK.

É muito importante que você use estes métodos para conectar setores em um arquivo WAD. Para

cada linha, o WadAuthor tem que saber qual setor é o mestre em cada lado da linha. Se esta informação estiver corrompida, você não poderá jogar seu mapa.


- 52 -

Na ilustração abaixo, eu uni uma das linhas da sala ao corredor.

Fig. 23 – Conectando um setor ao outro

25.2 - Criando uma Porta Local Uma das características arquitetônicas mais comuns encontradas em um mapa é a porta local.

Uma porta local é simplesmente uma porta que abre para cima quando o jogador clica nela usando o botão de “use” (normalmente a barra de espaço). O WadAuthor simplifica o processo de criação convertendo um setor existente em uma porta local. O setor a ser convertido tem que ter pelo menos duas linhas de apoio, que unem o setor principal a um segundo setor.

Na ilustração abaixo, eu uni dois setores adicionais (um retangular, e um setor hexagonal de

cinco lados, com radius 256) a outro setor no fim do corredor existente e marquei usando um círculo o setor a ser convertido em uma porta.

Fig. 24 – Criando uma porta nova


- 53 -

Clique com o botão direito do mouse em qualquer setor que satisfaça as exigências listadas acima e selecione a opção Convert Sector To Door... no menu de contexto. A caixa de diálogo resultante lhe permitirá selecionar como a porta deveria se aparecer e se comportar (por padrão, apenas uma porta básica está previamente definida – você poderá criar outras portas se assim desejar!). Na ilustração abaixo, eu converti o setor previamente circulado em uma porta. Note que as linhas centrais mudaram sua orientação, ficando invertidas uma em relação à outra.

Isto é muito importante! Só o lado dianteiro de uma linha pode ser usado para ativar uma

determinada ação (Estas informações serão úteis mais tarde no decorrer deste guia).

Fig. 25 – Nova porta criada

Fig. 26 – Visualizando a nova porta

25.3 - Providenciando uma Saída É sempre uma boa idéia providenciar um meio pelos quais os jogadores possam encerrar um

determinado mapa e com isso poderem continuar no próximo. Caso contrário, o único modo de encerrar será a morte! Evitarei entrar em tópicos mais avançados, iremos fazer o básico. Nós aproveitaremos esta oportunidade para criar o nosso primeiro sub-setor e ajustar as nossas primeiras ações das linhas.


- 54 -

Vamos criar uma área dentro da segunda sala que encerrará o nível quando o jogador pisar dentro dessa área.

Coloque um novo setor retangular no centro do setor no qual você criou por último ao adicionar a

porta. Para isso, clique com o botão direito do mouse dentro de um setor existente e selecione a opção New Rectangular Sector... no menu de contexto. O WadAuthor é bastante inteligente para interpretar que você está criando um setor dentro de um outro setor. O novo setor automaticamente compartilhará o chão, teto e a iluminação atribuída previamente neste setor.

Lembre-se daquele negócio sobre o lado dianteiro de uma linha, pois é o único lado que pode

ativar ações. Aqui está o primeiro caso onde isto é importante. Os lados dianteiros das linhas em nosso sub-setor estão virados com a face para dentro. Nós vamos precisar inverter as linhas do subsetor para podermos criar uma saída.

Para inverter as linhas, clique com o botão direito do mouse dentro do sub-setor e selecione a

opção Flip Linedef(s)... no menu de contexto. Na janela que aparecer, selecione Include Textures and Other Data e clique no botão OK. As linhas deveriam estar apontando para a direção correta agora (ou seja, devem estar apontando para fora do sub-setor). Tudo bem resta apenas ajustar as linhas para que o jogo saiba que este setor é uma saída.

Clique com o botão direito do mouse novamente dentro do sub-setor e selecione a opção

Properties... no menu de contexto. Isto exibirá a janela Map Object Properties. Esta caixa de diálogo será explicada mais tarde com maiores detalhes durante o guia. Agora, clique na guia Linedefs/Sidedefs no topo. Na opção Class, selecione Exit, em Type selecione nW1: end level, go to next, e clique no botão OK. Agora as linhas do nosso sub-setor estão configuradas para que o mapa seja encerrado quando o jogador pisar dentro.

Na ilustração abaixo, eu criei um setor retangular pequeno dentro da segunda sala como descrito

nos parágrafos anteriores.

Fig. 27 – Criando uma saída


- 55 -

Fig. 28 – Observando a nova saída

25.4 - Jogando o Mapa

Bem, não deve haver nenhuma dúvida até agora, você já deve estar se cansando de criar um mapa novo. Afinal de contas, a parte mais divertida está em jogar o mapa! O programa WadAuthor torna isto muito fácil, o que é excelente para você poder testar o seu novo mapa sem precisar encerrar o programa.

Clique no botão ou selecione Run Map... no menu Tools, agora, na janela que apareceu selecione o nível de dificuldade em Skill Level, se você quiser jogar sem inimigos selecione No Monsters, se não quiser nenhum som escolha No Sound, embaixo existe uma caixa onde você poderá digitar opções extras que serão passadas ao jogo durante o carregamento do seu mapa. Após escolher as opções, clique no botão OK.

O WadAuthor irá abrir uma sessão do DOS e carregará o arquivo WAD mestre do jogo DOOM,

especificado no arquivo de configuração do WadAuthor, com o seu mapa novo.


- 56 -

26 - Edição Avançada de Mapas

26.1 - Criando uma Sala Secreta

Uma sala secreta é um tipo de porta; normalmente é a entrada para uma sala, que é de fato o verdadeiro segredo. Detalhes à parte, eu criei um pequeno mapa para ilustrar a criação de uma sala secreta. Considere a ilustração seguinte.

Fig. 29 – Criando uma sala secreta

O mapa acima tem uma sala hexagonal grande com uma porta em sua parede nordeste que

conduz, por um corredor, até uma sala pentagonal menor. Seguindo os passos abaixo, você fará uma sala menor e a transformará numa sala secreta.

• Mude a imagem da porta (apenas na linha que está voltado para a sala maior – a sala

hexagonal) colocando a mesma textura utilizada nas paredes desta sala. • Clique com o botão direito do mouse na linha da porta (apenas na linha que está voltada

para a sala menor – a sala hexagonal), selecione Properties... na janela Map Object Properties, selecione a opção Secret, clique no botão OK.

• Clique com o botão direito do mouse no centro da sala hexagonal, selecione Properties..., agora clique na guia Linedefs/Sidedefs, selecione a opção Secret.

Colocando a linha como Secret, ela só trabalhará se a altura do chão ou teto do setor for um pouco mais acima que a sala, o mapa mostrará a sala secreta imediatamente até mesmo nas linhas depois da porta e antes da porta, mesmo antes de abrir a porta.


- 57 -

26.2 - Criando um Teleporter

Um teleporter, no senso mais tradicional (se pode ser dito até mesmo que um senso tradicional existe para algo assim), é um pequeno sub-setor (normalmente um quadrado de 64 unidades) cuja suas linhas foram ajustadas para causar teleportação quando cruzadas. Porém, a criação de um teleporter também requer um local de destino de teleporter dentro de um setor devidamente marcado. Os passos seguintes irão ensinar a criar uma plataforma de início e destino para um teleporter.

• Crie um novo setor retangular, opcionalmente ajuste as texturas de chão e teto, e as

condições de iluminação como uma sugestão visual para o jogador. Esta será a plataforma do teleporter;

• Inverta todas as linhas no setor novo, inclusive texturas e outros dados. Para fazer isto, selecione o novo setor e escolha a opção Flip Linedef(s)... no menu de contexto;

• Ajuste as linhas do teleporter à ação desejada. Para fazer isto, edite as linhas da plataforma do teleporter e selecione o tipo de teleport desejado;

• Crie um objeto de destino. Para fazer isto, coloque um destino de teleport dentro do setor para o qual o jogador deveria ser teleportado;

• Ao criar um teleporter, você tem que aplicar valores (Tags) as linhas da plataforma do teleporter e ao setor de destino. Para fazer isto, abra a janela de Tags, e crie uma etiqueta nova, acrescentando os objetos necessários à lista.

Sempre tenha certeza que as linhas da plataforma do teleporter estão ajustadas

corretamente. Lembre-se que a ação de teleport acontece quando o jogador cruzar o lado frontal de uma linha.

Na ilustração seguinte, eu adicionei um teleporter para permitir passagem de mão única entre

duas salas retangulares sem conexão. Quando o jogador cruzar as linhas na plataforma de teleporter no quadrado 1, ele será imediatamente teleportado ao local 2.

Fig. 30 – Criando um teleporter


- 58 -

Fig. 31 – Teleporter criado

Note que o setor de teleporter está alinhado com uma grade igual a 64 (um

quadrado padrão). As texturas de chão e teto da plataforma de teleporter devem ter um padrão específico, isto é necessário para fazer com que o teleporter apareça corretamente para o jogador.

26.3 - Criando uma Escada Básica O WadAuthor automatiza um pouco o processo lhe permitindo especificar a direção, número de

degraus, iluminação, chão, teto, e as várias imagens que auxiliam na conversão de um setor retangular pré-existente em uma escadaria. Os passos seguintes irão ensiná-lo a criar uma escada básica.

• Crie um setor retangular no local desejado caso não exista nenhum; • Clique com o botão direito do mouse no setor retangular, selecione a opção Convert

Sector To Stairs... no menu de contexto; • Especifique o número desejado de degraus, as texturas dos degraus, e direção do setor a

ser convertido na janela resultante.

Serão preservados a orientação e atributos das linhas em todos os lados da escada. Isto pode ser muito importante para alcançar efeitos especiais. Observe as imagens abaixo:

Fig. 32 – Novo setor de escada


- 59 -

Fig. 33 – Observando o novo setor da escada


- 60 -

26.4 - Criando uma Janela Padrão Para facilitar o entendimento, primeiramente iremos criar três setores separados conforme

mostra a figura abaixo:

Fig. 34 – Três setores criados A imagem mostra dois quadrados e um retângulo, no quadrado da esquerda, aponte o mouse

para a linha que está ao lado do retângulo, clique com o botão direito e selecione a opção Split Linedef(s), um ponto deverá aparecer na linha selecionada.

Repita a operação mais uma vez na mesma linha, e faça a mesma coisa na linha ao lado do

retângulo no quadrado direito. Clique e arraste cada ponto até a posição que você desejar, ou seja, deve haver um espaço entre eles. Na imagem abaixo eu deixei dois quadrados entre cada linha.

Fig. 35 – Dividindo linhas Vale lembrar que as janelas podem ter qualquer formato: retangular, quadrada, circular, etc...


- 61 -

Agora vamos unir as linhas para criarmos a nossa primeira janela. Clique com o botão esquerdo do mouse num dos pontos (vértices) do retângulo, segure e arraste

até um dos pontos de um dos quadrados, conforme indica a imagem abaixo. Se você fez certo, uma mensagem irá aparecer perguntando se você deseja unir esses dois vértices, clique Sim.

Fig. 36 – Unindo vértices O resultado da união é mostrado na imagem abaixo. Faça o mesmo com os outros vértices.

Fig. 37 – Vértices unidos

ATENÇÃO: Nunca cruze duas ou mais linhas sem que elas estejam unidas por vértices!


- 62 -

Para finalizar, ajuste as dimensões da janela, de acordo com suas preferências. Tome como base à imagem abaixo.

Fig. 38 – Dimensões da janela ajustada Agora vamos testar e ver como ficou a nossa ‘janela’. No WadAuthor tecle Ctrl+R para iniciar o

novo mapa. Vejamos como ficou!

Fig. 39 – Cadê a janela? Só tem um buraco! Você deve estar se perguntando: Onde diabos está a janela? Eu só vejo um buraco na parede!


- 63 -

Calma! Falta uma parte importante do processo, que é simplesmente ajustar a altura da janela (relação: chão X teto).

Dê um clique duplo no centro da janela (retângulo), uma tela com diversas opções irá aparecer

conforme mostra a imagem abaixo.

Fig. 40 – Janela de opções Nessa tela, você poderá ajustar alguns efeitos para a área da janela, como as texturas de chão e

teto, altura do chão e teto, luminosidade, entre outras opções. No momento as opções que iremos usar são:

Ceiling / Heigth – altura do teto Floor / Height – altura do chão

Altere o valor de Ceiling / Height para 104, e o Floor / Height para 24, no menu do WadAuthor,

clique ou selecione a opção Check Map. Isso irá verificar e listar todos os erros existentes no seu mapa. Como o nosso mapa é simples, deverão ser exibidos apenas quatro erros relacionados às

texturas. Isso se deve ao fato de termos abaixado o teto e levantado o chão no local da janela, criando

uma nova parede sem nenhuma textura. Para corrigir esse problema clique na opção Fix All, conforme mostra a imagem abaixo.


- 64 -

Fig. 41 – Corrigindo o erro das texturas Teste o mapa novamente e veja o resultado. A imagem abaixo mostra como ficou a janela.

Fig. 42 – Janela criada!


- 65 -

26.5 - Ajustes Finais Parabéns! Você acaba de criar a sua primeira janela! Observe na imagem anterior, que as texturas não estão devidamente alinhadas com o resto da

parede, e o que é pior, você pode atravessar a janela como se ela não existisse! Vamos ajustar isso agora!

Clique com o boto direito no centro da janela (retângulo), e selecione a opção Properties.

Fig. 43 – Opção propriedades Na janela Map Object Properties, clique na aba Linedefs/Sidedefs. Na seção Attributes selecione as opções Impassable, Upper Unpegged e Lower Unpegged. Respectivamente:

Impassable – Impede que você atravesse um setor Upper Unpegged – Ajustar textura superior Lower Unpegged – Ajustar textura inferior

DICA: A opção Impassable pode ser utilizada para bloquear a passagem em qualquer lugar do mapa.


- 66 -

Selecione as opções conforme a imagem abaixo.

Fig. 44 – Opções selecionadas Inicie o mapa e teste os resultados. Parabéns!

Fig. 45 – Janela pronta!


- 67 -

27 - O Que é ACS Script? ACS é uma linguagem de scripting que foi criada para o jogo Hexen e posteriormente expandida

pelo port ZDoom. A linguagem ACS permite a criação de eventos dentro dos níveis durante uma partida, possibilitando a criação de ambientes interativos usando a engine de DOOM modificada e expandida.

Com comandos muito básicos, um autor pode modificar a estrutura de um nível possibilitando a

inclusão de efeitos que não existem na engine original, como mergulhar e nadar em águas profundas, portas que abrem para ambos os lados, chão e teto que sobem e descem separadamente ou simultaneamente, entre muitos outros efeitos.

Você pode até mesmo mover determinadas paredes que possuem determinados critérios (veja a

seção PolyObjects). As texturas indicadas em pisos e em paredes podem ser mudadas. Os monstros (e alguns outros objetos) podem ser colocados, removidos, monitorados, terem suas propriedades alteradas, terem seus objetivos ajustados, etc...

Definido de uma maneira menos técnica, um script é algo que uma pessoa pode escrever em um

editor de textos, contendo scripts individuais (como de sub-rotinas), comandos, declarações variáveis, e assim por diante.

Atualmente existe apenas um compilador de ACS Script, o ACC.exe (que pode ser pego no site do

ZDoom), e um descompilador, o DEACC.exe. A linguagem ACS é muito poderosa e extremamente flexível, possuindo uma gama enorme de possibilidades para uma pessoa com talento, paciência e imaginação!

A linguagem ACS possui muitas características e semelhanças com outras linguagens de

programação, ele foi estruturado em C/C++ (e também pode ser comentada, como mostrado no exemplo). Um script é iniciado escrevendo algo tal como o seguinte:

// This is a comment int AvailableToAllScripts = 101; int ICanMakeArrays[3] = {3,6,9}; SCRIPT 1 OPEN { If (AvailableToAllScripts == 101){ Restart; } }

Por favor, note que isso criará um looping em um script sem provocar qualquer tipo de atraso, e

fará com que o ZDoom termine automaticamente o script, porque não dará a qualquer outra coisa no mapa uma possibilidade de funcionar. Você verá uma mensagem como o seguinte quando isso acontecer:

Runaway script 1 terminated

Variáveis são dimensionadas em muitas linguagens de programação. Se você quiser que uma

variável esteja disponível para todos os scripts, declare ou a defina fora de todos os scripts. As disposições, ou as variáveis que você pode armazenar e consultar possuem muitos valores, diferenciando-se entre eles através de um índice (ICanMakeArrays[2] = 9) é válido em ZDoom.


- 68 -

Note que um script é definido como uma função em C, com exceção do ‘oddity’ que não precisa ser encerrado após a execução de todas as indicações restantes. "OPEN" usado neste exemplo, é um tipo de instrução do script que diz ao ZDoom que o script deve ser executado no momento em que começar o nível.

Note também que o ACS suporta indicações condicionais, e conseqüentemente os loops feitos

com indicações condicionais. Suporta a maioria das implementações de C/C++ (mas não todas!) para indicações condicionais e loops condicionais. ACS necessita ser compilado antes que possa ser usado em um mapa. O utilitário de linha-de-comando ACC.exe foi projetado para esta finalidade.


- 69 -

28 - Dominando ACS Script Agora irei passar uma lição básica sobre ACS Script, ensinando alguns conceitos e definições.

28.1 - ACS Script Básico

28.2 - Estrutura de um Script

ACS, como toda linguagem de programação ou de um grupo, usa seu próprio jogo dos símbolos e deve seguir um determinado formato a fim de ser compreendido pela engine. Quando a linguagem ACS foi criada, escolheu-se modelar o formato e a sintaxe o mais próximo possível da linguagem de programação C. Aqueles que forem familiarizados com C serão capazes de entender prontamente seu script.

Como escrever um script? Deixe-me começar com um exemplo simples:

O que este script faz? Vou explicar cada linha: // My first ACS script Esta é uma linha comentada. Os comentários não afetam o comportamento do script, servem

somente para notas ou explicações curtas sobre o script (veja a seção comentários). Todo arquivo de script deve começar com a seguinte linha de comando:

#include "zcommon.acs" O comando ‘#include’ instrui o compilador a abrir o arquivo e executá-lo antes de continuar

processando o arquivo atual, ele denomina uma diretriz orientadora e é uma instrução a engine. O arquivo ‘zcommon.acs’ é uma arquivo padrão que contem todas as definições básicas. Este arquivo carrega internamente instruções para o processamento de três outros arquivos e fornece a engine uma série de outros elementos. Permite também que o programador do script use valores que podem ser lidos varias vezes, como ações humanas. Basicamente cada script que você fizer deve incluir essa linha.

script 1 enter Este é o começo de uma definição do script. O número de identificação do script é 1 e o ‘enter’

significa que o script está ativado por cada jogador que entrar no mapa. O numero deve ser único entre todos os outros scripts que seguem o ACS que o programador quiser fazer para seu mapa, eles NUNCA devem se repetir.

// My first ACS script #include "zcommon.acs" script 1 enter { Print (s:"Hello world!"); }


- 70 -

print (s:"Hello world!"); Essa linha é uma indicação de ACS. A opção ‘print’ é o nome da função interna que imprime uma

mensagem na tela - esta imprime “Hello world!”. Outro exemplo, o programador do script pode também incluir diretamente a um script o seguinte

comando: #define pausetime 70 Esta indicação diz a engine para substituir todos os valores que aparecem na palavra ‘pausetime’

pelo número 70. Há somente uma variável datilografada dentro do ACS. As duas palavras chaves INT e STR

definem seu uso. INT é usado para um número e o STR é usado para uma informação de personagem. As variáveis são simplesmente valores que armazenam informações para o uso em outra ocasião.

Um script também pode ser definido pela lista de parâmetros, como ‘OPEN’ e ‘(void)’. OPEN faz com que seu script seja carregado antes que o mapa comece a rodar, e (void) é

utilizado quando você quer que o script seja executado somente com a ação do jogador, como na morte de um monstro ou na ativação de uma linha.

É importante que seu script comece com um { e termine com }, é no meio dessas “chaves” que

os comandos do seu script são executados. Todos os comandos do seu script devem terminar com um (;), somente assim a engine identifica que o comando parou.

Este exemplo de script não usa nenhum parâmetro e é carregado ao iniciar o mapa. #define mysector 1 script 1 OPEN { sector_setcolor (mysector, 255, 255, 0); } O próximo script tem um parâmetro (void):

script 2 (void) { light_changetovalue (1, 180); } O próximo manda o script bloquear uma linha, e também usa um “valor humano”, para “desligar”

e “ligar”. script 3 (int line) { setlineblocking (line, OFF); }

28.3 - Comentários

Os comentários são partes do código fonte ignorada pelo compilador. Simplesmente não fazem nada. Sua finalidade é permitir que os programadores introduzam notas ou descrições no código fonte.

ACS suporta 2 estilos de comentários:


- 71 -

// line comment /* block comment */

O primeiro tipo, como indicado acima, inicia onde o par de sinais barra normal (//) começa e

termina na extremidade da mesma linha. O segundo tipo, como indicado acima, inicia com os caracteres /* e termina com os mesmos caracteres em formatação oposta */.

Veja o exemplo seguinte que utiliza os dois tipos de comentários: /* Wow my second ACS script, now with more comments. As you can see this is a block comment so it can go through more lines */ #include "zcommon.acs" // This is executed when player enters the level script 1 enter { Print (s: "Hello world!"); // Print the sequence "Hello world!" }

28.4 - Variáveis

ACS (Action Code Scripting) possui apenas um tipo de dado, um byte de quatro letras, e para que uma variável venha a ser usada ela deve ser declarada.

int line; str message;

As indicações acima dizem a engine que deve colocar um espaço na memória para duas

variáveis, uma será um número (int) e a outra uma mensagem (str). As variáveis neste momento, não têm nenhum valor significativo uma vez que elas não foram inicializadas. Essa declaração reservou simplesmente alguma memória para usar no futuro.

Para usar uma variável você deve ajustá-la a um valor significativo usando um dos operadores de

atribuição. O ACS reconhece os seguintes operadores de atribuição: =, + =, - =, * =, /=, % =, + +, - -. Eles serão familiares aos programadores de C, e para o resto de nós, as seguintes definições esclarecerão seu uso. = atribua o valor na variável. A = 1; + = adicione ao valor já na variável. A + = 1; Isso é o mesmo A = A + 1. -= subtraia do valor já na variável. A - = 1; Isso é o mesmo A = A - 1. * = multiplique ao valor já na variável. A * = 2; Isso é o mesmo A = A * 2. / = divida pelo valor já na variável. A/= 2; Isso é o mesmo A = A/2. % = atribua o restante (módulos) à variável. Um % = 3; Isso é o mesmo que A = A % 3. + + adiciona 1 ao valor já na variável. A++; Isso é o mesmo A = A + 1. - - subtraia 1 do valor já na variável. Um - -; Isso é o mesmo A = A - 1.


- 72 -

Além de um valor, uma variável tem uma propriedade chamada ‘espace’ (espaço). O espaço é a visibilidade da variável. Há três níveis possíveis no ACS. São eles: World, Map e Script.

O ‘World’ significa que a variável é visível a todos os scripts em todos os mapas. Este tipo de variável seria usado para a informação que pertence ao WAD como um todo. Uma variável World pode ser usada em qualquer parte do script e em qualquer mapa do WAD.

O ‘Map’ significa que a variável é visível somente em um mapa particular. Isto é, se você declarar

uma variável no map01, ela não é acessível ao map02. Todos os scripts em ‘map01’, terão o acesso à variável.

O ‘Script’ significa que a variável é visível somente em um script em particular. Se você definir

uma variável dentro do script 1, ela não será acessível ao script 2. O espaço de uma variável depende sobre onde a variável é declarada. O espaço das variáveis

World pode ser definido fora de todo o script e devem ser identificadas pela palavra ‘world’, seguido por um número de índice e pelo nome da variável.

world int 1:wadbadguycount;

A variável ‘wadbadguycount’ será acessível a todos os scripts em qualquer mapa. As variáveis

‘Map’ são declaradas fora de todos os scripts, dentro de um mapa particular. int mapbadguycount; A variável ‘mapbadguycount’ poderá ser acessada por todo o script no mapa atual. As variáveis de map do script são declaradas dentro do script.

script 1 (void) { str message; message = "Hello"; ...commands...; }

A variável ‘message’ só pode ser usada dentro do script 1 e não pode ser usada em nenhum

outro script.

28.5 - Usando Variáveis

Uma das coisas legais de se fazer com o ZDoom são as variáveis, elas são simples e podem gerar efeitos complexos e bem divertidos em um mapa.

Por exemplo, é possível fazer uma variável em que o jogador precise ativar 5 alavancas para que

uma porta se levante, e se alguém tentar abrir essa porta antes de ter ativado as 5 alavancas, a porta ‘fala’ que você deve ativar essas alavancas.

Para começar uma variável, lembre-se de saber o que você quer fazer com ela, depois de ter

imaginado um exemplo vamos ao script. Lembre-se de fazer pelo menos o ‘esqueleto’ do script. #include "zcommon.acs" script 1 (void) ou script 1 open { }

Agora vamos definir nossa variável, uma variável é definida com um simples ‘int;’


- 73 -

Esse ‘int;’ será o comando para definir uma variável, você pode usar qualquer nome para ela por

exemplo, vamos usar o exemplo das 5 alavancas, vamos colocar o nome da nossa variável de ‘alavacnt’.

#include "zcommon.acs" int alavacnt; script 1 (void) ou script 1 open { commandos // Aqui serão colocados os comandos }

Já definimos nossa variável, ela tem o valor 0 (zero), isso significa que ela não está ativada, e

também significa que enquanto ela não estiver com o valor 1, ela estará executando outros comandos. Não entendeu? Fique calmo, eu explico. O ACS trabalha com variáveis da seguinte maneira: Basicamente enquanto a variável ‘X’ não estiver com seu valor verdadeiro (TRUE), serão ativados

os comandos falsos (FALSE). Em um script quando escrevemos uma variável e ela não está sendo usada, ela não tem valor nenhum, isso quer dizer que ela não tem nem mesmo o valor 0 (zero), significa também que ela não será utilizada, enquanto não for chamada por um script.

Para usá-la em um script você deve lembrar que o ZDoom trabalha com operadores lógicos, isso

significa que você vai basicamente trabalhar com operações matemáticas. Ou seja, se você é péssimo em matemática, não use variáveis!!!

Lembra-se que ela não está ativa porque não estamos usando-a em um script? Então vamos usá-la, para usá-la vamos fazer o seguinte script: // Esses traços aqui são comentários, nos deixamos isso no script para // que eles ajam como notas para programadores ou pessoas que queriam // modificar o script. Eles não influenciam nas ações em si #include "zcommon.acs" // Aqui a variável está sendo definida int alavacnt; // Esse script irar executar antes do mapa abrir script 1 (open) { {if (alavacnt==5); // Se o contador for igual a 5 ativação OK door_open(12,5,13); acs_terminate(1,0); } else { delay(16); restart; } } Parece um monte de numero sem conexão não é mesmo? Mas a engine irá identificar esses

valores e interpretar o conteúdo do script. Observe como isso funciona. Quando colocamos esse ‘IF’ a engine lê o script da seguinte maneira:

if (alavacnt==5);

Isso que dizer que se o contador das alavancas for igual a 5, todos os comandos abaixo dela serão ativados, no nosso script os comandos abaixo desse ‘IF’ são:


- 74 -

door_open(12,5,13); acs_terminate(1,0);

Lembra-se que era só para quando o jogador ativar as 5 alavancas que a porta deveria abrir? Pois o ‘door_open’ só é ativado quando as 5 alavancas forem ativadas, o ‘acs_terminate’, irá

terminar o script dessas alavancas assim que elas estiverem ativadas, assim você não corre o risco de ter erros.

Mas o que acontece se as alavancas não estiverem ativadas? Simples! Você lembra que no meio

daquele script tem um ‘else’ (equivalente a ‘se não’). Ele funciona da seguinte maneira, lembra-se que no ‘script 1’ tinha o contador de alavancas, e que se o valor delas não estivesse em 5 a porta não iria abrir, então o else funciona em uma variável da seguinte maneira.

//Se as 5 alavancas não estiverem ativadas execute esses comandos else { delay(16); restart; } } Entendeu ? Não?? Calma que eu explico. Esse ‘delay’ é um intervalo para que o ZDoom possa calcular o script, se não houvesse esse

intervalo o script sairia correndo ‘literalmente’ e iria ocasionar um erro. O infame ‘Runaway Script’. O ‘restart’ indica que o script deve ser executado várias vezes para que assim a engine possa

trabalhar com a variável. Bom você se lembra que nossa variável esta com valor 0 (FALSE) e que precisamos começar a

colocar valores nela certo? Então como fazer? Simples! Com os operadores lógicos, recapitulando que o ZDoom trabalha com os seguintes operadores lógicos:

= atribua o valor na variável. A = 1; + = adicione ao valor já na variável. A + = 1; Isso é o mesmo A = A + 1. - = subtraia do valor já na variável. A - = 1; Isso é o mesmo A = A - 1. * = multiplique ao valor já na variável. A * = 2; Isso é o mesmo A = A * 2. * = divida pelo valor já na variável. A/= 2; Isso é o mesmo A = A/2. % = atribua o restante (módulos) à variável. Um % = 3; Isso é o mesmo que A = A % 3. + + adiciona 1 ao valor já na variável. A++; Este é o mesmo A = A + 1. - - subtraia 1 do valor já na variável. Um --; isto é o mesmo A = A - 1.

Então o que temos que fazer é que a somatória da nossa variável chegue até 5, assim a porta se abre! E para fazer isso vamos usar o operador lógico ‘+=’ assim ele soma valores na nossa variável. Para fazer com que a nossa variável ganhe valores vamos definir o ‘script 2’.

script 2 (void) { alavacnt+=1; }

Isso significa que toda vez que o jogador ativar esse script a variável ‘alavacnt’ vai ganhar o valor

1, por que o operador ‘+=’ soma valores na variável! Então se colocarmos 5 scripts desse a nossa variável teria o valor 5. E ai a porta iria se abrir!


- 75 -

#include "zcommon.acs" //definindo a variável int alavacnt; script 1 (open) //se a variável estiver com valor 5 executar esses comandos { {if (alavacnt==5); door_open(12,5,13); acs_terminate(1,0); } // caso não esteja executar esses comandos else { delay(16); restart; } } //somando valores na variável script 2 (void) { alavacnt+=1; } script 3 (void) { alavacnt+=1; } script 4 (void) { alavacnt+=1; } script 5 (void) { alavacnt+=1; } script 6 (void) { alavacnt+=1; } Assim que a variável estivesse com valor 5 todos os comandos abaixo dela seriam ativados, no

nosso caso uma porta seria aberta, e esse script seria encerrado. Bom isso é tudo que precisamos, mas vamos deixar as coisas mais interessantes. Você pode usar mais de 1 script do tipo ‘OPEN’ no seu WAD, então que tal fazermos o seguinte,

cada vez que o jogador ativar os scripts que somam valores na nossa variável uma mensagem diz quantas alavancas ou quantas ativações faltam?

Você se lembra que a nossa variável começa com valor 0 (zero), e que só quando ela alcançar o

valor 5 é que a porta será aberta, então vamos colocar um script para que a cada vez que ela receber um valor, ela faça algo, usando a mesma variável.

Você lembra que só tinha um script que seria executado quando a variável tivesse valor 5,

apenas vamos fazer mais scripts quando a variável tiver mais valores, como a nossa variável tem valor 5 vamos fazer mais 4 scripts OPEN, afinal já temos 1. Então apenas precisamos colocar mais scripts OPEN que funcionem com os valores das variáveis, observe:


- 76 -

script 6 open { {if (alavacnt==1); print(s:"4 activations left"); acs_terminate(6,0); } else { delay(16); restart; } }

Esse script manda uma mensagem (print) sempre que a alavanca estiver com um valor 1, lembra

que a porta só abre quando tiver com o valor 5, então apenas coloque vários scripts antes da variável tomar o valor 5.

script 6 open { {if (alavacnt==1); print(s:"4 activations left"); acs_terminate(6,0); } else { delay(16); restart; } } script 7 open { {if (alavacnt==2); print(s:"3 activations left"); acs_terminate(7,0); } else { delay(16); restart; } } script 8 open { {if (alavacnt==3); print(s:"2 activations left"); acs_terminate(8,0);

} else { delay(16); restart; } } script 9 open {


- 77 -

{if (alavacnt==4); print(s:"1 activations left"); acs_terminate(9,0); } else { delay(16); restart; } }

Observe que a cada vez que a pessoa colocar um valor na variável as mensagens aparecem! Se quiser colocar um script onde a pessoa fica sabendo quantas ativações faltam apenas copie e

cole esse script abaixo. O script esta limitado a 5 ativações mas você pode mudar isso, ele está devidamente comentado, isso irá ajudá-lo a lembrar-se de substituir os comandos de acordo com os rótulos e valores que você quer.

//Switch Script //by [DBR]Megamanx3 #include "zcommon.acs"

//identificando a variável

int alavacnt; //limite de ativações, se quiser mude para a quantidade que quiser na linha //{if (alavacnt==5); //Lembre-se de que mudando a quantidade você terá que colocar mais scripts. script 1 open {

{if (alavacnt==5);

print(s:"seguence complete"); door_open(tag,speed,amount); // door_open(rotulo,velocidade,quantidade) acs_terminate(1,0); }

else { delay(16); restart;

} } script 2 open { {if (alavacnt==4); print(s:"one activation left"); acs_terminate(2,0); } else { delay(16); restart; }


- 78 -

} script 3 open { {if (alavacnt==3); print(s:"two activations left"); acs_terminate(3,0); } else { delay(16); restart; } } script 4 open { {if (alavacnt==2); print(s:"three activations left"); acs_terminate(4,0); } else { delay(16); restart; } } script 5 open { {if (alavacnt==1); print(s:"four activations left"); acs_terminate(5,0); } else { delay(16); restart; } } Esse é o script que insere valores na variável, coloque esse script nas linhas que o jogador deve

ativar.

script 6 (void) { alavacnt+=1 }


- 79 -

29 - Criando um Script

29.1 - Um Script Básico

Para começar um script a primeira coisa importante a se fazer é, saber o que você quer fazer, por exemplo, suponhamos que você queira que um evento aconteça da seguinte maneira.

1. Um jogador aperta um botão; 2. Alguns setores levantam seus pisos; 3. Algumas paredes trocam suas texturas para texturas de sangue; 4. Depois de 5 segundos, esse setor fica vermelho e aparece um Archvile.

Pode parecer complicado, mas é muito simples de se fazer, antes de tudo tenha o mapa

preparado, para tal evento. Rotule os setores que terão seus pisos levantados, agora para se rotular uma textura no formato ZDoom (Doom in Hexen Format), use a linedef 121 (H - Line Identification), ele usa apenas um parâmetro o LineID, que é o rótulo da linha, este rótulo pode ser o mesmo rótulo de um setor, porque o ZDoom trata de forma diferente o rótulo de um setor e o rótulo de uma linha.

Agora escolha as linhas nas quais você quer que a textura se transforme em sangue. Lembre-se

de que essas texturas podem ou não conter o mesmo rótulo, se elas estiverem com o mesmo rótulo, você não precisará de um script muito grande, caso elas não estejam com o mesmo rótulo, você vai ter que definir a troca de cada uma delas, após ter feito esse processo, rotule o último setor que deverá ter uma cor nova.

Agora que já sabemos o que queremos que aconteça, está na hora de começar o script, vamos

começar pelas linhas, você se lembra que nós tínhamos suposto que o jogador deveria apertar um botão antes de todo o script começar a rodar, bem, faça esse botão em um editor de mapas e coloque uma textura no mesmo, depois de criar o botão, vamos rotular uma das linhas com o linedef 80 (H - Script Execute), assim o script somente será executado quando essa linha for ativada, antes de começar a criar o script lembre-se de checar a ativação dessa linha, ela pode ser ativada por vários fatores os quais são:

• Player Walks Over: O jogador passa por cima da linha, e esta é ativada; • Player Presses Use: O jogador ativa a linha apertando a tecla ‘Use’ (Barra de Espaço); • Monster Walks Over: Um monstro de qualquer tipo passa por cima da linha ativando-a; • Projectle Hits: Um projétil, como um tiro disparado por um monstro ou um jogador ativa a

linha; • Player Bumps: O jogador ‘esbarra’ na linha ativando-a; • Projectle Flies Over: Um projétil disparado de um monstro ou de um jogador passa pela

linha ativando-a; • Player Presses Use (Pass Thru): O jogador pressiona a tecla ‘Use’ (Barra de Espaço), mas

ele também passa pela linha, para ser ativada; • Projectle Hits or Crosses: Um projétil atinge ou passa pela linha para que essa seja

ativada.

No nosso caso a ativação será pelo ‘Player Presses Use’. Agora vamos ao script, a maioria dos editores de mapas, vem com uma configuração de script diferente para cada formato, então, não adianta usar ACS no DOOM Legacy (isso será abordado mais tarde).

Abra um editor de textos qualquer (use o Notepad – Bloco de Notas) para fazer scripts, na

primeira linha do seu script digite: #include "zcommon.acs"


- 80 -

Este ‘#include’ diz a engine que inclua o ACS no seu arquivo WAD, sem ele o script não seria compilado, o ‘zcommon.acs’ é um dos ACS que a engine do ZDoom usa, o zcommon.acs inclui todas as outras configurações de ACS do ZDoom, depois apenas defina seu script:

#include "zcommon.acs" script 1

Esse ‘script’ apenas define que isso é um script e o 1 é o numero do script, agora devemos definir

se ele vai ser ativado antes do mapa ser carregado ou apenas quando um jogador ativa-lo. No nosso caso, o jogador deve ativar o nosso script, para fazer isso devemos definir se o script é ‘OPEN’ ou é (void):

• OPEN: O script será executado antes de o mapa ser carregado; • (void): O script só é executado quando uma linha ou um evento for ativado.

No nosso exemplo fica:

#include "zcommon.acs" script 1 (void)

Depois de definir o script vamos colocar as ações desse script, essas ações devem estar dentro

do mesmo script, então para definir ações em um mesmo script se usa { e } dentro dessas chaves suas ações estarão sendo definidas.

ATENÇÃO! TODA AÇÃO DEVE SER DEFINIDA DENTRO DE UM SÍMBOLO!

#include "zcommon.acs" script 1 (void) {comandos } Agora vamos à parte mais importante, no nosso script várias ações iriam acontecer depois que o

jogador ativa-se o botão certo, o primeiro passo é saber quais comandos se encaixam no nosso script, por exemplo, existe uma lista imensa no ZDoom wiki de comandos, você apenas deve achar um que se encaixa no seu script no nosso caso, alguns pisos vão subir, esse efeito é obtido pelo simples comando:

Floor_raisebyvalue (Piso_levantaporvalor), esse comando faz com que um piso (floor) se levante

por um determinado valor, todos os comandos de um script possuem uma opção chamada de ‘valor’ (value), indicam o que pode ser usado em um comando e devem ficar entre dois () para que a engine possa identificar.

Exemplo: Floor_raisebyvalue(tag,speed,value) // Sendo, (rótulo,velocidade,valor)

Então apenas preencha de acordo com o que você quer no seu script, digamos que o rótulo dos

pisos que terão seus valores alterados seja 2:

#include "zcommon.acs" script 1 (void) { Floor_raisebyvalue(2,........) } Agora só falta definirmos a velocidade e o quanto esse piso será elevado.


- 81 -

script 1 (void) { Floor_raisebyvalue(2,25,......) }

e agora só falta o valor.

script 1 (void) { Floor_raisebyvalue(2,25,35) }

Pronto! O seu piso já irá elevar-se com a velocidade de 25 e vai elevar-se em 35 unidades. Bom

agora nossos pisos já irão levantar, então o que falta? As paredes trocarem suas texturas! Lembra-se de que só precisamos achar algum comando que se encaixe com o que queremos em nosso script, nesse caso é o ‘setlinetexture’.

setlinetexture(side,position,texture) // Sendo, (lado,posição,textura) Agora digamos que as linhas rotuladas tem um valor 3, vamos colocar em nosso script, mas

antes, vamos usar a cabeça. Pense bem, se você um jogador, não iria achar estranho que de repente uma textura de parede irá virar sangue, o setor fica vermelho e um Archvile aparece em menos de 2 segundos!?!? Para resolver isso foi inventado o ‘delay’ (intervalo), esse intervalo trabalha com ‘tics’.

delay(tics) // Sendo, (tempo)

Lembre-se de que 35 ‘tics’ equivalem a 1 segundo então vamos colocar um intervalo de 1 segundo entre os comandos, para que assim pareça mais real.

script 1 (void) { Floor_raisebyvalue(2,25,35); delay(35); setlinetexture(side,position,texture) } Agora vamos continuar o nosso script, completando o ‘setlinetexture’, lembre-se de colocar tudo

corretamente, e do jeito que você quer, no nosso caso a textura será de sangue, então mudamos a ‘Texture_Middle’ para ‘blood1’, que é a textura de sangue do Doom 2.

setlinetexture(3,SIDE_FRONT,TEXTURE_MIDDLE,"Blood1"); Agora o comando esta completo, vamos adicioná-lo em nosso script. script 1 (void) { Floor_raisebyvalue(2,25,35); delay(35); setlinetexture(3,SIDE_FRONT,TEXTURE_MIDDLE,"Blood1"); }

Agora a sala fica vermelha, usaremos o comando ‘sector_setcolor(tag,red,blue,green)’, vamos

dizer que nossa sala tem o rótulo 5. Lembre-se de que a sala só fica vermelha depois de 5 segundos, então... Intervalo neles! 35x5 = 255

script 1 (void) { Floor_raisebyvalue(2,25,35); delay(35); setlinetexture(3,SIDE_FRONT,TEXTURE_MIDDLE,"Blood1"); delay(255); sector_setcolor(5,203,0,0); }


- 82 -

E agora colocamos o Archvile! O comando para colocar objetos no mapa é obtido pelo ‘thing_spawn(tid,type,byte,tid)’. Vamos apenas colocar um Archvile, mas antes é necessário um ‘mapspot’ no mapa para indicar onde o Archvile irá aparecer, então rotule um mapspot, o rótulo dele também pode ser igual ao de um setor. O rótulo do nosso mapspot será 4, vamos coloca-lo em nosso script.

script 1 (void) { Floor_raisebyvalue(2,25,35); delay(35); setlinetexture(3,SIDE_FRONT,TEXTURE_MIDDLE,"Blood1"); delay(255); sector_setcolor(5,203,0,0); delay(35); thing_spawn(4,T_Archville,0,0); } Pronto seu script está completo, não foi tão difícil foi?

29.2 - Executando Ações num Script

O verdadeiro poder do ACS vem à tona na hora de fazer decisões. No Doom uma ação só poderia ocorrer quando um jogador clica-se num botão, atravessa-se uma linha ou tivesse uma chave (amarela, azul ou vermelha), assim uma porta abriria ou um evento ocorreria. Mas agora uma série de critérios pode ser adotada para que uma ação aconteça.

A indicação IF-ELSE é uma ferramenta de decisão no ACS. Ela é muito poderosa e é usada na

hora em que uma indicação ativar o valor TRUE. TRUE é definido por um valor não-zero. 1 é TRUE assim como 4, 10, e 1+1. FALSE é definido como 0 (zero). O formato ficaria assim:

IF (evaluation) commands; ELSE commands; Os comandos sob IF só serão executados se a avaliação (evaluation) retornar um valor

verdadeiro (TRUE) diferente de zero. Se a avaliação for FALSE (zero), os comandos abaixo do IF serão ignorados e os comandos sob

o ELSE é que serão executados. Note que a indicação ELSE é opcional. Lembre-se de que os comandos múltiplos devem ser incluídos dentro { e }.

Por exemplo, ‘if A = 1’ então: ‘if (A)’ tornará verdadeiras (TRUE) as indicações se for executado. ‘se A = 0’ então: ‘se (A)’ tornará falso (FALSE) as indicações que sequem IF(SE) serão ignoradas.

Entretanto, A é geralmente uma variável não única de indicação. O IF usa argumentos lógicos para ser executado que estão entre ( e ). Estes são chamados de

Logical Operators (Operadores Lógicos). Os operadores lógicos são: !, &&, ||, ==, !=, >, <, >=, <= ‘!’ (Exclamação), não é operador!!! Mas você disse que era!? Calma, este é o operador o mais

difícil de compreender porque se opera em uma forma INVERSA.


- 83 -

script 1 (int switch) { // Se o jogador não ativou a Alavanca ainda // não faça nada! if (!switch) print (s:"You need to activate a switch first") // Execute esses comandos quando ele tiver ativado a alavanca else commands...; } ‘&&’ esse é o operador AND(E). Esse operador é usado para testar a ‘verdade’ de todas as

variáveis, em um jogo de variáveis. Todas as variáveis testadas devem ser TRUE (verdadeiro) para que toda a indicação seja verdadeira. Se uma variável for FALSE (falsa), toda a indicação se tornará FALSE (falsa).

script 1 (int sw1, sw2, sw3) { // Se todas as alavancas tiverem sido apertadas // ative a radiação if (sw1 && sw2 && sw3) sector_setdamage (1, 50, MOD_LAVA); // Desligue a radiação else sector_setdamage (1, 0, MOD_WATER); } script 1 (int sw1, sw2) { //se um ou outro interruptor for acionado, ligue a luz. if (sw1 || sw2) { light_raisebyvalue (1, 180); print (s:"Ah, you can see now") } } ‘==’ Este é um operador de igualdade. Ele tornará verdadeiro se duas variáveis ou expressões

forem iguais. (Ele é usado em vez de = de modo à para não ser confundido com o operador de atribuição ‘=’).

script 1 (void) { if (thingcount (0, 1) == 0) print (s:"All those nasty zombies are dead") } ‘! =’ este é o operador NÃO IGUAL. É, obviamente, o oposto do operador de igualdade e

retornará TRUE (verdadeiro) se duas variáveis ou expressões não forem iguais.

script 1 (void) { if (thingcount (0, 1) != 0) print (s:"You must kill all the zombies") } ‘>’ Esse é o operador ‘maior que’. Ele retorna TRUE (verdadeiro) se a expressão do lado esquerdo

for maior que a expressão ou variável do lado direito.


- 84 -

script 1 (void) { // Spawn Archivile invisível a cada 10 segundos! // :) if (timer > 350) thing_spawnnofog (1, T_STEALTHVILE, 0); } ‘<’ Esse é o operador ‘menor que’. Ele retorna TRUE (verdadeiro), se a expressão do lado direito

for menor que a expressão ou variável do lado esquerdo.

script 1 (void) { // Deixe o jogador saber que eu to de mau humor if (timer < 350) print (s:"Eu estou de mau humor, de uma olhada"); } ‘<=’ Esse é o operador ‘maior que’, como o nome já diz ele retorna TRUE (verdadeiro), a variável

ou expressão que está do lado esquerdo se ela for maior ou igual à expressão ou variável que estiver do lado direito.

script 1 (void){ // Spawn Archivle invisivel assim que // os 10 segundos tiverem passados

if (timer >= 350)thing_spawnnofog (1, T_STEALTHVILE, 0);}

‘>=’ Esse é o operador ‘menor que’, como o nome já diz ele retorna TRUE (verdadeiro), a variável ou expressão que está do lado esquerdo for menor ou igual à expressão ou variável que estiver do lado direito.

script 1 () { // Deixe o jogador saber que algo ruim vai acontecer. if (timer < 350) print (s:"Em 10 segundos seu dia vai ser estragado"); } A indicação IF, também pode ser usada de outra maneira, como mostra esse exemplo.

script 1 (int sw) { if (sw == 1) { if (thingcount (0, 1) == 0) print (s:"You kill all the zombies"); else print (s:"The door is now open"); } } Demora algum tempo até você se familiarizar com todos os comandos, mas quando estiver

preparado para usar você vai gostar das novas oportunidades que irão surgir para você.


- 85 -

30 - Criando um Script no Doom Builder

A criação de scripts no Doom Builder é muito fácil, pois o mesmo já inclui um editor de script embutido. Primeiro encontre onde você irá fazer o seu script, para isso vá a Scripts → Edit BEHAVIOR lump... (fig. 46).

Fig. 46 – Criando scripts

Agora na parte do ACS tenha certeza de digitar #include "zcommon.acs" com mostra a foto, se

seu ACS não tiver esse comando ele não vai funcionar (fig.47).


- 86 -

Fig. 47 – Caixa de criação de scripts

Pressione ‘Enter’ algumas vezes (umas 3 vezes) e digite ‘script 1 ( void )’, isso significa que o

numero do script é 1, e que não será ativado antes do mapa iniciar ‘(void)’. Veja a figura 48.

Fig. 48 – Escrevendo o script


- 87 -

Dê um ‘Enter’ e escreva um { ‘abre chaves’. Esse { é que vai começar o script, ao final lembre-se de fecha-lo, é como uma equação matemática. Agora de um ‘Enter’ e digite um evento de ACS, que nesse caso é o sector_setcolor (setor_ajustarcor).

Você verá que ao colocar esse evento e abrir uma (o Doom Builder virá com uma dica para você

começar com o rótulo (tag), depois com, r (red - vermelho), g (green- verde) e b (blue - azul), isso significa que você deverá definir o rótulo do setor, a cor vermelha, a verde e a azul. Essa definição é feita em números, assim quanto maior o número maior será a cor, a um limite para os rótulos e outras coisas, esse limite é o numero 255.

Agora vamos terminar o script preenchendo o resto do evento, nesse caso você vai ler (tag, red,

green, blue) depois de terminado o evento coloque um (;) ou o script não será compilado junto com o arquivo WAD. Veja a figura 49.

Fig. 49 – Finalizando o script

Se você quiser que esse seja o seu único script, basta simplesmente fechar com um }, caso não

queira apenas coloque outro evento. Que no nosso caso é o ‘print’ (fig. 50).


- 88 -

Fig. 50 – Entendeu?

Uma dica quando quiser fazer um ‘print’ lembre-se de sempre colocar (") ou a frase não será

mostrada. Terminado o script ele devera ficar assim.

Fig. 51 – Script finalizado


- 89 -

No mapa você deverá rotular a linha com o numero 80 (no ZDoom - Doom in Hexen Format) e colocar nesse caso o número 1 e veja como ele será ativado (fig. 52).

Fig. 52 – Rotule a linha desejada

Fig. 53 – Finalizando o script


- 90 -

Agora que entendeu as ativações coloque no primeiro parâmetro do script que será executado, que nesse caso é o 1. Sempre cheque o ‘Activation’ do script, e qual será ativado!!!!

Entre no seu mapa e veja se o script funciona corretamente. Lembre-se de checar o setor que foi rotulado com o script. Quando colocar ‘Reapeteble Action’ o script será executado infinitamente, nesse caso ele será executado toda vez que o jogador passar em cima da linha.

Fig. 54 – Resultado final


- 91 -

31 - Lista de Comandos ACS (ZDoom)

Segue abaixo uma lista ‘básica’ com comandos disponíveis para serem utilizados na criação de scripts usando ACS. PolyObjects 1:Polyobj_StartLine * 2:Polyobj_RotateLeft 3:Polyobj_RotateRight 4:Polyobj_Move 5:Polyobj_ExplicitLine * 6:Polyobj_MoveTimes8 7:Polyobj_DoorSwing 8:Polyobj_DoorSlide 90:Polyobj_OR_RotateLeft 91:Polyobj_OR_RotateRight 92:Polyobj_OR_Move 93:Polyobj_OR_MoveTimes8 Doors 10:Door_Close 11:Door_Open 12:Door_Raise 13:Door_LockedRaise 14:Door_Animated 249:Door_CloseWaitOpen Ceilings 38:Ceiling_Waggle 40:Ceiling_LowerByValue 41:Ceiling_RaiseByValue 42:Ceiling_CrushAndRaise 43:Ceiling_LowerAndCrush 44:Ceiling_CrushStop 45:Ceiling_CrushRaiseAndStay 69:Ceiling_MoveToValueTimes8 192:Ceiling_LowerToHighestFloor 193:Ceiling_LowerInstant 194:Ceiling_RaiseInstant 195:Ceiling_CrushRaiseAndStayA 196:Ceiling_CrushAndRaiseA 197:Ceiling_CrushAndRaiseSilentA 198:Ceiling_RaiseByValueTimes8 199:Ceiling_LowerByValueTimes8 252:Ceiling_RaiseToNearest 253:Ceiling_LowerToLowest 254:Ceiling_LowerToFloor 255:Ceiling_CrushRaiseAndStaySilA


- 92 -

Floors 20:Floor_LowerByValue 21:Floor_LowerToLowest 22:Floor_LowerToNearest 23:Floor_RaiseByValue 24:Floor_RaiseToHighest 25:Floor_RaiseToNearest 28:Floor_RaiseAndCrush 35:Floor_RaiseByValueTimes8 36:Floor_LowerByValueTimes8 46:Floor_CrushStop 66:Floor_LowerInstant 67:Floor_RaiseInstant 68:Floor_MoveToValueTimes8 138:Floor_Waggle 238:Floor_RaiseToLowestCeiling 239:Floor_RaiseByValueTxTy 240:Floor_RaiseByTexture 241:Floor_LowerToLowestTxTy 242:Floor_LowerToHighest 250:Floor_Donut 235:Floor_TransferTrigger 236:Floor_TransferNumeric Floors and Ceilings 29:Pillar_Build 30:Pillar_Open 94:Pillar_BuildAndCrush 95:FloorAndCeiling_LowerByValue 96:FloorAndCeiling_RaiseByValue 251:FloorAndCeiling_LowerRaise 245:Elevator_RaiseToNearest 246:Elevator_MoveToFloor 247:Elevator_LowerToNearest Stairs 26:Stairs_BuildDown 27:Stairs_BuildUp 31:Stairs_BuildDownSync 32:Stairs_BuildUpSync 217:Stairs_BuildUpDoom Platforms/Lifts 60:Plat_PerpetualRaise 61:Plat_Stop 62:Plat_DownWaitUpStay 63:Plat_DownByValue 64:Plat_UpWaitDownStay 65:Plat_UpByValue 172:Plat_UpNearestWaitDownStay 206:Plat_DownWaitUpStayLip 207:Plat_PerpetualRaiseLip 228:Plat_RaiseAndStayTx0


- 93 -

230:Plat_UpByValueStayTx 231:Plat_ToggleCeiling Teleporters 39:Teleport_ZombieChanger 70:Teleport 71:Teleport_NoFog 76:TeleportOther 77:TeleportGroup 78:TeleportInSector 215:Teleport_Line Exits 243:Exit_Normal 244:Exit_Secret 74:Teleport_NewMap 75:Teleport_EndGame Things 72:ThrustThing 128:ThrustThingZ 73:DamageThing 248:HealThing 130:Thing_Activate 131:Thing_Deactivate 132:Thing_Remove 133:Thing_Destroy 134:Thing_Projectile 135:Thing_Spawn 137:Thing_SpawnNoFog 139:Thing_SpawnFacing 136:Thing_ProjectileGravity 175:Thing_ProjectileIntercept 178:Thing_ProjectileAimed 119:Thing_Damage 125:Thing_Move 127:Thing_SetSpecial 176:Thing_ChangeTID 177:Thing_Hate 180:Thing_SetTranslation 229:Thing_SetGoal 17:Thing_Raise ACS 80:ACS_Execute 226:ACS_ExecuteAlways 81:ACS_Suspend 82:ACS_Terminate 83:ACS_LockedExecute 84:ACS_ExecuteWithResult 85:ACS_LockedExecuteDoor


- 94 -

Lines 121:Line_SetIdentification * 208:TranslucentLine Scrollers 100:Scroll_Texture_Left * 101:Scroll_Texture_Right * 102:Scroll_Texture_Up * 103:Scroll_Texture_Down * 221:Scroll_Texture_Both 222:Scroll_Texture_Model * 225:Scroll_Texture_Offsets * 223:Scroll_Floor 224:Scroll_Ceiling Lighting 109:Light_ForceLightning 110:Light_RaiseByValue 111:Light_LowerByValue 112:Light_ChangeToValue 113:Light_Fade 114:Light_Glow 115:Light_Flicker 116:Light_Strobe 117:Light_Stop 232:Light_StrobeDoom 233:Light_MinNeighbor 234:Light_MaxNeighbor Sectors 140:Sector_ChangeSound 185:Sector_SetRotation 186:Sector_SetCeilingPanning 187:Sector_SetFloorPanning 188:Sector_SetCeilingScale 189:Sector_SetFloorScale 190:Static_Init * 212:Sector_SetColor 213:Sector_SetFade 214:Sector_SetDamage 216:Sector_SetGravity 218:Sector_SetWind * 219:Sector_SetFriction 220:Sector_SetCurrent * BOOM generalized line types 200:Generic_Floor 201:Generic_Ceiling 202:Generic_Door 203:Generic_Lift 204:Generic_Stairs 205:Generic_Crusher


- 95 -

Renderer 9:Line_Horizon * 182:Line_Mirror * 183:Line_AlignFloor 184:Line_AlignCeiling 209:Transfer_Heights * 210:Transfer_FloorLight * 211:Transfer_CeilingLight * 16:Transfer_WallLight * 50:ExtraFloor_LightOnly * Slopes 181:Plane_Align * Other 15:Autosave 18:StartConversation 33:ForceField 34:ClearForceField 49:GlassBreak 120:Radius_Quake 129:UsePuzzleItem 173:NoiseAlert 174:SendToCommunicator 179:ChangeSkill 191:SetPlayerProperty 227:PointPush_SetForce * 237:ChangeCamera


- 96 -

32 - PolyObjects

O uso do BSP para pré-calcular e renderizar a geometria vertical dos mapas causa alguns inconvenientes, é impossível mover uma estrutura entre os eixos X e Y no Vanilla Doom (DOOM original). A engine ZDoom corrige esse problema fornecendo ‘PolyObjects’. Um polyobject consiste em um grupo das linhas simples conectadas contidas dentro de um único sub-setor.

Fazer um polyobject é razoavelmente simples, embora possa parecer difícil no início (quando eu

comecei a criar esses setores, achei que nunca iria conseguir), uma vez que você começar a pegar a pratica, perceberá que é extremamente simples e sem nenhum mistério. Como esse não é um processo fácil pra quem está começando, eu fornecerei algumas imagens. O exemplo a seguir foi feito no WadAuthor.

32.1 - Porta Dupla

Primeiramente nós precisamos de um mapa real. Eu farei um polyobject de porta deslizante (talvez o tipo mais fácil), sendo assim nós precisaremos de duas salas com alturas de teto de 192 e um

corredor médio (que é onde os polys aparecerão) com um teto de 128.

Todos os pisos estão na altura 0 (zero).

Em seguida você deverá construir os polyobjects. Estes podem ser construídos em qualquer lugar no

mapa, mas para simplificar é melhor colocá-los perto de onde aparecerão. Você pode colocá-los

em um setor ‘dummy’ (uma espécie de setor falso...) se você quiser, mas provavelmente é mais

eficiente colocá-los à direita do setor no qual aparecerão dentro (especialmente se você usa o Doom Builder que não colocará polys no ponto

direito para você no modo 3D). Para simplificar irei colocá-los em um setor ‘dummy’. Note que os

polyobjects são colunas ‘sólidas’.

As linhas marcadas em amarelo devem ser ‘Polyobj_StartLine’ composto por três argumentos,

o número do polyobject, o polyobject espelhado e o som que faz ao mover-se

(definido em SNDSEQ). Para o poly superior você deve usar o polyobject número 0, e para o fundo

você deve usar o número 1 (embora algum número entre 0 – 255 funcione).

Como estes polys espelharão um ao outro (suas ações serão as mesmas, somente no reverso, o


- 97 -

poly 1 abrirá à direita e poly 0 abrirá a esquerda no exemplo), você deve colocar o número do poly

oposto no segundo campo. O som não é importante para nós agora, sendo assim, ajuste-o

para 0.

Agora você tem que colocar as âncoras e pontos de inicio do polyobject. Estes determinarão onde

os polyobjects realmente serão colocados no mapa. Coloque primeiramente as escoras, que têm

DoomEdNum 9300. Estes devem ser colocados dentro dos polyobjects porque você os tem drawn no mapa (ou perto da borda), como na imagem. A

única coisa importante sobre as escoras é seu ângulo, que deve corresponder ao número do

polyobj. Assim a escora no alto tem o ângulo 0 e a escora sob ela tem um ângulo de 1.

Em seguida nós colocamos os pontos de início. Estes são colocados de uma maneira similar às escoras; em um lugar onde você queira que o polyobject apareça no jogo relativo à escora. Assim neste caso nós colocamos a escora no

centro do poly, assim que nós queremos o ponto de início colocado no centro de onde nós queremos que o poly apareça, como mostrado na imagem. Os pontos de início têm o DoomEdNum 9301 (ou

9302 se você quiser o polyobject esmague o jogador).

Agora vem a parte complicada e também a parte mais importante. Necessitamos que os polyobjects estejam dentro de seu próprio subsector. Se você não souber o que um subsector é, não é realmente importante, mas a melhor coisa a fazer é ter cada polyobject dentro de seu próprio setor ou colocar uma linha entre os dois (neste caso). O subsector que o polyobject reside dentro deve também ser

convexo. Para um subsector (ou apenas um setor) ser convexo todas as linhas que fazem acima sua

forma deve ser uma sorte do círculo ou do quadrado da forma. Eu acredito que uma definição mais matemática (mas não muita) é que todos os pontos ao longo da parte externa da forma devem

poder conectar com algum outro ponto (não na mesma linha) sem se cruzar através de todas as outras linhas. Os polyobjects do sustento em um setor e em um você retangulares serão apenas finos though. Anote as mudanças que eu fiz ao

mapa no screenshot. As áreas do ramo são onde os polys irã0 quando deslizam, impedindo que desloquem na área vaga e as mantenham do

sangramento (que é o mais indesejável).


- 98 -

Finalmente, você quer provavelmente os polybjects abrir realmente. Esta é elasticidade é

completamente simples, justa os lados largos dos polyobjects, o Polyobj_DoorSlide especial, com os argumentos 0, 32, 128, 64, 105 que são o número do polyobject, velocidade do movimento, ângulo (definido no ZDoom), distância do movimento e

atraso antes que os polys se desloquem para trás as sua posição original (no tics, 105 são 3

segundos). Você não precisa se preocupar com o polyobject 1 neste caso, porque ele espelhará o

polyobject 0.

Aquele na imagem é ele, feito por você!


- 99 -

33 - LUMPS Aqui estão todos os lumps, compatíveis com o ZDoom (isso inclui GZDoom e variantes) que você

pode colocar num WAD além de usá-los para customizar vários aspectos do modo de jogo.

33.1 - Lumps Textuais Esses tipos de lumps são feitos por textos em editores de wad, tais como XWE, DeepSea e

Wintex.

ANIMDEFS - Usado para definir animações de texturas; DECALDEFS - Usado para definir animações de Decals; DECORATE - Usado para criar novos objetos (things), como armas, monstros, etc... divididos em "classes"; DEHACKED - Modifica todos os objetos (things) de DOOM. Usado junto com DEHSUPP (Considerado meio obsoleto atualmente); FONTSDEF - Usado para definir novas fontes; HIRESTEX - Usado para definir Texturas de Alta Resolução (Hi-Res Textures - HRT); KEYCONF - Usado para editar, criar, remover opções do Options Menu entre outras coisas; LOADACS - Usado para carregar automaticamente objetos de ACS (inclusive em mapas do DOOM); LOCKDEFS - Usado para customizar chaves e suas trancas; MAPINFO - Usado para definir vários aspectos do mapa como: nome, música, céu, etc...; S_SKIN - Usado para definir a propriedade de uma pele (Skin) customizada (Player Sprite); SCRIPTS - Usado para conter todos os códigos de ACS em um mapa (compilado pelo Doom Builder); SNDINFO - Usado para criar e definir todas as propriedades de som; SNDSEQ - Usado para criar novas seqüências de sons em movimentos de portas; TERRAIN - Usado para mudar vários aspectos de propriedades das texturas de chão (floor); TEXTCOLOR - Usado para definir novas cores para os textos.

33.2 - Lumps Compilados Esses LUMPS precisam ser compilados por outras ferramentas do ZDoom, e oferecem um

controle maior sobre alguns dos aspectos do jogo.

ANIMATED - Usado para criar animações no estilo Boom; BEHAVIOR - Usado para compilar ACS Script; DEHSUPP - Compilador para definir, modificar, e mudar paths de DEHACKED; SWITCHES - Usado para mudar texturas no estilo Boom; Libraries - Usado para habilitar varias funções de ACS em qualquer mapa; Strife dialogue scripts - Usado para modificar e criar scripts de conversas como no jogo Strife; TITLEMAP - Usado para criar um mapa especial (extremamente difícil de ser feito), que substitui a imagem da tela de entrada para uma espécie de "filme".


- 100 -

34 – Operadores ( Apêndice )

ATENÇÃO: OS TEXTOS QUE APARECEM A PARTIR DESSA PÁGINA CONTÊM INÚMEROS ERROS E INCORREÇÕES QUE SERÃO CORRIGIDOS EM VERSÕES FUTURAS DESTE GUIA!

ESSAS INFORMAÇÕES FORAM AQUI COLOCADAS COMO UM AUXÍLIO AOS MAPPERS,

PORÉM A SUA UTILIZAÇÃO DEVE SER FEITA COM MUITO CUIDADO. NÃO ME RESPONSABILIZO POR QUALQUER TIPO DE PROBLEMA QUE VOCÊ POSSA TER AO UTILIZAR AS INFORMAÇÕES AQUI DESCRITAS.

Estes são todos os operadores e keywords suportados por ACS bem como uma descrição básica

de cada um. Você poderá usar essa lista para uma consulta futura durante a manipulação de scripts. Se você tiver algum conhecimento em C/C++, você poderá escolher apropriadamente e de forma rápida qual função usar em seus mapas.

'=' (binary) Operador de Atribuição Este operador examina o valor da direita e armazena-o na variável na esquerda. A menos que

uma expressão esteja sendo passada diretamente a uma função ou a um script então deve ter alguma sorte de um operador de atribuição associado a ela. Uso básico:

'+' (binary) Operador de Adição Adiciona dois números básicos: Nota: Se você quiser adicionar para trás um número em uma variável use o operador '+='.

'-' (unary) Operador de mudança do sinal (não sei o nome real, sendo assim que eu lhe dei um!) Quando usado na frente de um número muda o sinal dessa variável. Uso básico:

'-' (binary) Operador de Subtração Isto subtrai dois inteiros de se. Uso básico: Nota: Se você quiser subtrair para trás um número em uma variável use o operador '-='.

'*' (binary) Operador de Multiplicação Isto multiplica dois números. Uso básico: Nota: Se você quiser multiplicar para trás um número em uma variável use o operador '*='.


- 101 -

'/' (binary) Operador de Divisão Isto divide dois números. Tenha cuidado sobre a precisão, como o ACS não suporta operações de ponto flutuante, você somente irá obter a parcela do inteiro do resultado e a parte decimal será excluída. Também convém não se dividir por zero pois isso causará um erro. Uso básico: Nota: Se você quiser dividir para trás um número em uma variável use o operador '/='.

'%' (binary) Operador de Módulos Este estranho operador dá o restante da divisão de dois números. Para ajudá-lo a compreender, na matemática normal 10/4 é 2,5 sendo que no ACS o restante usado será apenas 2 inteiro. Uso básico: Nota: Se você quiser modificar um número para trás em uma variável use o operador '%='.

'&' (binary) Bitwise AND Operator Este operador examina os bits dos lados direitos e esquerdo, e logicamente os ANDs esquerdos e direitos junto à eles. Tabela verdade:

Como você pode ver retorna um verdadeiro se ambos forem verdadeiros. Assim se você tivesse 7 e 6 e AND juntos, você teria 6 porque: 0 1 1 1 & 0 1 1 0 = 0 1 1 0 Uso básico: Nota: Se você quiser logicamente uma indicação de inteiro, então cada bit deve ser tratado individualmente usando o operador '&&'. Se você quiser tratar logicamente um número para trás em uma variável use o operador '&='.

'|' (binary) Bitwise OR Operator Este operador trata logicamente dois números comparando-os (OR). Tabela verdade:

Como você pode ver retorna um verdadeiro se um deles for verdadeiro. Assim se você tivesse OR 7 e 6 juntos, você teria 7 porque: 0 1 1 1 | 0 1 1 1 0 = 0 1 1 1 Uso básico:

Se você quiser a logicamente OU uma indicação inteira rather então cada bocado a seguir vê '||' operador. Se você quiser a logicamente OU um número para trás em uma variável vê então '|= ' operador. ' ^ ' (binário)


- 102 -

Bitwise operador de XOR (refered às vezes como a EOR também) Isto é exclusivo-ou operador e logicamente XORs dois números junto. A tabela de verdade de XOR: | p ^ q p q | 0 0 | 0 0 1 | 1 1 0 | 1 1 1 | 0 Como você pode ver retorna um verdadeiro se ambos forem diferentes. Assim se você logicamente XOR 7 e 6 você começar 1 porque 0 1 1 1 ^ 0 1 1 0 = 0 0 0 1 uso básico: z = x ^ y; Se você quiser logicamente a XOR uma indicação inteira rather então cada bocado então seu ir ter que escrever uma função que o faça para você porque Acs não tem um operador que . Se você quiser logicamente a XOR um número para trás em uma variável então você deve ver ' ^ = ' variável. ' ~ ' (unary) Bitwise NÃO Operador. Este logicamente NOTs cada bocado no número. NÃO a tabela de verdade: | ~p p | 0 | 1 1 | 0 Como você pode ver retorna um verdadeiro se falso e um falso se verdadeiro. Assim se você logicamente NÃO 7 então você começar (realmente desde que os inteiros em ACS são 32 bocados e não 4 você começa realmente um número negativo muito grande mas você puder começar o ponto) ao becase 8 ~0 1 1 1 = 1 0 0 0 usos básicos: y = ~x; Se você quiser logicamente NÃO a uma indicação inteira rather então cada bocado a seguir vir '!' operador. Se você quiser logicamente NÃO a uma variável e então armazen-a-ar para trás nse então você necessidade fazê-la a maneira longa: x = ~x; ' < < ' (binário) Operador De Deslocamento Bitwise Esquerdo Este operador faz exame de todos os bocados na esquerda e desloca-os pelo número na direita. Assim se você tiver 7 e o deslocamento esquerdo ele 1 então você tem 14 porque 0 1 1 1 < < 1 = 1 1 1 0. Nota: esta é exatamente a mesma coisa que multibling o número na esquerda pelo poder cooresponding de 2 na esquerda, assim 4 < < 3 = 32 porque 2^3 é 8 e 8 por 4 são 32 mas em vez de multipling 4 * 8 seu mais rápido para fazer 4 < < 3. Nota 2: Se você deslocar um bocado fora de você perca-o. Desde que nós estamos tratando dos 32 inteiros do bocado um 1 < < o deslocamento 32 faremos com que o um bocado seja deslocado fora da variável e você seria deixado com o 0. Uso básico: z = x < < y; Se você quiser deslocar os bocados de um esquerdo variável e para armazená-lo para trás nse vêem então o operador do '<<='. ' > > ' (binário) Operador De Deslocamento Bitwise Direito Esta é a mesma coisa que o operador de deslocamento esquerdo mas o exato oposto a. Faz exame do número na esquerda e move seus bocados para a direita pelo número na direita. Assim 6 > > 1 = 3 porque 0 1 1 0 > > 1 = 0 0 1 1. Nota: este é exatamente o mesmo que dividindo um número o poder cooresponding de 2 mas mais rapidamente. Assim, 24 > > 3 = 3 porque 2^3 é 8 e 24/8 = 3. Nota 2: se você deslocar os bocados fora da variável então você perde o bocado. Se você fizer exame de 1 e o deslocar 1: 1 > > 1 então você tem zero porque o bocado começou deslocado fora. Uso básico: z x > > y; Se você quiser deslocar os bocados de um direito variável e para armazená-lo para trás nse vêem então o operador do '>>='. '==' (binary) Iguais Relacionais ao Operador. Isto compara duas indicações e retorna um valor verdadeiro se igual ou falso se diferente. Uso básico:

'! = ' (binary) Relacional Não iguala Ao Operador Isto compara duas indicações e retorna então um verdadeiro se não iguale e falso se . Uso básico: z = x ! = y; ' > ' (binário) Então Operador Mais grande Relacional Isto compara duas indicações e retorna então um verdadeiro se o valor na esquerda for mais grande então o valor na direita e em um falso de outra maneira, mesmo se o igual dois retornará um falso. Uso básico: z = x > y; ' > = ' (binário)


- 103 -

Mais grande então ou igual relacional ao operador Isto compara duas indicações e retorna então um verdadeiro se o valor na esquerda for mais grande então ou igual ao valor na direita e em um falso de outra maneira. Uso básico: z = x > = y; ' < ' (binário) Mais menos Então Operador Relacional Isto compara duas indicações e retorna então um verdadeiro se o valor na esquerda for menor no direito e falso de outra maneira, mesmo se o igual dois retornará um falso. Uso básico: z = x < y; ' < = ' (binário) Relacional mais menos então ou igual a Operater Isto compara duas indicações e retorna então um verdadeiro se o valor na esquerda for menor ou igual ao valor na direita e em um falso de outra maneira. Uso básico: z = x < = y; '&&' (binary) Operador Lógico AND Este operador compara duas indicações e retorna então um verdadeiro ou um falso baseado no E na tabela de verdade: | p & q p q | 0 0 | 0 0 1 | 0 1 0 | 0 1 1 | 1 Entretanto, desde que verdadeiro é todo o nenhum zero números este retorno um verdadeiro: 4 seus do && 3 usados melhor ao ligar junto os operadores relacionais. Uso básico: && y de z = de x; Ligando junto os operadores relacionais: && a do == y de z = de x ! = b '||' (binário) Lógico OU Operador Este operador compara duas indicações e retorna então um verdadeiro ou um falso baseado no OU na tabela de verdade: | p & q p q | 0 0 | 0 0 1 | 1 1 0 | 1 1 1 | 1 Entretanto, desde que todo o número non-zero é verdadeiro isto retornará uma indicação verdadeira 4 || 0. Seu usado melhor ao ligar junto os operadores relacionais. Uso básico: z = x || y; Ligando junto os operadores relacionais: == y de z = de x || a ! = b '!' (unary) NÃO Operador Lógico Este operador NOTs uma indicação. Se seu verdadeiro (algum número non-zero) então ele retornar um falso (ou zero) e se seu falso ele retornar um verdadeiro (geralmente um 1). Seu usado melhor com amd dos operadores relacionais outros operadores lógicos. Uso básico: y = !x Usado em operadores lógicos: && do && de z = de!(x y) (x || Y) ' + = ' (binário) Operador De Atribuição Da Adição Este operador faz exame do valor na direita, adiciona-o ao valor da variável na esquerda, e armazena-o então para trás na variável. É o equivalente de n = uso básico de n + de y.: x + = y; ' - = ' (binário) Operador De Atribuição Da Subtração Este operador faz exame do valor na direita, subtrai-o do valor da variável na esquerda, e armazena o então para trás na variável. É o equivalente de n = n - uso básico do y.: x - = y; ' * = ' (binário) Operador De Atribuição Da Multiplicação Este operador faz exame do valor na direita, multiplica-o ao valor da variável na esquerda, e armazena-o então para trás na variável. É o equivalente de n = n * uso básico do y.: x * = y; '/= ' (binário) Operador De Atribuição Da Divisão Este operador faz exame do valor na direita, divide o valor da variável por ela, e armazena-o então para trás na variável. É o equivalente de n = n /y. Nota: todos os limitaions do operador da divisão carregam o excesso assim que veja '/' operador se você não for certo. Uso básico: x/= y; '%=' (binary)


- 104 -

Operador de Atribuição de Módulos Este operador faz exame do valor na direita, divide o valor do varialbe por ele, retorna o restante e armazena-o então para trás na variável. É o equivalente de n = % de n y. Nota: se você for unsure em como este operatore trabalha então veja o operador modulous:, ' % ', para mais info. Uso básico: x % = y; '&=' (binary) Bitwise E Operador De Atribuição Este operador faz exame do valor na direita, logicamente ANDs todos os bocados dela ao valor da variável na esquerda, e armazena-o então para trás na variável. É o equivalente de n = n & y. Nota: Veja bitwise E, ' & ', o operador para mais info em como este operador trabalha. Uso básico: x & = y; '|=' (binary) Bitwise OU Operador De Atribuição Este operador faz exame do valor na direita, logicamente ORs todos os bocados dela ao valor da variável na esquerda, e armazena-o então para trás na variável. É o equivalente de n = n | y. Nota: Veja bitwise OU, '|', operador para mais info em como este operador trabalha. Uso básico: x |= y; '^=' (binary) Bitwise Operador de Atribuição XOR Este operador examina o valor na direita, logicamente XORs todos os bocados dela ao valor da variável na esquerda, e armazena-o então para trás na variável. É o equivalente de n = n ^ y. Nota: Veja bitwise o XOR, ' ^ ', operador para mais info em como este operador trabalha. Uso básico:

'<<=' (binary) Operador de Atribuição do Deslocamento Bitwise Esquerdo Este operador examina o valor na direita, desloca os bits do valor da variável na esquerda para um número, e armazena-o de volta na variável. É o equivalente de n = n < < y. Nota: Veja a seção Deslocamento Bitwise Esquerdo, '<<', para mais informações sobre como este operador trabalha. Uso básico:

'>>=' (binary) Operador de Atribuição Bitwise Direito do Deslocamento Este operador examina o valor na direita, desloca os bits do valor da variável na direita para um número, e armazena-o então de volta na variável. É o equivalente de n = n > > y. Nota: Veja a seção Deslocamento Bitwise Direito, '>>', para mais informações sobre como este operador trabalha. Uso básico:


- 105 -

35 - Links Interessantes

• BrDOOM Website Site dedicado aos doomers (fãs do jogo) http://www.brdoom.com/

• BrDOOM Fórum

Fórum dedicado aos fãs http://www.brdoom.com/_forum/

• [DBR] Clan Primeiro Clã brasileiro de jogadores de DOOM http://www.dbr.brdoom.com

• [DRB] DOOM Resources Brasil

Site oficial de Drak[X] - é o meu site ;-) http://www.brdoom.com/drb

• Guia do Levelord

Aprenda a criar e modificar mapas para o DOOM http://www.brdoom.com/levelord/

• DOOM: Apocalipse Site oficial do projeto http://www.brdoom.com/apocalipse

• DOOM: Apocalipse Fórum Fórum do BrDOOM sobre o projeto DOOM: Apocalipse http://www.brdoom.com/_forum/viewforum.php?f=34

• ZDoom – Source Port Site oficial do ZDoom http://www.zdoom.org

• ZDaemon – Source Port Site oficial do ZDaemon http://www.zdaemon.org

• Doom Legacy – Source Port Site oficial do Doom Legacy http://legacy.newdoom.net

• Skull Tag – Source Port Site oficial do Skull Tag http://skulltag.com

• Odamex – Source Port Site oficial do Odamex Port http://odamex.net

• DOOM 64: Absolution (TC) Port do DOOM 64 do Nintendo 64 para computador (doom2.wad ). http://www.doom2.net/~doomdepot/abs-download.html


- 106 -

• Lost Episodes Of Doom http://www.doomwadstation.com/le.html

• Super Mario DOOM http://files.filefront.com/sdmzip/;7048226;/fileinfo.html

• DOOM SNES

Essa é a ROM do jogo DOOM para o Super Nintendo (requer ZSnes ou Snes9x). http://www.emulabr.com/rom.php?rom=1243

• DOOM PSX

Jogue DOOM no PSOne ou PSTwo

Parte 1: http://rapidshare.com/files/17169521/Doom_v1.1_NTSC.part1.rar Parte 2: http://rapidshare.com/files/17171646/Doom_v1.1_NTSC.part2.rar

• Final DOOM Jogue Final DOOM no PSOne ou PSTwo

Parte 1: http://rapidshare.com/files/3120547/Final_Doom.part1.rar.html Parte 2: http://rapidshare.com/files/3118665/Final_Doom.part2.rar.html


- 107 -

36 - Bibliografia

Este guia inclui textos que eu mesmo escrevi baseados em minha experiência com edição de mapas para o DOOM, também contém textos retirados do DOOM Wiki, ZDoom Wiki, livros sobre DOOM e do BrDoom Fórum (textos escritos por jogadores que são fãs e mappers de Doom), e adaptados para facilitar a compreensão do leitor.

A lista de sites e os nomes dos escritores originais dos textos estão listados abaixo. (lista incompleta!)

• Sites Brasileiros BrDoom Fórum http://www.brdoom.com/_forum

• Sites Estrangeiros DOOM Wiki ZDoom Wiki Doom Legacy Wiki

• Mappers Brasileiros Drak[X] – Laete Meireles LogamMTM

• Mappers Estrangeiros HolfDoom CrackDoom YBabel

Agradeço a todos os membros da BrDoom pelo apoio dado durante o processo de construção deste guia. Também quero expressar os meus agradecimentos aos mappers

‘estrangeiros’ que apesar de não falarem português também me ofereceram apoio para a realização deste grande projeto.

Laete Meireles ‘Drak[X]’

Documents

Levelord - Doom Bible