[Tutorial]Iniciando no Dream Maker(Byond)

I.Abrindo o programa

Vá para o menu de seu programa e abra o Dream Maker.Sob o menu “File”, escolha “New Environment”, clique no lado direito da caixa de entrada, e digite “Mundo Teste”. Clique em OK. Quando a próxima janela aparecer, você vai ver que quer criar um novo arquivo de código(Code File) com o mesmo nome. Clique OK.

Todo jogo deve ter um environment(ambiente). Para um jogo você deve ter muitos Arquivo de códigos, ou muitos arquivos de sons, e assim por diante, mas todos eles fazem parte do mesmo environment. Em nosso caso, é o environment Mundo Teste. Um arquivo de código(Code File ou .DM file) é onde você entra com a programação. No painel à esquerda, você pode ver pequenos itens representando o environment e o arquivo de código Mundo Teste.

Uma diretório para esse environment foi criado em seu diretório BYOND\bin\, desde que não especificamos outro caminho. Você pode ir ver se quiser. Normalmente o BYOND se encontra instalado em C:\Arquivos de Programas\BYOND (se você não sabe onde esta o byond em seu computador, esta provavelmente lá). Na pasta bin, você vai ver a pasta Testworld. Nesta, você vê o MundoTeste.dme(o environment) e MundoTeste.dm (o arquivo de código).

II. Primeira coisa a fazer (Comentários)

No topo do MundoTeste.dm, nosso arquivo de código, ponha essa linha:

//Este é um mundo Teste criado por em .

...Substitua o que esta entre <> com sua informação.

Isto é um comentário. Começa com duas barras, que faz a linha ficar da cor cinza. Você pode escrever tudo o que quiser no comentário, pois isto não afetará o código. Comentários são muito importantes; bons programadores colocam comentários em seus códigos explicando com ele funciona. Um comentário deve ser feito como se fosse explicando o código para outro programador, mesmo que você não pretende que ninguém veja seu código.

Isto pode soar um pouco bobo, mas esquecer como seu próprio código funciona é mais fácil do que parece. É muito melhor ter um bom comentário e não precisar dele do que precisar e não ter um.

III. Códigos que fazem coisas(Verbs)

Aperte ENTER algumas vezer para pular algumas linhas, e coloque esse código (acerte as linhas pressionando o botão TAB):bem no caso dos TAB's eu vou colocar aqui no fórum o sinal de +.

mob
+verb
++Falar(msg as text)
+++world << "[usr] diz:[msg]"

Nós fizemos nosso primeiro verb(verbo). Verbs são os comandos que o jogador tem acesso em um jogo. Nós começamos com “mob”, que significa para o verb funcionar, um mob precisa existir no jogo. Que pode ser você. (Se tivéssemos começado com um “turf”, então o verb precisaria de um turf para existir, e um mob também, de fato, se não tem ao menos um mob no jogo, não vai ter ninguém para usar o verb.) Mob é a abreviação de mobile(móvel) e é frequentemente usada para representar jogadores e monstros.

Embaixo de mob nós colocamos “verb”. Nós usamos um TAB antes do verb, para significar que pertence ao mob; mob é o pai. Se colocarmos o “verb” totalmente na margem esquerda, ele não ira pertencer a ninguém.

Próximo é “Falar” e algumas coisas. Nós colocamos embaixo do verb e apertamos TAB 2 vezes, indicando que Falar é um verb. O que vem depois é um pouco mais complexo; Antes de seguir devemos comentar nosso código como bons programadorezinhos.

mob
+verb
++Falar(msg as text) // o que o usr diz é passado como uma mensagem de texto
+++world << "[usr] diz:[msg]" //O mundo vê como um chat

IIIa. Argumentos são saudáveis (argumentos de Verb)

++Falar(msg as text) // o que o usr diz é passado como uma mensagem de texto


Verbs levam argumentos. Mas isso não é de grande ajuda se não sabemos o que significa um argumento e como usá-lo. Nós podemos ver que a palavra não tem muito sentido. Sobre o que exatamente estamos argumentando? (Eu prefiro argumentar sobre os Lakers e os Bulls)

Pense em um argumento como uma entrada.Com um verb, esta entrada vem do player. Você decide que nome para chamar a informação que entra. Neste caso, é “msg”, abreviação de “mensagem”. Podemos colocar qualquer nome que quisermos, mas é bom escolher nomes descritíveis e fáceis de digitar.

Então, nós não sabemos que entrada vai vir aqui, mas o que quer que seja, nós sabemos do que iremos chamar-lo. E sabemos que tipo de entrada será. Text(texto). Não um numero, não um mob, mas um Text. Que é palavras, na maior parte. Texto pode conter dígitos: “Eu tenho 23 anos” – mas isso não faz dele um numero. Msg as text(msg como texto).

IIIb. Saída!(o operador <<)

+++world << "[usr] diz:[msg]" //O mundo vê como um chat


Nós colocamos esta linha embaixo do verb, sendo a ação que o verb faz. Estes dois sinais de menor que são chamados operadores. “O operador <<”, de fato. Não me pergunte como pronunciar isso. Operadores são símbolos, geralmente colocados entre coisas, que causa algo especifico para acontecer. Neste caso, o que acontece é que o lado direito esta saindo para o lado esquerdo. Que é todo o mundo(world), no nosso caso. A mensagem esta sendo exibida para o mundo.

Faz muito mais sentido agora, não faz?

IIIc. O que é isto? (Imbedded expressions (Expressões embutidas))

O que exatamente significa “[usr]: [msg]” você deve estar curioso. Ele esta entre aspas, significando que toda a coisa é uma string (série) de texto. O que o jogador digitou em, nossa msg, é uma string de texto... Eu chamei de “text” antes, hey, é o que nosso verb disse. Msg as text. Não msg as string. O verb não mente. Mas eles significam a mesma coisa.

Quando algo em uma string de texto esta entre colchetes [ ], é chamado de imbedded expres​sion(expressão embutida). Eu não sei de onde os programadores tiram essas coisas. Eu acredito que se reúnem, bebem e ficam jogando dartos no dicionário de inglês da Oxford. Contudo, a parte embutida de “expressão embutida” faz algum sentido. Uma expressão embutida é como um nugget buried em nossa string de texto.

Quando seu código é executado essa string de texto não é passada para o mundo exatamente como você vê acima. Ou seja, tudo o que é uma expressão embutida é substituído. Você verá o que a expressão se refere. O [usr] é subtituido pelo nome do usuário. Quando uma string de texto possui [usr] é mostrada no mundo, a parte [usr] é substituída pelo nome do usuário.

Pense rápido! Se um player chamado Ichabod falasse “I'm going to whack everybody with a 30-pound petrified hunk of mutton!” O que o mundo veria?

O mundo veria

Ichabod: I'm going to whack everybody with a 30-pound petrified hunk of mutton!

Voila. Bate-papo!

IIId. Ação! (Compilando e rodando)

Vai no menu “Build” e escolha “Compile”. No painel da base você deve ver:

Loading Testworld.dme

Saving Testworld.dmb

Testworld.dmb – 0 erros, 0 warnings

Se não aparecer isso, olhe seu código para ter certeza que está correto.

Quando seu código é compilado, é traduzido em um formato que o computador (e/ou qualquer programa que você esta rodando o código) possa ler. Se não houver erros durante esse processo, seu arquivo de código .dm será salvo. Agora vai no menu “Build” de novo e escolha “Run”. O Dream Seeker vai abrir.

Quando seu mundo abrir você deve ver o verb “Falar” em um painel chamado “Commands.” Clique nele ou digite “Falar” na linha de comando (a caixa de texto rosa), depois sua mensagem. Se você usar a linha de comando não se esqueça de dar espaço entre Falar e a mensagem. E aperte ENTER. Agora volte aqui!!

IV. Este mundo é muito chato (Ícones)

Nós vamos fazer algo mais interessante. No menu “File” no Dream Maker, escolha “New…” e quando a janela aparecer, escolha “Icon File (.dmi)”. De o nome de “grama”.

Agora você esta no editor de ícones ; você pode ver uma nova tela com dois botões, uma palheta e uma câmera. Clique na palheta. O que você verá em seguida é provavelmente alto explicativo; faça uma grama bonita se você quiser, ou apenas inunde toda coisa com verde.

IVa. Fantasia, Fantasia (Icon states(Condição de ícones))

Em seguida, faça um novo “Icon file (.dmi)” e nomeie de “pessoa”. Clique na palheta e desenhe um boneco cor de rosa. Sim, você me ouviu. Se você se atrapalhar no desenho, pode apagar usando a borracha, que esta na caixa de cores, primeira linha, primeira coluna.

Quando estiver pronto, clique no botão “Back” que esta embaixo. Você vai ver uma pequena figura rosa no espaço que era branco antes. Clique na palheta de novo. Desta vez, faça um boneco azul, e volte de novo. Clique novamente na palheta e faça um boneco preto, então volte mais uma vez.

Nós acabamos de criar um ícone com várias states(condições). Continua sendo um arquivo .dmi, um ícone, mas pode ser visto de três formas diferentes. Não pense como se fosse uma pintura, pense nisso como um livro de figuras, e você pode virar para qualquer figura que você quer e então mostrar para as pessoas. Todo o “livro” junto se chama “pessoa.dmi”. Este livro não estará na lista dos bestseller do New York Times.

Clique um milímetro ou dois embaixo do boneco rosa. Vai demorar algum tempo e uma pequena janela irá abrir. Na caixa de entrada, digite “female”, todo em minúsculo, e soletrado corretamente. Agora faça o mesmo com o azul, mas digite “male”. E faça o mesmo o a figura preta, mas digite “neuter”. Nós nomeamos nossos icon states. Agora quando quisermos mostrar somente uma, basta chamar por nome.

Este pode ser o primeiro tutorial de iniciantes falando sobre icon states. Icon states é considerado um conceito difícil. Muitas pessoas que programam há meses continuam sem entender-los.

IVb. Implementando gráficos(Protótipos)

Nós fizemos (um tipo de) gráficos legais, mas eles não vão saltar no jogo sozinhos. Dois cliques em Testworld.dm, nosso arquivo de código. Embaixo de “mob”, aperte TAB, para ficar exatamente em cima de “verb”, escreva isso:

+icon = ‘pessoa.dmi’ //Faça isso para que todos os mobs sejam criados com o ícone pessoa

Depois de todo o código mob coloque:

turf
+grama //define um protótipo“grama”, que é um tipo de turf
++icon = ‘grama.dmi’ //e um ícone chamado ‘grama.dmi’

Um protótipo é como um blueprint(planta). Uma blueprint de uma casa não é uma casa por si mesma... mas você usa para construir uma casa. Esse nosso código não cria grama no jogo. É somente o blueprint. Nós podemos fazer quanta grama quisermos usando a mesma blueprint. Finalmente

world //Colocamos uma das características do mundo:
+turf = /turf/grama //A turf default é a turf grama


Nós vamos olhar o que fizemos até agora. Vá no menu “Build” e compile de novo, que alem de traduzir o código vai salvar nossos arquivos. Sempre se lembre de salvar regularmente, e fazer backups.

Eu tive que reescrever metade desse tutorial porque eu esqueci de salvar, e meu computador obedientemente travou. Faça como eu falo, não como faço.

IVc. Cartografia(Fazendo um mapa)

Hora de fazer um mapa para nosso mundo. No menu “File”, escolha “New...” e faça um novo “Map File (.dmp)” chamado “Mundo Teste”. O mesmo nome que nosso environment. Lembra do environment?

Sim?

Vai abrir uma janela perguntando o tamanho do mapa; somente clique em OK. Quando o editor de mapas aparecer, você vai ver tudo verde. Eu espero. Isto é porque nós colocamos a turf grama como default, e colocamos o ícone grama.dmi, o mapa vai automaticamente aparecer com essa turf. Isto nos livra do trabalho de colocar a grama por nós mesmos.

Agora você tem um mundo com 100 quadrados. Compile de novo, e rode. Você vai ver a grama... mas não verá nenhum boneco.

Você ENTROU no jogo. E você seria um belo e pequenino boneco na grama... exceto porque nós demos ao boneco vários icon states, e o programa não sabe qual deve mostrar, então ele desiste e você não se torna um boneco. Desculpa.

V. Mais abreviações (Procs)

Proc é uma abreviatura de procedimento. Estes são pequenos bits de código que fazem toda a ação acontecer no jogo; você pode reconhecer um proc por causa dos parênteses que vem depois do nome. Verbs são um tipo de proc, então você já fez um sem nem ao menos saber disto. A linguagem DM já vem com alguns Built-in procs(procs internas) para deixar mais fácil para programar. Nós também podemos modificar essas procs para fazer o que agente quiser.

Va. Login() e Logout() (Procs internas)

Quando um programa é ordenado a fazer um procedimento, o procedimento em questão é chamado. Login() é chamado automaticamente quando um player entra no jogo, e Logout() quando o player sai do jogo. Quando queremos modificar essas duas, nós colocamos o código no prototype para mobs. Aqui é código para mobs agora:

mob
+icon = 'pessoa.dmi'
+Login()
++icon_state = gender
++..()
+verb
++Falar(msg as text)
+++world << "[usr] diz:[msg]"


O comando ..() diz para ir chamar a atual proc interna Login(). Isto é muito, muito importante. A proc interna Login() é o que põe você no mapa. É chamada de procs pais.(Você nunca perguntou, “Mãe, como eu fui entregue?”)

O Login que NÓS codificamos é uma criança, e não sabe tudo o que seus pais sabem. “Então dizemos para ele perguntar para o seus pais o que fazer, com essa linha “..()”

Agora, compile e rode! Você será um boneco que pode dizer coisas E mover por pelo mapa através das teclas direcionais. Agora você tem um Bate-papo gráfico. A vida não é bela? Você deve agora salvar tudo ou compilar de novo.

VI. Mas eu não quero uma sala de Bate-papo!! (declarando variáveis)

As características de mobs e turfs que utilizamos como (icon e gender) são chamadas de variáveis internas. Uma variável é um lugar onde um tidbit de dados é guardado. É chamado de variável porque nós podemos modificar-la quando desejarmos, então a informação contida pode variar. A lista de referencias do DM já explica um pouco mais sobre variáveis internas.

Mas hoje nós queremos fazer uma variável guardar uma data sobre a vida do jogador, ou HP, não existem variáveis internas para isso, então temos que criar nossa própria variável. Coloque essas linhas:

+var
++HP = 30 //Declara uma nova variável chamada HP, com o valor 30

...dentro de mob, abaixo da linha “icon”.

Nós declaramos uma variável e assimilamos um valor para ela. Quando nós declaramos uma variável, nós deixamos o programa saber que nós fizemos uma nova que não é uma variável interna. Nós fazemos isso colocando abaixo de “var”. Quando assimilamos um valor, nós dizemos que dados nós desejamos que a variável carregue. Neste caso é o numero 30.

VIa. Matando coisas... (mais procs internas)

Se nós quisermos sair por ai atacando coisas, precisamos de um verb de ataque. Coloque isso abaixo de “verb” e antes de “Falar”:

+Atacar(mob/M as mob in oview(1)) //Atacar um mob a distancia de um tile
++usr<< “Você atacou [M]!” //manda essa mensagem para o usr
++oview()<<”[usr] atacou [M]!” //manda essa mensagem para os outros
++var/dano = rand(1,10) //Assimila um valor aleatório para variável
++world << “[dano] dano!” // diz ao mundo o dano sofrido
++M.HP -= dano //Tira o dano no HP de M


De uma olhada nas comentários e veja se você consegue descobrir algo por você mesmo. Não precisa ficar preocupado, Vou explicar tudo detalhadamente.


+Atacar(mob/M as mob in oview(1)) //Atacar um mob a distancia de um tile


Isto é muito similiar ao verb Falar. O player que esta fazendo o ataque tem que pegar um mob perto dele, que vai ser passado como M. De novo, especificamos que deve ser um mob.

Próximo, oview(1) é a distancia que ele pode atacar coisas. A parte “view(vista)” é auto-explicatoria; o “o” significa outside(fora) ou other(outro), ou possivelmente, Okefenonkee, isso faz com que o usr não mire em si mesmo. O usr só estará capaz de atingir os alvos com um tile de distancia dele.

++usr<< “Você atacou [M]!” //manda essa mensagem para o usr

Na linha de cima, nós fizemos uma mensagem de ataque para o usr.

++oview()<<”[usr] atacou [M]!” //manda essa mensagem para os outros

Nós não colocamos nenhum numero nos parênteses desse oview(), então a mensagem será enviada para todos que o usuário pode ver... exceto, é claro, o próprio usr.

++var/dano = rand(1,10) //Assimila um valor aleatório para variável

Nós declaramos uma nova variável acima, chamada dano.

Nós assimilamos um valor para nossa variável, mas não como fizemos com o HP. Em vez de assimilar um numero, nós chamamos a proc interna, rand(). Os argumentos que passamos dentro de rand() determinam a variação de números que podemos pegar. Neste caso, um inteiro entre 1 e 10 somente.

Toda vez que essa linha é alcançada no seu programa, rand() vai ser chamada, e ela passara o numero que será pego. Isto se chama retorno. Retornando o numero que requisitamos. O numero retornado será assimilado ao valor de dano.

++world << “[dano] dano!” // diz ao mundo o dano sofrido

Aqui mostramos o dano, como uma expressão embutida. Do mesmo jeito que já fizemos com usr, msg e M.

++M.HP -= dano //Tira o dano no HP de M

Aqui é onde realmente o dano é feito. M.HP significa “O HP de M”. O operador -= (o sinal de menos e de igual) significa que a coisa contida à esquerda é igual ela mesma MENOS o valor da outra coisa da direita. Então, o HP de M é igual como antes, menos o dano.

VIb. Cinco notas.

1.Eu coloquei comentários em praticamente todas as linhas do programa, mas não precisa fazer isso normalmente. Coloque comentários suficientes para que outro programador possa entender, o básico não será necessário comentar.

2.Note como colocamos o nome de variáveis relacionadas com seus propósitos. É altamente recomendado isso. Faça nomes de variáveis descritíveis e que sejam pequenas o suficientes para serem fáceis de escrever repetidas vezes.

3.Quando declaramos uma variável em uma proc, ela existe somente naquela proc. Uma vez que a proc retorna, a variável se perde. Se você quiser que outra proc use essa variável você deve passá-la. Você aprenderá mais disso quando você continuar com seus estudos com o BYOND.

4.Se você ver, nós temos uma linha dizendo “var/HP = 30” e uma linha dizendo “var/dano = rand(1,10)”. Se agente voltar e colocar HP = rand(1,10), invez de 30, você terá um erro.

Testworld.dm:6:error:=expected a constant expression

Isto é porque se algo não é conhecido quando você compila... como não sabemos que numero será... você deverá colocar dentro de um proc.

5.Você deve ter notado uma diferença entre Login(), uma proc interna, e rand(),também uma proc interna. Uma é maiúscula e a outra não. Isto é para indicar que Login() é a proc de um mob, enquanto rand é somente uma proc regular.

VIc. Procodilo Dundee (Declaração de procs; declaração de if; src)

Então agora podemos atacar mobs. Mas se realmente queremos mata-los, nós temos que ver se o HP deles chegam à 0 ou menos. A melhor hora de fazer isso é depois que o mob leva o dano. Coloque outra linha no fim do verb Atacar.

++M.ChecarMorte() //Checa se o mob morreu com uma proc

Você provavelmente sabe que ChecarMorte() é uma proc. O M. em frente diz para não chamarmos simplesmente essa ChecarMorte, mas ChecarMorte() que pertence a M. Então é melhor escrever a proc ChecarMorte(). Em mob, entre Login() e var, coloque isso:

+proc
++ChecarMorte() //Checar ataque mortal
+++if(HP<=0) //Se o HP for menor ou igual a zero....
++++world<<”[src] morreu!”//Mostra a mensagem de morte

Como ChecarMorte() não é uma proc interna como Login(), nós temos que declará-la digitando a “proc” primeiro, exatamente como tivemos que fazer com “var” sobre HP.

Na próxima linha temos a declaração de um if(Se). Isto não é exatamente como uma proc; você pode separar o “if” dos parênteses, e tudo o que aparecer em azul no seu editor de códigos. Neste caso, estamos checando se o HP de M é menor ou igual a 0. Se for, o programa vai executar o que estiver embaixo da declaração. Neste caso, uma instrução para mandar uma mensagem para o mundo.

A parte [src] é nova; src vem de “source(fonte)”, src significa qualquer coisa que proc é pertencida. Em nosso caso, ChecarMorte() vai sempre pertencer para a M no verb Atacar. Mas ChecarMorte() não sabe que nós estamos o chamando de M, então usamos o src, que sempre se refere ao dono da proc.

Por enquanto, nosso código junto deve estar assim:

//Este é um mundo Teste criado por Blake em 04/09/2008.

mob
+icon = ‘pessoa.dmi’
+var
++HP = 30
+Login()
++icon_state = gender
++..()
+proc
++ChecarMorte()
+++if(HP<=0)
++++world<<”[src] morreu”
+verb
++Atacar(mob/M as mob in oview(1))
+++usr<< “Você atacou [M]!”
+++oview()<<”[usr] atacou [M]!”
+++var/dano = rand(1,10)
+++world << “[dano] dano!”
+++M.HP -= dano
++Falar(msg as text)
+++world <<”[usr]: [msg]”
turf
+grama
++icon = ‘grama.dmi’
world
+turf = /turf/grama

Salve tudo, ou compile de novo.

VId. Eu sou um Programador! (Antecipando problemas)

Não tão rápido, Jack. Um programador... um bom programador... tem que pensar no futuro. Ou seja, antecipar o que os jogadores irão fazer. Jogadores são sórdidos e atenciosos nas coisas, e se tiver algum problema com o seu jogo, eles eventualmente irão achá-lo.

Você pode identificar algum problema no código que já escrevemos?

Sim?Não? Se lembre de que os jogadores não vêem o jogo do mesmo jeito que você. Você sabe como as coisas devem agir; eles não.

Você está no caminho reto e apertado do “deveria fazer...” mas os jogadores não enxergam esse caminho tão claro quanto você. Eles andam por aí e entram em loops infinitos e bugs. Ou eles deliberadamente procuram por eles. Coisas que você nem imaginava que havia ali.

Acho que deveríamos ver nosso bug em ação. Primeiro precisamos de algo para atacar. Faça um novo arquivo icon e nomeie de “bug” (isto é simbólico). Clique na palheta e desenhe algum tipo de bug. Agora dentro de mob e entre as linhas icon e Login(),

coloque isso:

+bug //Novo protótipo
++icon = ‘bug.dmi’ //Define o novo icon, que era o ‘pessoa.dmi’

Nós quebramos a ordem alfabética em nosso código. Mas desse jeito temos os protótipos, mob e mob/bug, perto um do outro. Agora compile.

Para colocar nosso bug(inseto) no mapa, nós temos que abrir o arquivo Testworld.dmp. No painel à esquerda você verá o que é chamado de “Arvore”, que é um arranjo de galhos.

Clique no pequeno sinal ao lado de “mob” e a arvore vai abrir mostrando nosso bug.

Clique no bug e então coloque um ou dois ou dez em qualquer lugar que você quiser no mapa.

Compile de novo e rode. Experimente usar o verb Atacar. Mate um bug... então continue atacando. Muito irritante, né? Já teve jogos produzidos e vendidos com bugs bobos como esse (bater,bater,bater e nunca matar). Nós somos melhores que isso.

Olhando seu jogo, uma pessoa que não tem muito conhecimento iria ver um tipo de design de jogo de estratégia, algo raro em um tutorial de iniciante. Mas o design de um game é muito importante para mim. E deveria ser muito importante para você. Que tal se colocarmos quando o mob morrer o jogador ganhar 100 de ouro?

VIe. Buntime Rugs(Runtime bugs)

O que nós temos é um Runtime Bug. Nosso código parece ótimo... mas não faz o que agente quer que ele faça. Isto pode ser muito frustrante, e não tenha duvidas que você ainda vá bater muito sua cabeça no teclado durante sua carreira como programador. É por isso que eu tenho POIUYTREWQ marcado em minha testa.

Quando encaramos um problemas, nós (1) pensamos em todas as soluções e (2) escolhemos a mais eficiente. Este “pensar em todas as soluções” é provavelmente um pouco confuso para os iniciantes em DM. Então eu quero que você esqueça do código, pense na lógica do mundo real. Isto pode ser uma questão que você se pergunta todo dia em sua vida: “Como posso fazer as pessoas pararem de matar coisas que já estão mortas?”.

Desse jeito, nossas soluções caem para duas categorias básicas: Bloquear o assassino de matar o defunto, ou simplesmente remover o cadáver, então não teremos que bloquear.

Vou mostrar como fazer os dois.

VIf.Matendo o assassino sem atacar de novo(A declaração de else)

Aqui está o nosso jeito de bloquear o assassino.

++Atacar(mob/M as mob in oview(1))
+++if(M.HP<=0) //Se o HP de de M for igual ou menor que 0
++++usr<<”[M] já esta morto!”
+++else //Se não
++++usr<< “Você atacou [M]!”
++++oview()<<”[usr] atacou [M]!”
++++var/dano = rand(1,10)
++++world << “[dano] dano!”
++++M.HP -= dano

if e else trabalham juntas. Você pode ter um if sem um else, mas você não pode ter um else sem um if. Eles fazem do mesmo jeito que soam. Apesar de que else, poderia ser “otherwise”(de outra maneira) (if, else = Se, de outra maneira).

VIg. Ataque?!?!?! (A proc del())

Aqui está nosso jeito de dar um sumiço com o cadáver.

++ChecarMorte()
+++if(HP<=0)
++++world<<”[src] morreu”
++++del(src) //Deleta qualquer coisa que morreu

Isto faz exatamente como soa. Qualquer coisa que estiver nos parênteses da proc del()... será deletado do jogo.

Você tem que imaginar qual dessas soluções é melhor para você. Imagine que isso seja um verdadeiro game que você esteja fazendo, e pense à frente. Tem algum motivo para deixar defuntos por ai?

Eu vou escolher a solução del(), por causa do que vem a seguida...

VII. ... E pegando seus items (Recapitular)

Vá em frente e adicione essa linha ao nosso programa, depois do código mob e antes do código turf:

obj
+ouro //Define ouro como um protótipo, que é um tipo de obj
++icon = ‘ouro.dmi’ //Declara o ícone padrão
++var
+++quantidade //Declara uma nova variável chamada “quantidade”

Está tudo nos comentários. Aquele “obj” é como um mob e turf, é um tipo de coisas que podemos fazer protótipos. E é melhor usado como objetos no mundo real. Ou seja, coisas que não são pessoas nem lugares.

Agora Compile.

VII. AHA! (Erros de compilação)

Se você fez somente o que eu mandei fazer, você pode estar vendo algo como isso no painel da base:

Loading Testworld.dme

Testworld.dm:34:error:’ouro.dmi’:cannot find file

Testworld.dmb – 1 error, 0 warnings

Este é um erro de compilação. É na maioria das vezes fácil de concertar porque nosso amigo compilador nos mostra a linha onde ele acha o erro. Neste caso, obj/ouro/icon se refere à um arquivo que não existe. Porque não fizemos ele ainda. Vá e faça um novo .dmi para ouro, e coloque o nome de “ouro”. Criativo, não?

AGORA compile.

VIIB. Me mostre o dinheiro! (As procs Del() e new() e a variável loc)

Quando a proc del() é chamada, ela chama a proc Del()... conveniente,né? ... da área ou turf ou obj ou mob que está sendo deletado. Relembre do que eu disse procs internas maiúsculas pertencem à algo, enquanto as minúsculas não? As duas são procs internas e são do jeito que eu disse. Nós vamos modificar a proc Del() como fizemos com a proc Login(). Acima de Login()...

+Del()
++var/obj/ouro/G = new(loc) //Cria um novo objeto ouro
++G.quantidade = rand (1,100) //Define uma quantidade randomicamente
++...()


Entrando em detalhes. G é uma variável que criamos para guardar referencias com um obj. É por isso que é var/obj/ouro/G em vez de \G. O que assimilamos foi uma referencia ao obj; este obj vai ser do tipo var/obj/ouro. A proc interna new() é o que cria um novo obj. O que está em parênteses é a localização que queremos que ouro apareça.

Em nosso caso é “src.loc”. Está é a localização do src, ou a fonte da proc Del(), que é o mob que acabou de morrer. loc é uma variável interna que contem referencia com a turf que algo está sobre. Eu não coloquei “src.” em frente de “loc”. Você pode deixar assim e o programa vai presumir que você está falando sobre o src. Nos poupa de digitar um pouco a mais.

Em seguida nós acessamos uma variável de nosso novo obj. Nós usaremos o G. Nós falamos para o programa achar o obj que G se refere e colocar a variável quantidade com o valor de um numero entre 1 e 100.

Salve tudo ou compile.

VIIc Já estamos tendo diversão? (Eu espero que sim!)

Então. Quando matamos um bu, uma quantidade randômica de ouro vai aparecer no lugar do monstro. Não será muito útil para nós, se não conseguimos pega-lo. Aqui está o código para nosso obj ouro:

obj
+ouro
++icon = ‘ouro.dmi’
++var
+++quantidade
++verb
+++pegar()
++++set src in view(1) //src precisa estar perto
++++usr << ”Você pegou [quantidade] ouro.”
++++usr.carteira += quantidade //Adiciona à carteira de usr
++++del(src) //deleta o ouro


Você pode perceber que não podemos acessar a variável “carteira” não está em nosso código. Não é variável interna, então temos que criar. Então coloque “carteira” exatamente embaixo de “HP” na sessão mob.

Desta vez fizemos um obj/ouro/verb em vez de mob/verb. Isto significa que um obj/ouro precisa estar presente para que possamos usar este verb. A próxima linha faz isso, dizendo que o obj precisa estar na distancia de 1 tile do usr. Em seguida é nossa mensagem, completa com uma expressão embutida. A próxima significa que usr.carteira agora é igual a ele mais src.quantidade(a quantidade ouro) . Depois disso deletamos a fonte do verb (o obj ouro).

Compile e teste. Nós acabamos.

Ufa!

VIII. Exercícios

Aqui vai algumas coisas que você pode tentar. Você pode...

1.Mandar uma mensagem para o mundo que um jogador entrou no jogo?
2.Fazer um novo obj, com icon, e colocá-lo no mapa?
3.Escrever um verb permitindo o usuário de verificar sua carteira?

nossa, sem palavras!!!
tuto perfect brother!!!
parabéns!! pinet, fixo!

Abraços

muito lôko!!!
bem explicativo!!!!

Opa! fico feliz em ter ajudado.