/* TUTORIAL FEITO POR MANUOWN



Olá!
Se você já possuiu um conhecimento básico, mas deseja aprender
mais, deseja se aprofundar um pouco mais, nesse tutorial você
vera como utilizar varios comandos para dar um encrementada no
seu jogo e poder criar seus proprios códigos sozinho.

1 - MOB

1.1 - Vamos começar com algo simples, vamos criar um mob, que
podera falar com você:*/


mob/NPC
Mordomo
name = "Modormo"
icon = 'Mordomo.dmi'
verb
Conversar()
set src in oview(2)
/* Olhem aqui, colocamos um "verb" depois do nome do Mordomo,
ou seja, Caso você esteja a 2 tiles do Mordomo(set src in oview(2))
você tera o verbo para poder "Conversar com o mordomo".
Mas oque irá acontecer se eu clicar no verbo "Conversar"?
Bom agora a sua imaginação pode rolar solta. A varios modos de você
montar um dialogo com o Mordomo, podera fazer de um modo com que
dependendo da sua resposta ele fale alguma coisa, ou não. ex:*/
switch(alert("Olá, senhor","Mordomo","Olá","Quero Logo minha comida"))
if("Quero Logo minha comida")
alert("Quer saber? To me demitindo! Seu sem educação xD")
return
if("Olá")
switch(alert("Deseja sua comida?","Mordomo","Sim. por favor","Claro, vai logo"))
if("Claro, vai logo")
alert("Quer saber? To me demitindo! Seu sem educação xD")
return
if("Sim. por favor")
spawn(30)
switch(alert("Tome aqui o sua Comida","Mordomo","Obrigado","Que demora"))
if("Que demora")
alert("Quer saber? To me demitindo! Seu sem educação xD")
return
if("Obrigado")
usr << "[b]Esse é o meu dever ^^!"

/* Hum... Simples não? Não O_O? Bom então vamos às explicações:

"switch(alert("Olá, senhor","Mordomo","Olá","Quero Logo minha comida"))"
Vamos ver, começamos essa linha com um comando em azul: "switch".
usamos esse comando para literalmente trocarmos para alguma coisa,
no caso, a coisa é sempre aquilo que esta entre parenteses.

poderiamos fazer de eu m outro jeito:

mob/NPC
Mordomo
name = "Modormo"
icon = 'Mordomo.dmi'
verb
Conversar()
set src in oview(2)
switch(1)
if(1)
alert("Olá, senhor","Mordomo","Olá","Quero Logo minha comida")
if("Quero Logo minha comida")
alert("Quer saber? To me demitindo! Seu sem educação xD")
return
...

Ou seja, seguiriamos para o "1", logo depois colocamos
que se for 1( if(1) ) acontecerá o que esta em baixo(Lembre: os códigos
funcionam em forma de árvore). Nesse caso o primeiro modo seria
"mais bonito e simples", mas dependendo do que você deseja fazer
o segundo modo é um boa opção(ver tópico 5)

Bom continuando: logo depois do swtch, vem um "alert". Bom com o
comando alert, faremos aparecer em sua tela uma Quadro(igual àqueles
de messagem de erro do Windos), que nos dara uma menssagem e botões
para clicarmos.
o formato de uso do alert é o seguinte:

alert("Menssagem","Titulo","Botão 1","Botão 2")

obs: Quando nos não colocamos as opções para clicarmos(Botões 1 e 2),
fica padronizado um "OK" como opção.
obs²: Você poderá criar quantas opções forem necessárias.
obs³: Caso você deseje por opções, mas não quer por um titulo,
faça o seguinte.ex:
alert("Oi!","","Olá")
Assim, o titulo vai ficar nulo e a opção será "Olá"

Continuando: abaixo do alert vem:

if("Quero Logo minha comida")
alert("Quer saber? To me demitindo! Seu sem educação xD")
return
if("Olá")
switch(alert("Deseja sua comida?","Mordomo","Sim. por favor","Claro, vai logo"))

Inressante, aqui criamos uma certa ocasião, dependente da sua
resposta na pergunta anterior. Caso sua resposta seja
"Quero Logo minha comida", você recebera o alerta dizendo que
seu mordomo esta se despedindo.
E aquele return? Para que serve? Bom, como o seu mordomo se
despediu, é claro que ele não o servira mais, então nos "Paramos"
todo o codigo, ou seja, não acontecera mais nada depois do return.
Um outro exemplo:*/

mob
verb
Defecar()
defe
switch(alert("Você deseja defecar?","Defecar","Claro","Não"))
if("Não")
return
if("Claro")
usr << "Você defecou!"
spawn(10)
goto defe

/* Hum.. vamos dar uma olhada. Nos fizemos um verbo aqui, sua (f)utilidade
é fazer seu personagem defecar xD. Agora vamos analisar o código:
Veja a 4ª linha: defe
Mas que diabos esse "defe" ta fazendo ai?O_O
Bom, esse defe é como um nome, um título para um comando que iremos
ultilizar, é muito últil caso você for usar o mesmo prossedimente
varias vezes, podendo criar um ciclo com ele. SEMPRE você ira usar
o comando "goto"(em azul) para chamar essa linha de comando(literalmente,
"ir para" = "goto"), assim criando um ciclo que ira se repetir até a hora
em que você escolher a opção "Não", pois logo após do "Não" colocamos
um return, para paramos oque esta acontecendo, assim acabando com o
ciclo.
obs: o comando spawn(10), é usado para dar um tempo antes uma coisa que
esta abaixo do spawn, mas só aquilo que estiver com uma tab/espaço a
mais do que o spawn, ex:*/

mob
verb
Defecar2()
defe
switch(alert("Você deseja defecar?","Defecar","Claro","Não"))
if("Não")
return
if("Claro")
usr << "Você defecou!"
spawn(10)
goto defe

/* Aqui não vai adiantar de nada esse spawn, pois o "goto defe" esta apenas
uma linha abaixo, e sem o tab/espaço a mais, mas no caso:

if("Claro")
usr << "Você defecou!"
spawn(10)
goto defe

Funcionaria pois o esta com um tab/espaço a mais.
O formato do spanw é:

spawn(TEMPO)
[alguma.coisa]

Isso nos leva a um outro comando que pode ser usado em certos
casos:
sleep(TEMPO)
[alguma.coisa]

Bom, a funcionalidade é a mesma, fazer algo espera para ser execultada.
Mas então qual a Diferença? Bomb, vamos usar um explo para explicar:*/

mob
proc
Destruir_o_Mundo()
world << "O mundo será destruido em 60 segundos!"
sleep(100)
world << "O mundo será destruido em 50 segundos!"
sleep(100)
world << "O mundo será destruido em 40 segundos!"
sleep(100)
world << "O mundo será destruido em 30 segundos!"
sleep(100)
world << "O mundo será destruido em 20 segundos!"
sleep(100)
world << "O mundo será destruido em 10 segundos!"
sleep(80)
world << "O mundo será destruido em 2 segundos!"
sleep(20)
for(var/mob/A in world)
del A

/* Hum... Vamos ver. Aqui fizemos uma proc(processo), que fara o mundo
ser destruido .
Começamos o código com uma linha que mostrara para todos os players
a menssagem de que o mundo será destruido em 1 minuto. Logo abaixo
colocamos um sleep de 10 segundos(lembre-se no byond o segundo
equivale ao número 10), então a cada sleep terminado damos mais
uma menssagem de quanto tempo falta para o mundo ser destruido.
No final quando o mundo vai acabar, usamos o comando "for"(em
azul, que literalmente segnifica: "para") e expecificamos quem
desejamos "chamar", var/mob/A in world(ou seja, criamos uma var
interna, com ovalor de mob, e colocamos o nome de "A" em todas
que ele encontrar e falamos aonde é para ele procurar{in world}),
depois usamos o comando del(deletar) e deletamos todos os mobs A
de uma só vez(ou seja, todos são desconectados do server, dando o
efeito de que o mundofoi "destruido"), tbm poderiamos usar o
comando world.Reboot para darmos esse efeito mais isso é algo
para depois xD.
Bom, voltando ao sleep/spanw:
agora olhem o seguinte:*/

mob
proc
Destruir_o_Mundo2()
world << "O mundo será destruido em 60 segundos!"
spawn(100)
world << "O mundo será destruido em 50 segundos!"
spawn(100)
world << "O mundo será destruido em 40 segundos!"
spawn(100)
world << "O mundo será destruido em 30 segundos!"
spawn(100)
world << "O mundo será destruido em 20 segundos!"
spawn(100)
world << "O mundo será destruido em 10 segundos!"
spawn(80)
world << "O mundo será destruido em 2 segundos!"
spawn(20)
for(var/mob/A in world)
del A

/* Você deve estar pensando, oque que mudou "? E eu repondo: Tudo =D
Bom lembra-se de que eu falei que no spawn deve por as coisas uma
tab/espaço depois para poderem surtir efeito? Bom. como eu não
coloquei neste caso, oque ira acontecer? As menssgens não vão ter
um tempo entre elas, e irão aparece de uma só vez e os mobs A
tbm serão deletados na mesma hora. E como eu faço para concertar
isso?:*/

mob
proc
Destruir_o_Mundo3()
world << "O mundo será destruido em 60 segundos!"
spawn(100)
world << "O mundo será destruido em 50 segundos!"
spawn(100)
world << "O mundo será destruido em 40 segundos!"
spawn(100)
world << "O mundo será destruido em 30 segundos!"
spawn(100)
world << "O mundo será destruido em 20 segundos!"
spawn(100)
world << "O mundo será destruido em 10 segundos!"
spawn(80)
world << "O mundo será destruido em 2 segundos!"
spawn(20)
for(var/mob/A in world)
del A

/* Prontinho, agora esta funcionando =D.
Embora funcione, neste caso o preferivel seria você usar o sleep
ao invés do spawn, pois seria mais simples xD.


1.2 - Que tal fazermos os seus mobs andarem?

Vamos começar fazendo eles seguirem você*/

mob/NPC
Mordomo2
name = "Modormo"
icon = 'Mordomo.dmi'
New()
andar
for(var/mob/A in oview(6))
step_towards(src,A)
goto andar

/* Bem, agora seu Mordomo ira te seguir! Mas você intendeu oque
fizemos aqui? Vamos ver.
Logo abaixo do icon, colocamos um New(), que indica, quando
o mob for criado, ele ira executar depois que nascer, para
ele não fazer iss oapenas uma vez, criamos um ciclo.
Usamos o comando for para ele achar um mob/A... Mas oque é
"oview(6)"? Bom lembra que no código da destruição do Mundo
usanmos "in world", ou seja, no Mundo. Dessa vez usamos o oview(6)
que indica algo que esteja a 6(seis) tiles do src(Mordomo).
Se ao invés de oview(6) tivessemos usado view(6), seria 5 tiles do
src, pois o "o" na frente do view, indica "fora do src"(ou algo assim xD).
Logo a baixo temos:
step_towards(src,A)
step_towards(OQUE.IRA.SEGUIR , OQUE.IRS.SER.SEGUIDO)
o step_towards é usado para seguir.
Existem outros comando semelhantes:
step_away: para se destanciar
step_rand: para ficar andando se sentido único
e outros outros.



Obrigado por ler meu 1º Tutorial =D

Se gostarem irei continua os tutorial com muito mais conteudo!

Desculpem pelos erros de português!

Até a proxima!