MMFMakers

Bem-vindo!

2019-01-01T10:08:00.000-02:00

Olá e seja bem-vindo ao MMFMakers! Aqui no MMFMakers, você encontra diversos Tutoriais e Recursos para criar seus próprios jogos de computador! Então, se você sempre quis criar jogos, acessou o lugar certo!

Espero que desfrute do nosso conteúdo. Eu não sou um Expert em Criação de Jogos, e acho que não sou apto a ensinar, mas farei o possível para que entendam tudo que eu explicar. Além disso, fiz um blog porque quero que caso alguma dia não queira mais atualizar, o que eu fiz sempre estará aqui, ajudando os novatos, mesmo que não venha a ter novas coisas.

Se você tem alguma crítica, sugestão, dúvida ou quiser só conversar mesmo, mande um e-mail ou me adicione no msn:

admkhbr@hotmail.com

Porra, eu só prometo, mas...?

2011-12-14T18:38:00.005-02:00

Pootz galera, eu realmente tenho de me desculpar com vocês. Eu já perdi a conta de quantas vezes eu vim aqui e disse que ia melhorar o curso ou bla bla bla, mas acabo nunca fazendo nada.

Entedam, eu simplesmente perdi a fé no MMF2, principalmente depois de descobrir que as builds mais novas podem estar carregando um Cavalo de Tróia que pode, inclusive, contaminar todos os projetos compilados usando elas (podem estar, é apenas uma possibilidade, mas as chances não são nulas... o Norton pode ter dado apenas um falso positivo).

Dois avisos ao mesmo tempo: eu não sei se vou conseguir terminar esse curso do jeito que as coisas estão (o quadro do MMF2 está realmente ruim: caro, com vírus...), mesmo que eu recupere meu HD. Sem falar que estou cada vez menos ligado ao PC. Antes eu mexia em tudo, códigos, criação de jogos... agora o máximo que eu faço é ler um mangá ou outro no tempo ocioso, e olhe lá, com uma puta vontade de fazer algo legal de verdade.

Eu não sei se vou conseguir terminar esse curso. Desculpem a todos que acreditaram em mim esse tempo todo. Não vou fechar o blog, ele vai ficar aqui, e se pá, até faço uma matéria vez ou outra, mas dessa vez, estou falando o oposto do que sempre falo. A questão é que realmente não acho que eu vá conseguir.

É um grande projeto e, de fato, temos um número realmente bom de matérias. Contudo, porém, entretanto, todavia, não sei se um projeto como esse vale a pena para o MMF2 como ele é. Talvez seja uma base para o Construct (que é opensource, e você pode comercializar os jogos feitos nele, sem falar que o 2, apesar de pago, é realmente barato), mas se esse fosse o caso, eu faria logo um curso para o mesmo.

Queria dizer também pra vocês não perderem todo seu tempo no PC. Eu fazia isso... mas curtam a vida de uma outra forma (aos homens, meninas, fiquem em casa e sejam boas garotas, se um dia decidirmos nos casar, será com esse tipo de menina, não essas putas de hoje em dia). Eu acho que esse comentário já disse tudo, está implícito XD.

E se alguém quiser me adicionar no MSN pra bater um papo de vez enquando, vou ficar feliz. Me mandem também um e-mail de vez em quando só pra perguntar como vão as coisas xD. Também não vou ignorar dúvidas, mas tenham em mente que não sou nenhum gênio em MMF2, não sei um monte de coisas, e ainda estou sem ele no PC (pelos motivos já citados neste post), então, não garanto respostas. Enfim, quem quiser mandar uma dúvida, xingamento, ou só mesmo quiser dar um "oi", meu e-mail está na mensagem de abertura do blog, mas vou deixar aqui também: admkhbr@hotmail.com

Bom, é isso... isso não é um "adeus", mas também não é um "até logo". Encarem isso como um "a gente se vê por aí".

É isso, a gente se vê por aí! :P
Flw! :D

Estou de volta ;)

2011-10-28T23:25:00.003-02:00

Não recuperei meu HD, nem meu PC. Mas estou de volta, e quero fazer esse curso algo realmente bom.

Mas vou precisar da ajuda de vocês, falando em que preciso melhorar as aulas, se elas estão num ritmo bom, fáceis de entender, se estou atropelando coisas, se o método não está bom etc. Por favor, críticas construtivas. Digam como posso melhorar. Não demora, e vai ajudar pra caramba ;)

Vocês podem deixar comentário neste post ou me mandarem um e-mail (admkhbr@hotmail.com). Agradeço se fizerem qualquer um dos dois!

Grato.

Aloha

2011-09-08T19:48:00.001-03:00

Quem veio aqui esperando ver matéria nova, de meia volta.

Venho anunciar a vocês uma boa e uma má notícia.

A má primeiro: ficaremos sem posts até o fim desse ano. Talvez matéria só ano que vem agora. Isso mesmo, o blog ficará parado até que eu consiga recuperar meu HD. Vou mandar para uma empresa especializada no fim do ano, e então, vou ficar animado e voltar com o blog com força total =D

E a boa? A boa é que o blog não vai acabar. Já disse que não vou desistir dele e ponto. Só tamo passando por maus bocados, mas... TUDO PASSAAAA... TUDO PAAAAAASSAAAAAAAAAA O/

Flws aew!

Aww yeah!

2011-08-01T23:06:00.003-03:00

Eaí pessoal,
este post está liberado para xingamentos, trollagens e afins. Isso pq eu mereço mesmo auhauah

Eu disse no post passado q "essa semana" não tinha matéria. E não teve mesmo, faz tempo. Vou me explicar: acabei fazendo outra viajem de última hora, então, nem pude postar nada. Mas o fato de eu estar vindo aqui dar satisfações não trará novas aulas.

Estou com um pequeno grande problema. Alguns devem saber, outros não, que minha irmã quebrou meu HD externo onde tinha TODA A PORRA DE CRIAÇÃO DE JOGOS DESDE QUE ENTREI NESSE PORRA DE ÁREA DA COMPUTAÇÃO. Ou seja, perdi tudo: todas as minhas fontes, engines, extensões, o programa crackeado, builds novas, enfim: fudeu.

Com isso, desanimei pra caralho, e acabei desmontando meu PC. Estou acessando pelo PC da minha irmã para dar-lhes este post.

Isso significa que aulas agora serão raras, o que é uma pena, porque até achava que o blog estava num ritmo bom... só não desisto do blog porque não tenho coragem, já que não tem conteúdo decente de MMF2 na net. E eu acho melhor ter algum conteúdo - mesmo que não seja lá essas coisas - do que não ter nenhum.

Ah é! Minhas aulas começaram hoje! Mas como estou de coma alcóolica, infelizmente, não pude ir (mentira, matei aula). Acho que é uma boa desculpa... falem isso para suas coordenadores quando forem matar aula... já dei essa desculpa para 2 amigos, e acho que eles enguliram! Ou não (y)

Bom, é isso, flwz.

Sem matéria

2011-07-08T22:43:00.001-03:00

Essa semana n tem matéria... vou viajar =/

Flws.

Comunicado

2011-07-05T15:31:00.002-03:00

Venho lhes avisar que parei com essa frescura de cobaia.

As aulas estão ruins e pronto (eu dei uma lida) e vou reescrever após terminar o nível Básico.

Trolls, podem fazer a festa.

Iaew :D

2011-07-03T15:17:00.001-03:00

Bom, eu tenho boas e más notícias...

Antes as boas: fiz uma matéria nova :D
Agora a má: ela não ensina nenhuma função nova, só põe em prática algumas já ensinadas.

Quem quiser dar uma conferida, só ir na seção "Curso" ;D
Flw.

Invertendo Textos

2011-07-03T14:38:00.016-03:00

Introdução:
Um leitor me enviou uma pergunta que acredito ser digna de um tutorial... não sabia como fazer inicialmente, mas o também administrador da MMFM e amigo meu, Matheus290, enviou-me seu source de um inversor de links.

Trata-se de inverter textos no MMF2. Por exemplo: 123456789 ficará 987654321, assim como ASD ficará DSA.

Objetos necessários:
• 1 EditBox
• 1 Rich Edit Object
• 1 Button
• 1 Counter

Os Eventos:
Serão apenas 3 eventos. O primeiro serve para ativar a inversão. O segundo, é a inversão propriamente dita. E o terceiro, para desligar a inversão quando esta acabar.

Vamos fazer a ativação da inversão.

Button clicked?

Set Counter to GetNChars( "Rich Edit Object" )

Goto character number value( "Counter" )

Set text ""

(Button) Set internal flag 0 on

Calma, vou explicar. Quando o jogador clicar no botão, as ações irão acontecer. Elas são quatro:

• Set Counter to GetNChars( "Rich Edit Object" )
Irá definir o valor do Counter para o número de caracteres do Rich Edit.

• Goto character number value( "Counter" )
Vai até o caractere representado pelo valor do Counter.

• Set text ""
Esvazia a EditBox

• (Button) Set internal flag 0 on
Liga a flag 0 do botão. A inversão ocorrerá enquanto esta flag estiver ligada.

Muito bem. Vamos, então, fazer a inversão em si.

(Button): internal flag 0 is on

Subtract 1 from Counter

Set text Edittext$( "Edit Box" )+GetText$( "Rich Edit Object", value( "Counter" ), value( "Counter" )+1)

Aqui, as ações ocorrerão se a flag 0 do botão estiver ligada. Neste caso, são apenas duas ações:

• Subtract 1 from Counter
Esta irá subtrair 1 do Counter enquanto a flag estiver ligada, ao mesmo tempo que a inversão acontece. Entendará isso melhor quando ler sobre a próxima ação.

• Set text Edittext$( "Edit Box" )+GetText$( "Rich Edit Object", value( "Counter" ), value( "Counter" )+1)
Essa ação fará com que enquanto a flag 0 estiver ligada, o texto da EditBox vá se formando, a partir de seu valor atual (para armazenar os caracteres já invertidos) somados ao caractere do Rich Edit representado pelo valor do Counter. Como o Counter está sempre sendo subtraído, o caractere adicionado vai sendo sempre menos um, conforme ele vai adicionando! Meio confuso, mas veja bem... No texto 123456789. O caractere representado pelo Counter, inicialmente é o 9. Entretanto, ao mesmo tempo que o 9 é adicionado à EditBox, o valor do Counter é subtraído em um, o que significa que o caractere representado, agora, pelo Counter é o anterior, ou seja, 8. E isso vai se repetindo até não restar nenhum caractere e o Counter chegar a 0!

A primeira parte da fórmula, Edittext$( "Edit Box" ), você encontra já de cara na EditBox, quando usa a opção Retrieve data from an object. Ela é Get Text. A segunda parte, entretanto, GetText$( "Rich Edit Object", value( "Counter" ), value( "Counter" )+1), você deve ir no Rich Edit, e em Text > Get Text. E você vai ter de configurar a opção.

O que vai aparecer é o seguinte:
GetText$( "Rich Edit Object", >First character number<, >Second character number<)

Troque >First character number< pelo valor do Counter. E troque >Second character number< pelo valor do Counter adicionado a 1. First character number representa o início do caractere, e Second character number, o fim deste caractere. Isso significa que o caractere compreendido entre estes dois intervalos, é o que será adicionado à EditBox.

Talvez seja um pouco confuso, mas procure entender, em vez de simplesmente copiar... vale a pena ;p. Mas enfim... agora, vamos ao último evento! Desativar a inversão!

(Counter) <= 0
(Button) Set internal flag 0 off.

Acho que nem tem o que explicar... se o Counter for igual ou menor que 0 (o que significa que não existem mais caracteres a serem invertidos), desligar-se-á a flag 0 do botão, o que significa que a inversão será interrompida.

--//--

Bom, é isso aí... me pergunto, ainda, em que situação eu precisaria fazer algo assim... mas pra quem precisa saber, aí está :D.

Agradeço, mais uma vez, ao Matheus290. Foi graças a ele que aprendi a fazer isso daí. Agradecimentos também ao Alves, por ter tentado dar uma mãozinha.

Flw.

AVISO SUPER ULTRA MEGA LONGO, LEIA COM ATENÇÃO!!

2011-06-28T18:36:00.001-03:00

Acabei.

Grupos de Eventos

2011-06-28T17:34:00.023-03:00

Introdução:
Eu poderia dizer que a principal função de grupos de eventos é organização. De fato, fica muito mais difícil nos perder em nosso código quando agrupamos um conjunto de eventos que possui uma mesma função, ou de função semelhante. Principalmente em jogos com muitos eventos. Leve em consideração que você pode dividir ainda mais eventos semelhantes com comentários (ex.: grupo de eventos relacionados à morte do personagem, pode-se separar os eventos de "Morte por tempo" dos de "Morte por falta de HP" utilizando comentários, a fim de organizar ainda mais). Quanto mais organizado, melhor. Além do mais, substituição de milhares de linhas de eventos por poucas de grupos faz você ficar bem mais relaxado, acredite.

Veja bem... uma Static Engine (Movimento Personalizado) precisa de vários eventos para serem feitos. Se você os deixa soltos, acaba misturando com eventos de inimigos, efeitos etc. Agora, pense que os eventos de cada função estão dentro de um grupo com o nome dela. Os eventos do movimento em um grupo chamado "Static Engine" (onde comentários dividem os eventos da movimentação e da animação), os dos inimigos em um grupo "Inimigos", e por aí vai.

Mas organização é o de menos quando falamos de Grupos de Eventos. Acontece que Grupos de Eventos possuem duas funções, além de organização: proteger determinado grupo com uma senha (se, por exemplo, você estiver com dúvida em algo e quiser mandar o source para as pessoas analisarem o que há de errado, pode proteger os demais eventos) e ativar/desativar os eventos de um grupo. Aprendamos, então, a como fazê-lo.

Criando um grupo:
Criar um grupo é simples em demasia. Apenas clique com o botão direito do mouse no número ao lado de New Condition , e vá em Insert > A group of events.

Faça isso.

Ok. Uma janela como esta vai se abrir, para você inserir os dados do grupo:

Em Title of the group, você coloca o nome do grupo.

Nos dois campos de Password protection, insira uma senha para o grupo ser acessado (lembra que eu disse que também era possível proteger um grupo com senha?). Isso fará com que sempre que alguém tentar abrir o grupo, seja necessário digitar uma senha. Se o grupo já estiver aberto ou se a pessoa quiser fechá-lo, não será necessária senha alguma, ela só é requisitada para abrir ou editar o grupo. O grupo, então, só se abrirá se ela estiver correta. A senha inserida nos dois campos deve ser exatamente igual. Se quiser deixar o grupo sem senha (pode ser aberto sem precisar inserir senha alguma), apenas deixe estes dois campos em branco.

A opção Active when frame starts, ao ser marcada, faz com que o grupo seja ativado por padrão. Desmarcá-la faz com que o frame já se inicie com o grupo desativado. Para saber mais acerca disto, leia o próximo tópico.

Ao terminar, clique em OK. Lembrando que você pode editar as configurações de um grupo a qualquer hora clicando com o botão direito do mouse em cima dele, e escolhendo a opção Edit (se o grupo estiver protegido por senha, será necessário digitá-la corretamente).

Bom, isso é tudo sobre criação de grupos. Vamos à parte mais importante da aula, agora...

Ativando/desativando um grupo:
Quando falamos em ativar ou desativar um grupo, estamos falando, na verdade, em ativar ou desativar os evento do mesmo. Ativando os eventos, eles irão agir como qualquer outro. Desativando, seria como se eles não existissem. Para entender melhor, um exemplo. Suponha que tenho este evento dentro de um grupo qualquer:

Start of frame
("Objeto") Destroy

Always
Center window position at ("Outro Objeto que não é o Objeto do evento anterior")

Pois bem. Se o grupo estiver ativado, tais eventos agirão. Ao iniciar o frame, destruir-se-á o objeto Objeto, e sempre a tela será posicionada em relação ao Outro Objeto que não é o Objeto do evento anterior! Todavia, se o grupo estiver desativado, esses eventos não agirão. Quando iniciar o Frame, nada acontecerá ao Objeto, já que o evento que o destruiria está atuando como "inexistente". Muito menos a tela será centrada no Outro Objeto que não é o Objeto do evento anterior, pois este evento também está atuando como "inexistente", uma vez que está dentro de um grupo desativado.

Isso é útil em demasia a fim de se fazer "upgrades" pro personagem em um jogo. Wallkicks, tiros carregáveis, dashs... tudo isso você programaria em grupos (um grupo para cada upgrade), e os ativa ou desativa, caso o herói tenha ou não conquistado as habilidades em questão, respectivamente. E antes que me perguntem, sim, eu estava pensando em Megaman X quando escrevi isso.

Mas enfim, como ativar ou desativar grupos? São poucos passos que vão mudar sua vida de maker no MMF2. Você só precisa ter o grupo a ser ativado/desativado em mãos, e criar a condição que mude seu estado. Então, nas Special conditions, vá em Group of events e escolha Activate para ativar e Deactivate para desativar!

Special conditions > Group of events > Activate/Deactivate

Certo. Então, uma janelinha se abrirá, para que você selecione o grupo que será ativado ou desativado. Escolha-o e clique em OK.

No caso, escolhendo um grupo para ser ativado. Quando você escolhe Deactivate, lá em cima fica escrito isso, e não "Activate", mas não tava a fim de fazer outra imagem por causa de uma porra de uma palavra '-'.

Talvez você esteja se perguntando se não dá no mesmo usar flags... realmente, dá. Mas isso é só pra se você quiser ficar perdendo tempo limitando o estado em que a flag deve estar. Pra muitos eventos, então? É bem mais fácil, rápido e organizado usar grupos de eventos para isso. Isso sem falar que flags são numeradas, e grupos nomeados. Mas enfim... fica a critério de cada um o que quer usar.

--//--

Bom, essa é uma das aulas mais importantes do nível básico... espero que tenham gostado!
Até a próxima! -^.^-

Flw.

Comunicado

2011-06-26T18:31:00.003-03:00

Eaí pessoal!

Bom galera, é o seguinte... desculpem por não ter postado esse FdS. Ele foi cheio... na sexta teve niver, no sábado teve niver, e hoje dormi a tarde inteira e agora vou sair. Pra compensar, sai matéria durante a semana weee :D

Mudando radicalmente de assunto, pra quem está procurando um bom sistema de upload, venho recomendar-lhes um, já que isso ajudará tanto vocês como eu na MMFM :D. É nele que eu faço upload de grande parte do conteúdo da MMFM, e infelizmente meu espaço está acabando =\.

Pra quem se interessar por esse serviço (upload por desktop/web uploader e download por link direto, 2GBs inicais, podendo expandir para 8GB fazendo com que amigos se cadastrem com o seu reffearl). Vocês podem hospedar arquivos, imagens e até sites em HTML :D. Apesar de a URL destes últimos não ficar muito agradável... Mas enfim, existem redirecionadores gratuitos bons ^^. A questão é que é um ótimo serviço!

Para ajudar a MMFM e começar a usar o Dropbox (quem se interessar), vocês podem se cadastrar NESTE LINK. Ajudaria se quem desejar se cadastre com meu reffearl, porque só me restam 500mb, ainda sobrevivo com os 2GB inicias xD.

Mas isso é só pra quem quiser mesmo... porque pra eu ganhar o espaço, a pessoa tem de instalar o programa de upload por desktop até... só se a pessoa instalar eu ganho os 250mb.

Enfim, é isso... flw.

Outra semana sem matérias

2011-06-16T19:28:00.001-03:00

Continuo em semana de provas bimestrais. Graças a Deus, acabam dia 22. Mas esse FdS não tem aula de novo.

Flw.

Dúvidas MMF2

2011-06-14T16:27:00.007-03:00

Andei pensando e é realmente chato tirar dúvidas por e-mail. Afinal, apenas o autor da dúvida em questão saberia a resposta depois. Então, decidi criar um post para vocês deixarem suas dúvidas :). Assim, qualquer um que tenha a mesma dúvida pode obter a resposta!

Fica avisado que não sou profissional algum; muitas dúvidas não saberei responder, talvez. Mas se souber, responderei. E, claro, caso saibam responder a dúvida de um colega, podem muito bem fazer isso, e ficarei bastante agradecido!

Eu só peço duas coisas...
• Escrevam com ortografia correta, pois dói os olhos ler um texto do tipo "eo kriah kivs mim insinansse a fasê iço pq naum cnsegi entao pf rspnda!". Não estou pedindo que escrevam usando a norma culta e tal, mas pontuação, letra maiúscula/minúscula diferenciadas e pouco internetês... sempre bom, né?
• Expliquem direito a dúvida. Por exemplo, no lugar de "Como faço um jogo de Mario?", pergunte: "Gostaria de saber como fazer um sistema de evoluir ao pegar cogumelos, mapa-mundo e habilidades extras conforme o item pêgo.". Bem melhor assim, não?

Dúvidas que não seguirem as diretrizes acima serão excluídas sem aviso. Comentários ofensivos também serão excluídos. Vamos todos tentar fazer algo bacana e organizado, por favor :). Procurarei responder as dúvidas semanalmente, mas, sinceramente, não prometo nada.

Bem, é isso aí!
Deixem suas dúvidas abaixo, nos comentários.

Phew...

2011-06-10T19:56:00.002-03:00

E o filho da puuuura mulher brasileira do Artur não entrou. Me deixou ON na porra do MSN o dia todo esperando ele pra não entrar. Eu mato aquele portador de gigantismo --'.

E estou em época de provas bimestrais, nem venham cobrar novos tutos que provavelmente não sai. Tenho de estudar...

Flw.

Como prometido

2011-06-05T19:38:00.002-03:00

Rá. E aí está, finzinho de domingo, como prometido, uma matéria nova. Acabou sendo do nível Intermediário (apesar de não ter nada de intermediário nela, senão utilizar conceitos básicos ensinados no primeiro nível), e não do Básico como eu disse, mas enfim, tá feita.

Perdão pela demora com a cobaia. Passou-se uma semana e nem falamos nisso. Amanhã acho que não dá, mas sexta que vem converso com ele, para tentar ajudar a alma a conseguir instalar (isso aí, ele não conseguiu nem instalar; se aprender a criar jogos, classificarei minhas aulas como excelentes) o programa. Bem, gente fina o cara... pena não manjar muito de PC, pelo jeito.

E antes que me esqueça... comecei uma matéria bem básica sobre Lógica de Programação, para iniciantes (* cof cof e alguns intermediários também cof cof *). Não sei quando vou terminá-la, mas fica o aviso ;D

Flw.

Ini++

2011-06-05T19:35:00.002-03:00

Excelente extensão que permite manipular arquivos INI no MMF2. Extremamente superior a extensão padrão do MMF2 que tem esse objetivo. Essencial para qualquer usuário de MMF2 que quer fazer um jogo decente, com configurações, saves e muito mais!

Download (264KB): Link Direto

Armazenando dados em arquivos INI

2011-06-05T00:36:00.070-03:00

Introdução:
Podemos, de várias formas, manipular valores e expressões de texto em arquivos externos, tanto em MMF2 como em programas similares. Podemos armazenar tais dados em arquivos de texto, DATs, e, principalmente, em arquivos INI. Para explicar melhor, utilizarei a definição DESTE site:

"Um arquivo INI é um arquivo texto usado para armazenar/fornecer configurações pessoais para sistemas/usuários."

Isso significa que podemos "gravar" ou "receber" dados em tais arquivos. Tais dados podem ser tanto valores (1, 5, 10 etc) como conjuntos de caracteres ("Tiago", "armazenar dados em arquivos INI" etc). Tais configurações pessoais podem ser alteradas tanto por um programa (no nosso caso, MMF2), quanto pelo usuário. Ou seja, ou um programa modifica/recebe tais dados automaticamente, ou um usuário pode modificar tais valores à bel-prazer.

"Mas para quê isto nos serve na criação de jogos?", você me pergunta. Armazenar dados em arquivos externos serve-nos para que não perdamos tais dados ao fechar ou reiniciar o programa/jogo. No caso do MMF2, manda-se armazenar os dados no INI em determinada condição, e receber tais dados em outra. Podemos utilizar isto para gravar posições, valores, vidas etc. Ou seja, fazer um Sistema de Salvar (Save Game).

Segue este exemplo. Estou fazendo um jogo de labirinto. Coloco um botão de salvar no topo do Frame, e programo para que, se o jogador clicar no botão, armazenar as posições X e Y do herói em um arquivo INI. Então, coloco para que assim que começar o Frame, definir as posições X e Y do herói para as que estão armazenadas no INI. Assim, se eu salvar, quando posteriormente abrir o jogo, o personagem estará nas posições anteriores.

Só existe um problema: o usuário (no caso, o jogador) pode editar manualmente os dados de um INI. O que significa que ele pode simplesmente abrir o INI e modificar seus valores, a fim de trapacear. É algo que pode ser contornado, claro, mas fica o aviso, para que não deixe arquivos INIs importantes do jogo (quantidade de dinheiro do jogador, HP etc) rolando pela pasta dele. Assim, o jogador concluiria o jogo facilmente.

Existe uma solução simples: "mascarar" o INI, colocando nele outra extensão, como (*.dat), (*.lua), (*.sav), ou até mesmo extensões mais incomuns como (*.dll) e (*.arquivo_INI_camuflado_do_meu_jogo). Ou seja, fazer um arquivo de texto, com a estrutura de um INI, só que salvando com outra extensão. Nada de outro mundo. A extensão que será utilizada para mascarar o INI realmente não importa... a não ser que você seja estúpido o suficiente para usar o último exemplo. Podemos, também, criptografar o INI: assim, você nem precisa dar-se ao trabalho de mascará-lo, pois o jogador não conseguirá modificar seus valores. ;)

Perdoem-me pela grande introdução, mas acredito que seja importante não apenas dar-lhes o conceito de INI, mas falar sobre eles na criação de jogos.

Estrutura de um arquivo INI:
Para fazer um arquivo INI, basta abrir o Bloco de Notas, criá-lo, e salvar como nome_do_arquivo.ini, com a opção Todos os arquivos em vez de Documentos de texto (*.txt). A estrutura de um INI é a seguinte:

[GRUPO]
ITEM=DADO

Os [ ] (colchetes) declaram um GRUPO. Todo INI deve possuir no mínimo um. Você pode armazenar todos os valores em um único grupo, mas por uma questão de organização, isso não é aconselhável. Os itens compreendidos entre a próxima linha depois da declaração de um grupo X e uma linha antes da declaração de um grupo Y, pertencem grupo X. Grupos devem ser separados de ITENS ou de outros GRUPOS por linhas. Um GRUPO pode possuir tanto caracteres normais, quanto especiais (sinais e acentos), espaços e números. Mas cuidado, pois tais caracteres fazem sim a diferença (o grupo Herói é diferente de Heroi).

Cada ITEM armazena um dado, que pode ser um valor ou conjunto de caracteres (se fôssemos usar o INI acima do jeito que está, o valor do item ITEM seria o conjunto de caracteres DADO). Itens devem ser separados por linhas. Cada linha deve conter um GRUPO ou um ITEM. E cada GRUPO ou ITEM deve ser expresso em uma única linha. Ao saltar uma linha, você não estará mais trabalhando com aquele GRUPO ou ITEM. Um ITEM pode possuir tanto caracteres normais, quanto especiais (sinais e acentos), espaços e números. Mas cuidado, pois tais caracteres fazem sim a diferença (o item Mangas é diferente do item Mangás).

O sinal de = (igual) define o valor de um ITEM para o que vier depois dele naquela linha.

O que vem depois de um sinal de = em uma linha é o DADO de um determinado ITEM. Um DADO pode ser um valor numérico (value) ou um conjunto de caracteres (string). Não há diferença alguma entre tais dados, levando em consideração a declaração deles. Se o DADO possuir apenas caracteres numéricos após o sinal de igual, ele será um value; já se ele possuir também caracteres não-numéricos (espaços, letras e sinais), ou apenas estes tipos de caracteres, ele será uma string.

GRUPOS e ITENS não fazem diferença em relação à letras minúsculas e maiúsculas; DADOS, porém, fazem.

Aqui vai um exemplo de INI, agora, com mais de um grupo/itens:
[Personagem]
posX=286
posY=242
[Inimigo]
posX=491
posY=493

Este arquivo armazena as posições X e Y (cada uma determinada por um ITEM) do personagem e de seu inimigo. Perceba que eu posso utilizar dois itens com o mesmo nome, se estiverem em grupos diferentes. Caso eu use dois ou mais ITENS com o mesmo nome em um mesmo grupo, ele considerará o último a aparecer (mais recente, do ponto de vista do arquivo). E se eu usar dois ou mais GRUPOS com o mesmo nome, o programa "mesclará" os grupos.

Ini++:
Agora que já conhecemos a estrutura de um arquivo INI e como criá-los, veremos como armazenar e receber dados em um programa de MMF2 com tais arquivos. Para isto, utilizaremos a extensão Ini++, desenvolvida por Jack Webster.

Nas propriedades desta extensão, encontramos logo de cara uma opção Default file, para utilizar um arquivo INI padrão: isto significa que será o primeiro arquivo INI procurado pela extensão. Se desmarcar esta caixa, você precisará carregar o INI manualmente; se deixar marcada, ele o carregará de imediato.

A opção Read only impede que o programa mude os valores do INI padrão; o que significa que ele apenas poderá receber os valores desse INI. Isto serve para que o usuário possa alterar dados pelo INI, e, estes dados, seriam carregados pelo programa. Opção desnecessária, eu diria.

Base folder é o diretório onde se encontra o arquivo INI padrão. Você pode optar, principalmente, entre a pasta raíz do programa e a pasta WINDOWS, que se encontra no Disco local C:\.

E essas são todas as opções realmente relevantes. Perceba que, se o INI padrão ainda não existir, a extensão há de criá-lo. Nesse caso, os valores definidos pelos eventos criarão no INI os grupos e itens. Se o INI já existir, ele simplesmente o carregará. Prefiro definir logo os valores que quero usar, então, sempre crio o INI antes. Em relação à ordem, não faz diferença, quando mandamos o programa armazenar valores, ele organiza os itens em ordem alfabética.

Armazenando/recebendo dados no MMF2:
Uma vez que a extensão esteja configurada como desejar, vamos aprender a armazenar e receber valores de arquivos INI no MMF2.

Antes de aprender a receber, vejamos como armazenar dados em um INI. Utilizamos ações diferentes para armazenar valores e strings. Para armazenar um valor, na ação do evento desejado, vá na classe da extensão, entre em Setting Items, e escolha Set Value.

A primeira coisa que ele irá pedir é o grupo que contém o item no qual o dado será armazenado. Entre aspas, digite o nome do grupo e dê OK.

Grupo Herói.

Então, ele pedirá o item no qual o dado será armazenado. Novamente entre aspas, escreva o nome do item e dê OK.

Item posX.

Agora, ele quer saber se o valor a ser armazenado é inteiro ou racional. Se for um número inteiro, deixe como 0. Se for um número racional, coloque 1. Os números racionais também englobam números inteiros; isso significa que se você colocar 1, ele armazenará tanto valores inteiros quanto racionais no item, apesar do contrário não ser verdade (colocando 0, ele apenas armazenará números inteiros). Acredito que tal divisão sirva para, no primeiro caso, ocupar menos bytes na memória do PC. Mas não sei explicar-lhes com certeza. É assim no C/C++, não sei se isto se aplica aqui. Enfim, após escolher o tipo de valor, dê OK.

Armazenar valor inteiro.

Por fim, ele quer saber qual o valor a ser armazenado. Tal valor pode ser fixo ou recebido de outro objeto (alterable values, global values etc). No exemplo, o valor armazenado deverá ser a posição X do personagem.

Receber posição X do Herói.

E, assim, armazena-se um valor. Vamos, então, aprender a armazenar uma string. É basicamente a mesma coisa, não fosse o fato de ser mais rápido, pois não existem strings inteiras ou racionais. Para armazenar uma string, na ação do evento desejado, vá na classe da extensão e entre em Setting Items, e escolha Set String.

Novamente, ele primeiro pede o grupo que contém o item no qual o dado (dessa vez uma string) será armazenado. Escreva entre aspas, e dê OK.

Grupo Herói.

Aqui, ele pede o item no qual a string será armazenada. Escreva entre aspas e dê OK.

Item nome.

Por fim, aqui, ele pede a string a ser armazenada. Uma string, tal como um valor, pode ser fixa ou recebida de outro objeto. Na imagem, a string armazenada será recebida do texto contido na EditBox.

Armazenar como string o texto da EditBox.

E isso é o básico sobre armazenar dados. Vamos, agora, aprender a receber dados.

--//--

Na ação, defina o valor/string desejado como definiria normalmente (por exemplo, se for para definir o valor de um Counter, vá em Set Counter). Quando ele pedir o valor, vá em Retrieve data from an object. Dependendo do tipo de dado (valor ou string), selecione Get Item Value (group, item, default value) ou Get Item String (group, item, default string).

Se o dado for um valor, dê um duplo clique sobre a extensão e escolha Get Item Value (group, item, default value). Deve aparecer a seguinte expressão:
GetItemValue( "Ini++", > Enter string here <, > Enter string here <, > Enter value here <)

Expressão que deve aparecer.

Substitua o primeiro > Enter string here < pelo nome do grupo (entre aspas), que contém o item no qual o valor a ser recebido está. O segundo > Enter string here <, substitua, também entre aspas, pelo nome do item no qual o valor em questão está. E, por fim, você deve substituir o terceiro > Enter string here < por um valor padrão, que o programa utilizará, caso ele não encontre o item em questão; seja por não existir, ou por ainda não ter sido criado (caso seja o programa que vá criá-lo posteriormente).

Receber o valor do item posX, que está no grupo Herói. Caso o item não seja encontrado, adota-se o valor 0.

Já se o dado for uma string, dê um duplo clique sobre a extensão e escolha a opção Get Item String (group, item, default string). A expressão que deve aparecer agora é esta:
GetItemString$( "Ini++", > Enter string here <, > Enter string here <, > Enter string here <)

Expressão que deverá aparecer.

Substitua o primeiro > Enter string here < pelo nome do grupo (entre aspas) que contém o item no qual a string em questão está armazenada. O segundo > Enter string here <, você deve substituir pelo nome do item (também entre aspas) no qual a string a ser recebida está armazenada. Por fim, o terceiro > Enter string here < nada mais é do que uma string padrão (que também deve ser escrita entre aspas) que o programa adotará caso o item não exista, ou ainda não tenha sido criado (no caso de o programa criá-lo apenas futuramente).

Receber a string do item nome, que pertence ao grupo Herói. Caso o item não seja encontrado, utilizar como valor padrão um texto vazio.

--//--

E isso é o básico sobre armazenar e receber dados de um arquivo INI ;). A extensão ainda possui algumas funções necessárias e úteis (como mudar o INI com o qual ela está trabalhando), mas não vou deixar a matéria muito extensa explicando-as. Você pode explorar o resto da extensão sozinho; não é difícil. Fica isso como lição de casa.

Se quiser ver um exemplo que fiz para esta matéria, clique AQUI.

Bom, é isso. Espero que tenham entendido :). Dúvidas, sabem meu e-mail.
Flw.

Aviso

2011-06-02T20:27:00.002-03:00

Olá, olá!

Vejo que os votos positivos estão subindo, o que leva-me a concluir que os primeiros eram, de fato, trolls. Mas isso não muda o fato de que irei fazer a experiencia, e restringirei ou não o blog de acordo com o resultado.

Mas mais uma vez fica avisado aos meus fieis e poucos leitores não-trolls: não se preocupem! Mandem-me um e-mail e adicionarei vocês na lista de leitores!

Ah sim! Essa semana tem matéria nova ;P. Na sexta, passarei o dia fora (escola + trabalho + academia), então, não vou ter tempo. Sábado, vou sair. Mas no domingo deve sair algo ;D. Refarei a matéria sobre edições de imagens no MMF2, e, se der tempo, farei uma nova do nível iniciante.

Flw.

Lógica de Programação

2011-05-31T20:53:00.019-03:00

Introdução:
Parecia-me um grande erro começar este curso falando de outra coisa senão Lógica de Programação. Conhecida, em alguns casos, como Algorítimo, é a base para a criação de qualquer software ou jogo, seja em MMF2, Java, Flash ou C/C++. O nosso objetivo utilizando tais programas é dar vida a esse Algorítimo. Aplicá-lo no software, para que este cumpra o que promete.

A Lógica:
Serei breve aqui. Utilizarei para explicar Lógica de Programação com uma situação do nosso cotidiano. Percebam: se quiséssemos fazer um jogo com uma situação assim, precisariamos reproduzir essa lógica no software.

O esquema acima representa uma situação e as possíveis formas de tal situação terminar. O que você vai fazer ao desenvolver um jogo é criar uma situação como essa e os rumos que ela pode tomar.

Outro exemplo. Super Mario é um clássico no mundo dos jogos. Provavelmente muitos dos que estão lendo isso agora já o jogaram e sabem como o jogo funciona. No que diz respeito a como enfrentar os inimigos no jogo, é mais ou menos o seguinte:

Mário encontra um inimigo...
> Vai tentar enfrentá-lo?
> Sim
>> Colide com ele
>>> Pulou em cima dele?
>>>> Sim
>>>> Inimigo morre
>>>> Não
>>>> Mario morre
> Não
>> Passa por ele correndo

Vê? Se o jogador decide enfrentar o inimigo, ele deve pular em cima deste para matá-lo. Se o inimigo e o Mario colidirem enquanto Mario estiver no chão, quem morre é o Mario. Mas se Mario pular na cabeça do inimigo, é o inimigo quem morre. Aí está um Algorítimo usado diretamente em jogos.

Concluindo:
Bem, é só isso. Você só precisa ter noção de que é você quem cria o universo dentro do seu jogo/software. No começo, você pouco utilizará Algorítimo; será algo muito mecânico: apenas colocar os personagens e obstáculos na tela e fazer eles se mexerem. Porém, para criar coisas mais complexas futuramente, você terá que criar manualmente esse conjunto de possibilidades em uma situação.

Mas não se preocupe com isso agora. Com o tempo você desenvolverá sua lógica e vai poder fazer o que quiser. É por isso que nas próximas aulas, focarei em ensiná-los as principais funções do programa.

Flw.

Nada de especial

2011-05-31T19:34:00.002-03:00

Não, relaxem, não é nada de especial. Só queria agradecer PELAS MILHARES E MILHARES DE OPINIÕES QUE VOCÊS DEIXARAM NESTE POST:
http://mmfmakers.blogspot.com/2011/05/aula-2.html

BRIGADÃO GALERA! AGORA EU SEI EXATAMENTE COMO ESTÁ A MATÉRIA! ¬¬

Falando sério, façam a parte de vocês... colaborem pootz! Preciso saber se está boa, e preciso do ponto de vista de vocês! Artur está se mostrando um pouco desinteressado acerca do assunto, então, ainda nem tentou.

Bem, se não for o Artur, tem o Diego.

Aula 2 & Engine

2011-05-29T21:44:00.001-03:00

Eaíii galeraaaa!!

Refiz a aula 2. Gostaria que dessem uma lida e comentassem neste post se está melhor ou pior. Mas queria que fizessem isso mesmo... tenho de saber se a matéria tá boa ou não ;). Não to pedindo pra só darem uma olhada nas imagens e dizer: tá legal. Não, queria que lessem mesmo... ver se, do ponto de vista de um iniciante, está compreensível.

Obrigado.

--//--

Além disso, trago pra vocês uma engine nova, de selecionar personagens em três slots, como no tal jogo Naruto Arena. Vocês podem conferi-la na seção de engines. Extremamente simples a lógica, vocês devem entender sem problemas.

Seleção Tripla de Personagens

2011-05-29T21:35:00.001-03:00

Autor: Eskyz

Descrição: No fórum, o tonico mandou uma dúvida, perguntando como fazer uma seleção tripla de personagens, como no jogo Naruto Arena. Dei uma olhada no jogo em questão, e desenvolvi um método para se fazer isso utilizando Global Strings.

Os eventos são muitos, e variam dependendo do número de personagens do seu jogo, e da quantidade de slots que serão selecionáveis. Mas a essência é simples, e, nos eventos, o que mudam são detalhes. Ou seja, você faz um, e vai só copiando e colando, mudando o personagem. Então, não tem problema algum ;P.

Download: Link Direto

Cobaia

2011-05-26T13:35:00.005-03:00

Olá pessoal!

Já achei a cobaia! Após revisar a segunda aula, começaremos os testes. Minha cobaia será o nosso amigo João Artur. ~~Ele é inteligente. O melhor seria uma pessoa mediana, mas ele serve com certeza.~~ Comecei a ficar em dúvida, já que ele achou difícil até instalar o programa...

Flw.

Eaí

2011-05-25T17:28:00.004-03:00

Eaí pessoal! Como disse, ainda não postei nenhuma matéria. Estou desenvolvendo um método de fazer full screen universal com Window Control (a FS padrão achata), e, quando conseguir, irei postar. E quando começo uma matéria, a termino.

Está sendo muito complicado redimensionar o tamanho do display até um limite desejado por mim; não encontrei tal função em extensão alguma. Entretanto, um amigo meu que sabe C, e tem a SDK da Click, tentará desenvolver tal extensão, se necessário.

Sobre a enquete, vi que em um voto Péssimo. Não sei se é trollagem ou não, mas, de qualquer forma, irei revisar todas as matérias. Depois, chamarei um amigo leigo, que nunca teve contato com criação de jogos, mas interessado, para tentar aprender a utilizar MMF2. Se ele conseguir, e eu descobrir que foi trollagem, vou ficar extremamente decepcionado: estou levando esta enquete a sério, e irei revisar todas as aulas de acordo com seu resultado. Se realmente está ruim, deixe. Mas se for trollagem, eu saberei, e, nesse caso, infelizmente, terei de selecionar meus leitores.

Não preciso dizer que, apesar de não ser boa, a MMFM é a única comunidade que contêm realmente uma quantidade considerável de matérias sobre o assunto. O que significa que os trolls vão se fuder UAAUHAUHA. Mas quem não deve não teme; se for opinião sincera, saberei. E quem realmente tem vontade de aprender MMF2, certamente me mandará um e-mail solicitando ser convidado para ler o blog ^^. Se você for um leitor sério, não será prejudicado :).

É isso aí. Tenho um amigo super interessado no colégio, e farei um teste. Eu detesto trolls, então, se você for um, serei obrigado a combater fogo com fogo. Ou melhor... trollagem com trollagem.

Flw.

Space Max

2011-05-22T20:04:00.003-03:00

Meu 2º game╝╝ feito por mim, Space Max
He, meu joguinho de nave quase sem graça mas não sei se vocês vão gostar!?○○○○

Imagens:

Titulo: Space Max

Versão:1.0

Fases: 9/9

Dificuldade: Média

Download: 4shared.com /file/KxD8t1Yn/SM_Install.html

O jogo é feito com poucos eventos mas ta bom.

Sonic Island

2011-05-22T20:00:00.000-03:00

História do Jogo

Sonic estava indo a Angel Island quando Dr.Robotinik ataca e Sonic é jogado no centro da Angel Island.
Saia da Angel Island e acabe com o Dr.Robotinik.

Criador: Gabriel Francisco

Programa: MMF2

Download: 4shared.com /file/_Yk2BXvr/Instalar.html

Imagens:

Joguinho paresido com o Sonic Angel Island.Hihi e Sonic Spike.

Ta feito o game!

Pra quem não está conseguindo baixar, copie o link e cole no navegador: http://www.4shared.com/file/_Yk2BXvr/Instalar.html

Space Invaders Customizado

2011-05-22T19:42:00.000-03:00

Acho que essa matéria é um mini tutorial mas vamos lá. Só que sem a droga do Movimento Pré-Definido Space Invaders.

Objetos:

3 Detectores
Naves inimígas[apenas uma na parte cinza].

Spoiler:
	Expandir esta imagem Reduzir esta imagem Ver em tamanho real

Crie mais dois detectores com movimento Boucing Ball,

Spoiler:
	Expandir esta imagem Reduzir esta imagem Ver em tamanho real

só que indo para a esquerda e altere a velocidade.
No meu caso, a velocidade e 10 mas bote o que você achar melhor.
Mas não muito rápido.

Vocês sabem que detectores sempre devem estar invisíveis.

Quando os dois detectores colidirem com outro detector vermelho,
faça as criações das naves com o Create Object

Quando os dois detectores colidirem no outro lado do frame faça os seguintes eventos:

Leaves the play area on the bottom, top or left> Wrap around play area.

Ta Feito!

Funções do Backdrop

2011-05-22T19:38:00.000-03:00

Bem gente, pra quem não sabe, Backdrop ou Background é um tipo de plano de fundo de uma area.
Exemplo:

Varias maneiras de utilizar:

Existem varias maneiras de utilizar o Backdrop como uma plataforma, uma escada ou um obstaculo qualquer ou até mesmo nada.
As duas principais funções do Backdrop é de Plataforma e de não fazer nada (modo plano de fundo)

Plataforma:

Alguns iniciantes devem falar:
"Por que o personagem não colidiu no Backdrop se eu fiz o evento de colisão nele?"
Se algum iniciante fez essa reclamação eu resolvo isso.
Para colidir, selecione o backdrop e vá nas propriedades do backdrop e clique em
Depois disto faça isto:

Facil né

Para fazer as outras funções como escada faça o mesmo com a função de programar para plataforma.
Em vez de botar "Platform" bote "Ladder"
Para fazer a função de escada encoste no backdrop programado para escada e aperte cima e baixo para decer e subir.

Atenção: Para fazer as colisões de obstaculo e plataforma bote o evento: "(Objeto) collides with the background" e a função é "Bounce" ou se preferir "Stop"

Tudo feito!!!

Espero que tenho ajudado bastantes iniciantes desse planeta. :)

Parte 3 da matéria

2011-05-21T16:58:00.003-03:00

Só escrevendo pra dizer que pode ser que demore um pouco para eu postar a terceira parte da matéria. Alguns dias talvez, to um pouco apertado.

Ah sim, por favor, votem na enquete ao lado. É muito importante, já que estou fazendo a revisão das matérias. Mas, por favor, sem trollagens. Votem sério. Se curtiram, em Muito boas ou boas... se não curtiram, votem em Ruins ou Péssimas. Se acharam que só servem para complementar, cliquem em Razoável. Mas votem na moral, por favor.

Flw

Parte 2 do MPFL

2011-05-20T18:51:00.002-03:00

A parte 2 já foi postada, e já pode ser conferida na seção Apostila MMF2.

Flw.

Movimento Personalizado de Fast Loops - Parte 2

2011-05-20T15:33:00.038-03:00

Parte 2: Gravidade e Pulo

Introdução:
Aula passada, entendemos a essência do Movimento Personalizado de Fast Loops. Mas para fazer-se um movimento de plataforma, precisaremos criar eventos de gravidade. E, se o programador desejar, o que normalmente deseja, eventos de pulo. Normalmente? Sim, pois devemos observar que em certos tipos de jogos, não há como pular. Se bem que, nesse caso, um pré-definido bastaria.

Preparando o Terreno:
Aqui, criemos os seguintes objetos: alguns backdrops (chão, paredes e teto); uma Máscara de Colisão (novamente usemos 32x32, e chamemos-a de MC) com o hotspot na parte inferior-central; e um Detector de Colisão, com 1px de altura e a mesma largura da Máscara de Colisão, seu Hotspot posicionado na parte central-central.

Frame montado. Um chão, duas paredes e um teto, sem falar na Máscara de Colisão. Repare também no pequeno detector logo abaixo da Máscara de Colisão.

Se prestou atenção na aula anterior, deve estar se perguntando o porquê do detector, já que as colisões são reconhecidas pela Máscara de Colisão. Respondo em uma palavra: pulo. É verdade que existem outras formas de se fazer o pulo (através de uma flag, por exemplo), mas estou adotando essa não apenas por ser mais prática, como também para tentar ser fiel ao movimento original de David.

Em princípio (e em eventos também), é bastante simples: o detector deve sempre ficar 1px abaixo do personagem. Logo, podemos dizer que quando o detector está sobrepondo um obstáculo, a Máscara de Colisão está no chão. E se o personagem estiver no chão e o jogador pressionar o botão de pulo... o personagem pula.

Mas ainda não acabamos de preparar nosso terreno: ainda precisamos nomear as variáveis, exatamente como fizemos na aula anterior.

Variáveis nomeadas.

Agora sim, aos eventos.

Programando o movimento:
Acho desnecessário repetir toda a longa explicação sobre Movimentos Horizontais, já que vocês já devem dominá-los bem a essa altura. Afinal, já a fizeram em ambos os eixos apenas neste tipo de movimento; já trabalhamos com posições X e Y faz algum tempo.

Só devo acrescentar um pequeno detalhe aos eventos desta vez, que diz respeito ao nosso detector. Em todos os eventos em que ocorre de fato uma movimentação (são aqueles em que alteramos a posição da Máscara de Colisão, no caso, a posição X), adicione a seguinte ação:

Set position at (0,1) from ("MC")

Isto é, todas as condições que causam uma movimentação na Máscara de Colisão, devem causar uma movimentação também no detector. Entretanto, o movimento do detector não precisa ser específico; basta colocar-se para que movimente-se para baixo da Máscara de Colisão.

Deve ficar desse jeito. Esses dois eventos são os que fazem a Máscara de Colisão de fato se movimentar, pois mudam sua posição X.

Vamos programar, então, a gravidade e o pulo!

A) Manipulação de Variáveis
Antes de manipular as variáveis, tenha isto em mente: a variável MovY representa a gravidade.

Vamos definir a aceleração gravitacional. Faça o seguinte evento:

MovY of ("MC") < 10
Set MovY to MovY("MC")+0.5

Tal evento significa que, enquanto a gravidade for menor que 10, adicionaremos 0.5 a ela, para que chegue, gradualmente, a 10. Quando chegar em 10, ela para; isso serve para que quando o personagem pule de determinadas altitudes, a velocidade de queda seja limitada, para que ele não caia muito rápido. Logo, a cada centésimo de segundo, a velocidade varia em 0.5px a favor da trajetória (ela é orientada para baixo). Isso significa que 0.5 é a aceleração.

Você pode fazer com que a gravidade seja menor de duas formas: a primeira, é diminuindo a aceleração (0.5). A segunda, adicionando uma condição Every.

Pois bem. Vamos, então, ao pulo.

("Jogador 1") Pressed fire 1
("Detector") is overlapping a background
Set MovY to -10

Esse evento diz que, se o detector estiver sobrepondo um obstáculo (o que significa que o personagem está no chão) e o jogador pressionar a tecla de fogo 1, a variável da gravidade será definida para -10. Neste ponto, talvez, você não entenda o que isso significa. Mas é o que fará com que a Máscara de Colisão pule. E quanto menor o valor (pois é negativo), mais alto a Máscara de Colisão pulará. Em breve, entenderemos por que.

B) Loops de Movimentação
É aqui que é feito o movimento propriamente dito. Precisamos, antes de mais nada, definir a quantidade de vezes que o loop irá acontecer, de acordo com o valor da variável, assim, causando o movimento.

MovY of ("MC") <> 0
Start loop "MovY" Abs(MovY( "MC" ))

Ou seja, se a gravidade for diferente de 0, iniciará-se um loop. Tal loop será o "motor" para movimentação em si. A quantidade de vezes que o loop será executado é expressa pelo módulo da variável MovY. Isso porque não se pode executar um loop um número negativo de vezes =P.

Agora, começa a movimentação. Faremos com que o personagem se mova a favor da trajetória. Ou seja, caia.

On loop "MovY"
MovY of ("MC") > 0
(MC) Set Y position to Y( "MC" )+1
(DP) Set position at (0, 1) from ("MC")

Ou seja, enquanto o loop estiver sendo executado, se a gravidade for maior que 0 (valores positivos equivalem ao sentido para baixo, pois esta é a orientação da trajetória), define-se a posição Y da Máscara de Colisão para sua própria posição, adicionada a 1(px). Isso significa que enquanto o loop estiver sendo executado e a gravidade for positiva, a Máscara de Colisão irá cair. E o detector será posicionado em seu devido lugar, já que ele deve se mover sempre que a Máscara de Colisão se mover.

Faremos, agora, o inverso: que a Máscara de Colisão mova-se contra a trajetória. Isso significa... subir!

On loop "MovY"
MovY of ("MC") < 0
(MC) Set Y position to Y("MC")-1
(DP) Set position at (0, 1) from ("MC")

Enquanto o loop estiver sendo executado, se a gravidade for menor que 0 (valores negativos equivalem ao sentido para cima, pois este é o sentido oposto ao da trajetória), define-se a posição Y da Máscara de Colisão para a sua própria posição, subtraída de 1(px). Isso significa que enquanto a gravidade for negativa, o personagem irá subir. Por isso que no evento do pulo, definimos a variável para um valor negativo!

Entretanto, ele não ficará para sempre no ar, pois o primeiro evento que fizemos irá tratar de fazer a Máscara de Colisão descer. Se a gravidade é negativa, é menor que 10; logo, pelo primeiro evento que fizemos, ele irá adicionando 0.5 à gravidade, fazendo com que, gradualmente, o valor vá crescendo, até que a gravidade volte a ser positiva, e a Máscara de Colisão volte a cair.

Vamos fazer as colisões. Primeiro, vamos fazer com que a Máscara de Colisão colida com o teto:

On loop "MovY"
MovY of ("MC") < 0
("MC") is overlapping a backdrop
Stop loop "MovY"
(MC) Set Y position to Y("MC")+1
Set MovY to 0
(DP) Set position at (0, 1) from ("MC")

Ou seja, se enquanto o loop estiver sendo executado e a gravidade for menor que 0 (ou seja, a Máscara de Colisão estiver pulando), a Máscara de Colisão sobrepor um obstáculo, isso significa que ele é teto. Logo, devemos fazê-la descer, para que ela não atravesse o teto. Para isso, somamos 1 à sua posição (o que anula a subida), paramos o loop, e definimos o valor da variável MovY para 0. Estes dois últimos, como já expliquei, servem para que a Máscara de Colisão não "trave" no obstáculo ao colidir. Ah, claro, e posicionamos o detector também, para que ele se ajuste novamente.

Agora, colidir com o chão:

On loop "MovY"
MovY of ("MC") > 0
("MC") is overlapping a backdrop
Stop loop "MovY"
(MC) Set Y position to Y("MC")-1
Set MovY to 0
(DP) Set position at (0, 1) from ("MC")

O princípio é o mesmo. Anulamos o movimento somando um valor oposto, definimos a variável para 0, paramos o loop e posicionamos o detector. Só o que mudou agora, foi o sentido. Já que MovY é maior que 0, o personagem logicamente estará caindo, e o obstáculo que ele encontrará será o chão. Para que ele não atravesse o chão, fazemos com que ele suba 1px, ao mesmo tempo que desce 1px. Os dois, então, se anulam, e a Máscara de Colisão entra em repouso. Ao mesmo tempo, fazemos com que o loop pare e a gravidade (MovY) seja definida para 0.

--//--

E aí está! Um movimento de plataforma perfeito, sem bug algum, e completamente customizável. Agora, tente personalizá-lo ainda mais. Cria molas, pulos duplos, plataformas móveis, tudo o que puder imaginar! Vá testando sua imaginação, vendo se consegue fazer algo sozinho. Caso não tenha entendido algo, dê uma conferida neste exemplo, para ver onde errou.

Mas calma lá, ainda não acabamos... na próxima parte, ensinarei a fazer Slope e a configurar as animações. Para quem não sabe, Slope é a capacidade de andar em terrenos irregulares, como ladeiras. As animações... bem, vocês já deveriam saber fazer, mas ensinarei assim mesmo.

Bom aprendizado ;)
Flw.

Parte II da matéria

2011-05-20T15:31:00.002-03:00

Eaí comunidade mmfmakiana! Antes de mais nada, gostaria de pedir desculpas pelo atraso de uma explicação. Estava até hoje sem net, percebam; estava de mudança, e só agora vim arranjar meu pc completo e um modem com uma net de 1mb, pra continuar a matéria.

Mas agora mesmo farei a parte II.

Matéria nova: postada

2011-05-13T20:13:00.001-03:00

Como prometido a algumas horas atrás, fiz a primeira parte da matéria acerca do Movimento Personalizado de Fast Loops. Quem quiser dar uma conferida, segue link:
http://mmfmakers.blogspot.com/2011/05/movimento-personalizado-de-fast-loops_13.html

Flw.

Movimento Personalizado de Fast Loops - Parte 1

2011-05-13T16:41:00.084-03:00

Parte 1: Movimento de Oito Direções

Introdução:
Nesta aula, vamos falar sobre uma forma especial de se fazer um Movimento Personalizado: utilizando Fast Loops. Apesar de ser uma das últimas aulas do nível intermediário, não significa realmente que seja difícil. Não, não é. Mas as fórmulas usadas (sim, vamos usar fórmulas) são um pouco chatas de se entender, e você precisará captar a essência dela. O que isso significa? Significa que você precisa realmente entender para o quê ela serve, a fim de poder usá-la novamente depois, sem ter de recorrer à anotações.

Até agora, já fizemos isso com fórmulas simples (X("Active)+2 etc). Já trabalhamos bastante expressões no MMF2. Não acho que vocês terão problemas para fazer esse movimento.

O método foi desenvolvido por David Newton, e disponibilizado no site oficial da ClickTeam. Deixo aqui meus sinceros agradecimentos a ele. Agradeço também ao Hazael, que me falou sobre esse tipo movimento.

Começaremos com um modelo em 8 direções, a fim de entender a base dele. Então, partiremos, na aula seguinte, para a movimentação em plataforma propriamente dita. O que não significa que você não possa utilizá-lo para um jogo de RPG.

Preparando o Terreno:
Durante esta aula, iremos precisar dos seguintes objetos: um Active Object totalmente preenchido por uma única cor (de qualquer tamanho, mas vamos adotar, para essa aula, 32x32), o qual chamaremos de MC, e atuará como uma Máscara de Colisão (ou Collision Mask, explicarei daqui a pouco); alguns obstáculos, posicionados aleatoriamente no Frame, para testar as colisões.

Frame com alguns obstáculos e um Active Object totalmente preenchido por uma única cor.

Vá nas propriedades do MC (o Active totalmente preenchido com uma única cor), e vá para a aba Values. Aqui, iremos nomear os dois primeiros Alterable Values, por questão de organização. Clique duas vezes no botão New, embaixo de Alterable Values. Dê um duplo clique sobre Alterable Value A, e renomeie para MovX, depois, dando OK. Faça o mesmo com o Alterable Value B, mas, dessa vez, renomeie para MovY.

Variáveis nomeadas.

A) Máscara de Colisão:
Ainda há pouco, falei para vocês sobre uma tal Máscara de Colisão, certo? Bem, uma Máscara de Colisão é um objeto (Active, no caso de MMF2) responsável por detectar onde o personagem à ela relativo deve colidir.

O que isso significa? Significa que não programaremos o movimento do personagem em si, e sim, de um Active totalmente preenchido por uma única cor. Daí, usaremos um outro objeto para as animações do personagem, programaremos as animações e faremos com que sempre fique no mesmo lugar da Máscara, ao mesmo tempo que a deixamos invisível. Ou seja, o personagem controlado será formado por dois objetos: a Máscara de Colisão e as Animações.

Com isso, concluímos que, quando formos fazer um jogo pra valer, a Máscara de Colisão deve cobrir a área em que o personagem deve colidir.

Dois exemplos de Máscaras de Colisão. Perceba que no exemplo da direita, a Máscara de Colisão do Zero não o cobre totalmente.

Tenha em mente que o tamanho das animações mudam; o da Máscara de Colisão, não. Sendo assim, pode ser que, se você tomar como base a animação principal (personagem parado), pode ser que, em algumas animações, talvez pareça que ele "atravesse" um pouco os obstáculos. E, dependendo da forma com que você posiciona as animações, isso também pode acontecer.

Por isso, fique ligado no HotSpot. Lembre-se que o posicionamento leva em consideração o HotSpot; ou seja, ao colocar um Active 2 sempre se posicionando na posição 0 em relação ao X, e 0 em relação ao Y, ambos em relação a um Active 1, isso significa que o lugar onde está o HotSpot do Active 2 ficará em cima do lugar onde está o HotSpot do Active 1. Ou seja, se você colocar o Hotspot da Máscara de Colisão na extremidade inferior central, deverá colocar o HotSpot das animações no pé do personagem, sempre. A não ser que você queria que o personagem fique enterrado no chão até o peitoral. Ou flutue, se colocar muito embaixo.

Particularmente, acho que isso dá um efeito legal no jogo (obviamente, apenas um pouco, não faço com que o personagem fique enterrado até o peitoral como acabei de falar), então, muitas vezes, faço intencionalmente.

Basicamente, a Máscara de Colisão no Movimento Personalizado de Fast Loops é o que seriam os Detectores de Colisão no Movimento Personalizado Tradicional.

Programando o Movimento:
Chegou a hora! Vamos programá-lo com aceleração mesmo. No ponto onde estamos, isso não será problema. Considerarei que todos aqui tenham uma versão antiga do MMF2. Entretanto, que não chegue a ser arcaica; pelo menos tenha Fast Loops. Apesar de não ter certeza, ouvi dizer que em versões muito antigas, o MMF2 não tinha Fast Loops embutido nele. Acredito que a build 248 do programa sirva.

O nosso movimento é dividido tanto na movimentação horizonta, quanto na vertical, em duas partes: Manipulação de Variáveis e Loops de Movimentação. Acho que isso é tudo. Agora, vamos aos eventos!

A) Movimento Horizontal:
Aa) Manipulação de Variáveis:

Como o movimento é horizontal, iremos definir valores para o eixo X. O eixo X será definido através da variável MovX. Logo, aqui, manipularemos essa variável. Façamos, então, a aceleração:

Repeat while ("Player 1") Moved right
X Repeat while ("Player 1") Moved left
MovX of ("MC") < 3
Set MovX to MovX("MC")+0.25

Repeat while ("Player 1") Moved left
X Repeat while ("Player 1") Moved right
MovX of ("MC") > -3
Set MovX to MovX("MC")-0.25

Aceleração. No ponto onde estamos, você já deve saber interpretar tal evento corretamente. Se não souber, é bom dar uma lida de novo nas aulas passadas. Mas vou dar uma colher de chá, e explicar cada evento.

No primeiro, se o jogador 1 estiver pressionando para a direita, não estiver pressionando para a esquerda (a fim de evitar conflitos ao apertar as duas teclas simultâneamente) e a variável for menor que 3, adicionaremos 0.25 à variável, fazendo com que ela vá atingindo o valor da velocidade do nosso movimento gradualmente. O valor 0.25 é a aceleração (variação de velocidade, ou seja, quanto a velocidade irá variar no decorrer do tempo). Isso significa que, quanto menor o valor, mais o móvel vai demorar para atingir a velocidade 3. Você pode retardar essa meta também adicionando uma condição Every, e especificando uma certa quantidade de centésimos de segundo. Nesse caso, você estará apenas fazendo com que a velocidade varie de forma mais lenta. Mas o resultado será o mesmo.

No segundo evento, a mesma coisa, só que para a esquerda. Perceba que, aqui, subtraíremos 0.25 da variável se o jogador estiver pressionando para a esquerda, e o valor dela for MAIOR que -3. Eixo X negativo = movimento para a esquerda, como já vimos inúmeras vezes.

Aliás, lembra que eu disse que iria tomar medidas para que os com a versão mais antiga de MMF2 não fossem prejudicados? Pois é. Vocês devem ter notado (se não notaram, ou são muito desatentos, ou realmente não interpretaram a formula corretamente, e acredito que, nesse segundo caso, não estejam preparados para ver esse movimento) que eu adicionei e subtraí os valores da variável com a ação Set. Mais uma vez, me disseram que em versões mais antigas do MMF2, não existiam as funções Add e Subtract. Mas para quem tem o MMF2 com essas funções, podem usar, não há diferença alguma.

Agora, vamos para a desaceleração:

X Repeat while ("Jogador 1") Moved right
X Repeat while ("Jogador 1") Moved left
MovX of ("MC") > 0
Set MovX to MovX("MC")-0.25

X Repeat while ("Jogador 1") Moved right
X Repeat while ("Jogador 1") Moved left
MovX of ("MC") < 0
Set MovX to MovX("MC")+0.25

Existe outra forma, mais rápida, de se fazer desaceleração, mas por ser mais complexa (usa uma fórmula que não é difícil, mas é chata pra entender) e obrigar o programador a utilizar o mesmo valor para a desaceleração dos dois lados (o que é o normal, mas talvez, por circunstâncias especiais, o jogo precise que o personagem desacelere com velocidades diferentes para cada lado), eu preferi utilizar a forma padrão. Quem quiser dar uma olhada, adicionei dentro de um grupo desativado no exemplo. A ideia é bem simples, vocês vão entender só de olhar.

Mas voltando ao assunto... no primeiro caso, se o jogador não estiver pressionando para a direita, nem para a esquerda, e a variável estiver maior que 0 (ou seja, andando para a direita), iremos diminuir 0.25 da variável gradualmente, fazendo com que ela volte a ser 0, e o móvel fique em repouso.

No segundo caso, é o oposto: se o jogador não estiver pressionando para a direita, nem para a esquerda, e a variável estiver MENOR que 0 (ou seja, andando para a esquerda), iremos ADICIONAR 0.25 da variável gradualmente, fazendo com que ela volte a ser 0, e, então, o móvel fique em repouso.

Ab) Loops de Movimentação:
Terminamos de manipular as variáveis do eixo X. Agora, é que a coisa começa a esquentar. Faremos o personagem movimentar-se através de loops, de acordo com o valor da variável. Vamos fazer os eventos, e eu explico.

MovX of ("MC") <> 0
Start loop "MovX" Abs(MovX("MC"))

Aqui, iniciaremos um loop, chamado MovX (o nome do loop deve ficar entre aspas no MMF2), e ele será repetido na mesma quantidade do módulo da variável. A função Abs() faz com que o programa utilize o módulo do valor expresso entre os parênteses (no caso, a variável). Isso porque um número de repetições não pode ser negativo. xD

Por que iniciamos um loop? Você entenderá agora. Faça o seguinte evento:

On loop "MovX"
(MC) Set X position to X( "MC" )+(MovX( "MC" )/Abs(MovX( "MC" )))

Ou seja, enquanto o loop estiver sendo executado, a posição X da Máscara de Colisão será mudada para o valor expresso pela fórmula. Antes de eu explicar o que ela faz, tentem interpretá-la sozinhos. Então, prossiga a leitura. Essa fórmula faz com que ele adicione +1 ou -1 à posição X atual da Máscara de Colisão, dependendo do valor atual da variável. Veja bem, ele divide o valor da variável pelo seu módulo. Assim obtemos 1, de acordo com o sinal da variável.
Exemplos:
• Se a variável for 2: (+2)/(+2) = +1.
• Se a variável for -2: (-2)/(+2) = -1.
Dessa forma, ele descobre se a variável deve fazer o personagem andar para a direita ou para a esquerda, e o movimenta de acordo com ela.

O movimento em si já está pronto. Você pode testar seu projeto, e ver que a Máscara de Colisão já se move na horizontal. Mas ela ainda não colide... vamos, então, para o evento das colisões:

On loop "MovX"
("MC") is overlapping a backdrop
(MC) Set X position to X( "MC" )+((MovX( "MC" )/Abs(MovX( "MC" )))*(-1))
Set MovX to 0
Stop loop "MovX"

Interpretemos o evento, então. Se enquanto o loop MovX estiver sendo executado, a Máscara de Colisão estiver sobrepondo um obstáculo, a posição dela será definida para o valor expresso pela fórmula, a variável será definida para 0, e o loop será interrompido. Para os mais atentos, a fórmula é extremamente parecida com a do evento anterior. Ela expressa nada mais, nada menos, do que o oposto da divisão entre o valor da variável e seu módulo. Usem a cabeça... se essa divisão expressa o valor que deve ser adicionado à posição X para que o corpo se mova no sentido correto, o que seu oposto expressa...? Isso mesmo, o sentido oposto! Ou seja, enquanto o móvel estiver tentando se mover contra um obstáculo, ele irá anular o evento anterior, entrando em repouso.

Por exemplo, considere que a variável fosse +3. Sabemos que conforme o loop vai se repetindo (no caso, 3 vezes, pois o módulo de +3 é 3), vai sendo adicionado +1 à posição do móvel (pois programamos para que a posição fosse adicionada de acordo com o sinal da variável, e, nesse caso, a variável é positiva). Enquanto este móvel estiver colidindo com um obstáculo, ele irá adicionar à posição o oposto do que programamos anteriormente. Ou seja, -1. Agora, calculem: (+1)+(-1) => 1-1 = 0. O corpo entra em repouso.

Estas três ações juntas são responsáveis pela colisão. A principal é a de mudar a posição para o valor expresso pela fórmula, mas definir a variável para 0 e interromper o loop, evita que o personagem "trave" ao colidir.

Teste seu projeto agora. Se você fez tudo certo, ele deve estar colidindo.

B) Movimento Vertical:
É a mesma lógica dos movimentos horizontais. Mas lembre-se que, aqui, a trajetória é orientada para baixo, diferentemente de um Plano Cartesiano matemático normal. Ou seja, o eixo Y é invertido: valores positivos fazem o corpo ir para baixo, e, valores negativos, ir para cima.

Trabalharemos, agora, com o eixo Y; consequentemente, com a variável MovY.

Ba) Manipulação de Variáveis:
Vamos fazer a aceleração:

Repeat while ("Jogador 1") Moved down
X Repeat while ("Jogador 1") Moved top
MovY of ("MC") < 3
Set MovY to MovY("MC")+0.25

Repeat while ("Jogador 1") Moved top
X Repeat while ("Jogador 1") Moved down
MovY of ("MC") > -3
Set MovY to MovY("MC")-0.25

Não vou me demorar muito aqui. Mas perceba que no primeiro, para descer, verificamos se a variável é menor que 3, e somamos, pois como eu já disse, a trajetória é orientada para baixo. E no segundo, verificamos se a variável é maior que -3, e diminuímos.

Desaceleração:

X Repeat while ("Jogador 1") Moved top
X Repeat while ("Jogador 1") Moved down
("MC") MovY > 0
Set MovY to MovY("MC")-0.25

X Repeat while ("Jogador 1") Moved top
X Repeat while ("Jogador 1") Moved down
("MC") MovY < 0
Set MovY to MovY("MC")+0.25

Na desaceleração, fazemos com que a variável volte gradualmente a 0, de acordo com o sentido da trajetória (para baixo se a variável for positiva e para cima se for negativa), caso o jogador não esteja pressionando nem para cima nem para baixo.

Bb) Loops de Movimentação:
Vamos fazer os loops:

MovY of ("MC") <> 0
Start loop "MovY" Abs(MovY("MC"))

Se a variável for diferente de 0, o loop se iniciará, repetindo-se na mesma quantidade do módulo da variável.

Agora, movimentação:

On loop "MovY"
Set Y position to Y( "MC" )+(MovY( "MC" )/Abs(MovY( "MC" )))

Enquanto o loop estiver sendo executado, ele irá mover a Máscara de Colisão de acordo com o sentido proposto pela variável MovY.

Por fim, colisões do Movimento Vertical:

On loop "MovY"
("MC") is overlapping a backdrop
Set Y position to Y( "MC" )+((MovY( "MC" )/Abs(MovY( "MC" )))*(-1))
Set MovY to 0
Stop loop "MovY"

--//--

E... pronto! Fizemos um Movimento Personalizado de Fast Loops, de oito direções! O movimento é perfeito; pelo menos, eu não encontrei bug algum. Com as minhas explicações colossais, e até desnecessárias, o tutorial ficou bem extenso. Mas, na verdade, esse tipo de movimento é mais curto que o tradicional. E, depois que você pega o jeito, fica bem fácil; e bem mais rápido. Na próxima aula, veremos o movimento de plataforma, que é ainda mais rápido que este.

Caso tenha alguma dúvida, ou não conseguiu fazer algo corretamente, dê uma olhada neste exemplo.

Bom aprendizado. ;)
Flw.

Eaí

2011-05-13T16:33:00.002-03:00

Eaí poucos leitores remanescentes da MMFM, tudo na paz?

Passando aqui pra dizer que irei dar uma revisada nos tutos de MMF2. Então, irei escrever um pouco acerca da parte intermediária. Quero iniciar as matérias sobre Movimento Customizado de Fast Loops. Se der, peço pro Matheus fazer o do tradicional; não o domino muito bem, sempre tem um bug aqui ou ali no meu tradicional (posicionamento de detectores imperfeitos, programação ruim, não sei dizer).

Mas relaxem: o Mov. de Fast Loops, apesar de mais "complexo" (sim, ele começa a usar umas fórmulas chatinhas) é mais rápido, mais fácil (se você o dominar) e mais funcional que o tradicional.

Enfim, é isso aí. Não se preocupem, dessa vez irei cumprir minha palavra ;).

Fenômeno de Chuva

2011-04-21T15:44:00.001-03:00

Gente, se querem saber como se faz chover no MMF2, leia com atenção.
Então vamos lá:

1)Crie um Active Object com o desenho de um pingo de chuva qualquer e um gramado ou um chão.
2)Para fazer chover crie um objeto de pingo e a parte Vertical precisamos de programar a posição Horizontal, para mudar para vertical presisamos de Random(640) e do "Frame Width" que é como o "Frame Height" que retorna para posição vertical.
Crie um objeto:

Depois de criado faça o evento do "Frame Width":

Copíe o código:

Código:

Random(Frame Width+(Frame Width/2))

Depois disto faça este outro evento de movimento:

Para colidir e desaparecer no Background faça os eventos de colisão no Backdrop e bote"Destroy".
Ver no Tópico de Funções de Backdrop.
Se si confundirem com este tópico ou de como fazer mande um email pra mim:sonicbieel@gmail.com

Pronto gurisada e gentalha.
Ta pronto.
Se não souberem disso ou se não deu certo mande um email viu.

Gabriel

2011-04-21T15:36:00.000-03:00

Me apresento aqui. Eu sou do fórum. Mas não posso cuidar daqui como colunista muito tempo. Tenho escola e um curso. Tem bastante trabalho pra fazer e não tenho muito tempo, mas as vezes arrumo um tempinho. Não significa que vou sair do Blog, só não tenho tempo pra postar. Também não tenho muita matéria pra postar. Fora disso, vou fazer o máximo aqui! Espero que um tempo eu tenha ajudado muito. Até makers!

Extensões.

2011-04-03T11:03:00.001-03:00

Super Pacote de Extensões do MMF2.

Acredito que tenha 368 extensões.

Download

Antes que eu esqueça, versão 250 +

Fui.

Sprite - Todas as Fontes do Sonic.

2011-03-08T19:22:00.001-03:00

Olá como estão vocês?

Bem eu sei que não apareço muito, mas enfim tem a lista de fontes bacanas usadas em todos os jogos do Sonic.

Acho que vale a pena conferir :D

Acesse o Link :D

Fui.

PS: Fonte embutida no Link.

Desculpem aí!

2011-01-20T01:04:00.002-02:00

Pessoal, desculpem aí por não ter postado nada ultimamente!
Nem mesmo eu estou pegando em MMF esses tempos... Dizer que tá meio parado é pouco =p
Bom, essa semana, ainda sai outra matéria. Espero. Enfim, fiquem ligados ;D

Behaviors, Qualifiers e Global Events

2010-12-27T19:00:00.000-02:00

Acabei de fazer uma nova matéria! Podem conferir na seção de tutoriais de MMF2 =D

Behaviors, Qualifiers e Global Events

2010-12-27T17:49:00.023-02:00

Introdução:
Hoje, irei ensinar sobre três funções, não digo úteis, mas que agilizam bastante um trabalho: Behaviors, Qualifiers e Global Events.

Behaviors são eventos internos de um Active Object (não apenas Active Objects, mas eles principalmente). Isso aí, os eventos ficam dentro dele! Se, por exemplo, você deletá-lo, os eventos somem juntos... Mas, afinal, em que isso vai ajudar? Vamos supor que você programe um Movimento Personalizado dentro dele... daí, é só ficar copiando ele e os colisores (ou Collision Mask) para o próximo Frame. CLAROOO, ainda estamos começando a usar MMF2, e ainda não sabemos fazer um Movimento Personalizado! Entretanto, mas pra frente, isso vai te ajudar pra caramba! A única desvantagem desse recurso, ao meu ver, é que não podemos ativar ou desativar Grupos de Eventos em um Behavior (coloco no singular porque um mesmo Active Object pode ter vários Behaviors, cada um com seus eventos... isso serve para organização mesmo). Mas nada é perfeito...

Qualifiers são grupos de objetos. Servem para que você não precise repetir um mesmo evento para mil objetos diferentes. Por exemplo... você faz um evento para matar o inimigo pulando na cabeça dele. Em vez de fazer eventos para cada inimigo, você simplesmente põe os inimigos em determinado Qualifier e faz os eventos com esse Qualifier. O único problema dos Qualifiers - e que nem é tão grave - é que eles já existem, e são limitados. O que significa que você não pode criar mil Qualifiers, nem colocar o nome que quiser neles. Você vai ter de se contentar com os que já tem... e colocar os "inimigos" num grupo com um nome nada a ver ("Doors", por exemplo, que singifica "Portas").

Global Events, para finalizar, são eventos que valem para TODOS os Frames, sem exceção. Serve para colocar um evento de, por exemplo, ao apertar ESC, sair do jogo. Preciso explicar mais alguma coisa?

Behaviors:
Para acessar os Behaviors, clique no objeto para ver suas propriedades. Então, vá na aba Events (aquela, com o mesmo símbolo do Event Editor). Você poderá gerenciar seus Behaviors abaixo da palavra azul de mesmo nome na janela das propriedades do objeto.

• Dando um duplo-clique sobre o nome do Behavior, você pode renomeá-lo.
• Clicando nas reticências de um Behavior X, irá aparecer um botão chamado Edit. Clicando nesse botão, você poderá programar os eventos daquele Behavior.
• Clicando no botão New, você pode criar um novo Behavior.

Não se tem muito o que explicar sobre essa função. Sabendo essas 4 coisas, você já sabe tudo sobre ela.

Qualifiers:
Você gerencia os Qualifiers de um objeto numa determinada janela. Para acessá-la, vá novamente na aba Events, nas propriedades do objeto, e clique no espaço em branco ao lado da palavra Qualifier(s). Um botão Edit, então, irá aparecer. Clique nele e a janela se abrirá.

• No botão Add, você adiciona um Qualifier ao objeto. Ou seja, você o inclui em um grupo.

(Clicando em OK, você adiciona o Qualifier ao objeto. Clicando em Cancel, você cancela a operação)

• No botão Delete, você deleta o Qualifier selecionado. Ou seja, você retira o objeto daquele grupo.
• Em OK, você salva as alterações feitas.
• Em Cancel, você cancela as alterações feitas.

Note que, quando você adiciona um Qualifier a um objeto, o espaço branco do lado da palavra Qualifier(s) nas propriedades deste objeto, deixa de ser branco, e passa a ter o símbolo dos grupos os quais o objeto participa.

Quando você adiciona um Qualifier a um objeto, esse Qualifier passa a aparecer no Event Editor. Daí, é só programar com ele, em vez de programar mil vezes a mesma coisa para objetos diferentes!

Global Events:
Essa é, com certeza, a parte mais besta da matéria. Como já expliquei, Global Events são eventos que valem para TODOS os frames. Para programar eventos nos Global Events, simplesmente vá nas propriedades da aplicação, entre, novamente, na aba Events, e clique no botão Edit do lado de Global Events. Pronto, você está na tela de programação dos Global Events!

Finalizando:
Bom, como vocês podem ver, são três funções super simples, que vão poupar muita dor de cabeça!
Isso é tudo, pessoal! (Pernalonga)

Flw.

Béqui

2010-12-04T21:43:00.001-02:00

Olá meus caros makers,
Estou de volta, e de férias! Na verdade, já estou com o PC há um tempo. Hoje tive um sonho bem chato... As aulas tinham voltado, pouco depois de eu entrar de férias o.O

Bom, logo logo estarei escrevendo novos tutos. Só preciso relembrar como mecher no MMF ._.

Flw!

Avoy - Quero dizer Sprites...

2010-11-21T16:40:00.001-02:00

Olá, a quanto tempo que não venho por aqui também... Vou tentar aparecer mais certo xD

Trago Sprites de World of Illusion starring Mickey Mouse and Donald Duck - Donald Duck, espero que gostem xD

http://www.spriters-resource.com/genesis/woi/sheet/22981

Créditos a http://www.spriters-resource.com/

Sinal de Vida

2010-11-17T15:58:00.002-02:00

Eaí makers o/
Estou acessando o PC por meio da LAN, e vim dar uma notícia que, ao meu ver, é boa... as férias estão chegando eu meu pai já mandou o PC pro conserto. Agora, ele só vai me devolver o PC depois da última prova, de Geografia e Química (dia 23 de novembro). Não pretendo fazer um big update ou algo do tipo, mas pretendo terminar o nível básico, e, se sobrar tempo, iniciar o intermediário.

Mas aviso logo que não vou me dedicar 100% ao blog. Tenho outras coisas pra fazer; não tem como ficar 24H no PC. Pelo contrário, não pretendo usar muito.

É isso.
Flw ae o/

Desculpas

2010-10-08T23:56:00.000-03:00

Olá. Bom, gostaria de pedir desculpas pela minha ausência no blog; é que meu computador deu problema, e meu pai acha que sou um vagabundo, então disse que só vai mandar pro conserto nas férias (pior que nem sou, tiro 7,5; 8,0; vez ou outra um 6, mas, mais frequentemente, 8 mesmo).

Então, não vou postar nesse treco durante um tempo.
É isso.
Tchau.

Nova matéria!

2010-08-27T22:45:00.002-03:00

Então, terminei outra matéria o/

Mas acabei adicionando outra no planejamento t-t

É isso! Amanhã e depois de amanhã, ashoq trago mais matérias. Pra compensar as três semanas sem matéria hehe.

Falow o/

Alterable Strings e Global Strings

2010-08-27T22:06:00.007-03:00

Introdução
Alterable Strings são uma espécie de variáveis internas de um Active Object que armazenam textos, e não valores. O uso é bem parecido com o dos Alterable Values, só tendo essa diferença. Eu posso, por exemplo, criar uma placa, e, nela, mandar exibir o texto de uma de suas Alterable String. Então, dependendo do que eu fizesse, o texto da placa (ou seja, da Alterable String) mudaria: se o número de moedas for 0, a placa exibiria o texto Noob. Já se o número de moedas fosse maior que 0, a placa exibir o texto Não-Noob. Diferentemente dos Alterable Values que 26 são nomeados, apenas 10 Alterable Strings são nomeadas. As outras variáveis de texto são representadas com números, da mesma forma que os Alterable Values.

Global Strings estão para Alterable Strings assim como Global Values estão para Alterable Values. Global Strings nada mais são do que variáveis de texto globais, que valem para a aplicação inteira. Quanto à nomenclatura, é a mesma coisa dos Alterable Strings, exceto pelo fato de que 26 são nomeadas, e não apenas 10. Fácil, não é?

Bem, na verdade, eu não consigo imaginar um uso realmente útil para esses dois recursos. Mas como eles existem, irei explicá-los.

Alterable Strings
Então, como já expliquei, Alterable Strings são variáveis de texto. Agora, vamos aprender a utilizar as condições e eventos desse recurso.

Condições:
Para ver as condições relacionadas à esse recurso, dê um duplo clique sobre o Active Object que contém as variáveis de texto e vá no menu Alterable Values.

Compare to one of the alterable strings - Essa condição compara o valor de uma variável de texto. Como aqui não são valores, mas sim textos, a coisa muda um pouco. Em Choose Value, você ainda escolhe a variável a ser comparada. Já em Choose comparison method, a coisa muda um pouco. Aqui, Equal (Igual) significa se o texto da variável for igual à expressão que será comparada a ela. Exemplo: Se o texto da Alterable String A for igual a qualquercoisa... puff, acontece algo. Different (Diferente), é o contrário: significa se o texto da variável for diferente da expressão que será comparada a ela. Ou seja... Se o texto da Alterable String A não for qualquercoisa, for outro (como outracoisa ou qualqueroutracoisa, por exemplo), algo irá acontecer. Até aí, nenhum mistério né? Mas OK. Agora que as coisas começam a mudar. O Lower or equal (Menor ou igual) já se refere ao número de caracteres da expressão que será comparada, no caso, se o número de caracteres for menor. Por exemplo: se o número de caracteres do texto da Alterable String A for menor ou igual ao número de caracteres da expressão... algo vai acontecer. Lower (Menor), quase a mesma coisa, só que, nesse caso, igual não entra, só se o número de caracteres da variável de texto for menor que o da expressão mesmo. E Greater or equal (Maior ou igual) seria justamente o contrário da Lower or equal, isto é, se o número de caracteres do texto da variável for MAIOR ou igual ao da expressão. E Greater, também quase a mesma coisa, só que não contando com o mesmo número de caracteres, ou seja, só se o número de caracteres da variável de texto for maior do que o da expressão, igual não conta. E por fim, em Enter Expression é onde fica a expressão a qual a variável será comparada. Caso seja um texto fixo (como qualquercoisa, por exemplo), deve ficar entre aspas. Já se for "pegar" essa expressão de algum objeto (como uma EditBox), você pode, e deve, não utilizar as aspas.

Ações:
As ações relacionadas a Alterable Strings se encontram no menu Alterable Strings (duh?) do Active Object que contém as variáveis de texto.

Set - Define o texto da variável para um de sua escolha. Usuários com certa experiência no MMF2 podem transformar isso até mesmo numa espécie de "Add" ou "Subtract" de textos. Mas não se preocupe com isso agora.

E essas são as condições e ações das Alterable Strings.

Global Strings
Global Strings, como expliquei no início da matéria, são variáveis de texto globais, isto é, que servem para toda a aplicação. Agora, vamos ver como utilizá-las.

Condições:
Para acessar as condições relacionadas a Global Strings, dê um duplo clique sobre o "objeto" Special (dois computadores).

Compare to a global string - A mesma coisa do Compare to one of alterable value, só que para variáveis de texto globais.

Ações:
As ações relacionadas a Global Strings se encontram nas ações do "objeto" Special (dois computadores)

Set global string - Define o texto de uma variável global para um de sua escolha. Assim como a dos Alterable Strings, com certa experiência é possível fazer uma espécie de "Add" ou "Subtract" através do Set.

Bom povo, e é isso!
Espero que tenham entendido!

Falow o/

Maple Story

2010-08-24T21:39:00.002-03:00

Vamos com Sprites de Maple Story O/

Green Robo

http://www.spriters-resource.com/pc_computer/maplestory/greenrobo.png

King Cro

http://www.spriters-resource.com/pc_computer/maplestory/kingcro.png

Robot

http://www.spriters-resource.com/pc_computer/maplestory/robot.png

Samiho

http://www.spriters-resource.com/pc_computer/maplestory/samiho.png

Como são muitos irei postando aos poucos.

Créditos a Spriters-Resource

Matéria?

2010-08-18T18:41:00.000-03:00

Desculpem, semana passada não teve matéria.
Essa terá 2 ^^

Nova Extensão - Lacewing

2010-08-17T23:59:00.000-03:00

Uma extensão parecida com MOOClick, MooGame e Afins, permite conexão para Jogos Online...

Lacewing

Em breve tutoriais sobre isso...

Chuck Rock - Sprites

2010-08-17T23:21:00.000-03:00

E agora vamos com Chuck Rock!!

http://www.spriters-resource.com/genesis/chuckrock/chuck.png
http://www.panelmonkey.org/gs/chuckrock.gif

New Super Mario Bros - Sprites

2010-08-17T21:50:00.000-03:00

E aí pessoas, lembram de mim?

Então, trago Sprites de New Super Mario Bros.

Espero que gostem ^^

New Super Mario Bros - Sprites

Matéria da Semana

2010-08-07T17:09:00.001-03:00

Postada matéria da semana. Fala sobre Alterable Values e Global Values. Podem conferir na lista de tutoriais de MMF2.

Próxima Matéria

2010-07-31T16:46:00.000-03:00

Quanto vão sair mais matérias? Sinceramente, não sei dizer x.x'. Amanhã tentarei terminar uma matéria sobre Alterable Values que comecei a fazer, mas não sei se vou mesmo terminá-la amanhã. Não vou dizer que é por falta de tempo ou algo assim, é realmente preguiça. Quem nunca sentiu? O pior é que segunda, minhas aulas volta, e só poderei entrar nos finais de semana. Bem, tentarei escrever uma matéria por fim de semana, mas não prometo nada...

É isso.
Falow o/

Novo Layout o/

2010-07-30T01:10:00.000-03:00

Finalmente fiz alguma coisa pelo blog, depois de tanto tempo e.e! Fiz um novo layout para o blog. Demorou algum tempo (apesar de que eu dei pausas de um dia mesmo xD) mas saiu. E aí, o que acharam? Melhor que outro pelo menos está né?

Ah sim, a propósito, terminei a matéria do FireSoul sobre MovCustom TileBased. Leiam direitinho! Espero que entendam tudo o/

Bom aprendizado!

Alterable Values e Global Values

2010-07-29T14:03:00.003-03:00

Introdução
No MMF2, uma coisa que utilizamos bastante são Alterable Values (Valores Alteráveis, ou variáveis). Alterable Values são variáveis internas de um Active Object. São como Counters, mas não podemos delimitar os limites via Frame Editor, apenas por eventos. Ao contrário do que muitos pensam, existem infinitos Alterable Values, mas só os do 01 ao 26 são nomeados, e, esses, recebem uma determinada letra do alfabeto para indentificá-los (Alterable Value A, Alterable Value B etc). Você pode e deve mudar esses nomes, para não se confundir. As outras variáveis são indentificados por números, e não podem receber um nome especial. Quando o Frame recomeça, as variáveis retornam aos seus valores iniciais.

Em contrapartida, Global Values são variáveis globais, isto é, funcionam para todo o jogo. Diferentemente dos Alterable Values, não importa se um Frame muda ou reinicia, o valor só mudara se você programar para que ele mude. Pode ser utilizado para diversos fins, como gravar a Posição Atual de um jogador ou até mesmo criar um Sistema Monetário! Assim como os Alterable Values, existem infinitos, mas só 26 são nomeados, também com letras do alfabeto (Global Value A, Global Value B etc). E, assim como os Alterable Values, você pode e deve mudar esses nomes, a fim de não se confundir.

Lembra das aulas chatas de Matemática, que você dormia o tempo todo? Espero que não, porque agora é hora de você colocar em prática. Para mexer com variáveis é bom ter certo conhecimento em Polinômios. Então, vamos a matéria!

Alterable Values
Como já expliquei, Alterable Values são variáveis internas de um Active Object. Conhecendo-os e sabendo utilizá-los você poderá fazer grandes coisas! E vou ajudar vocês a conhecê-los. O resto, é com o cérebro de vocês ^^.

Condições:
Para ver as condições relacionadas aos Alterable Values, dê um duplo clique sobre o Active Object que os contém, e vá no menu Alterable Values.

Compare to one of the alterable values - É a única condição relacionada de fato aos Alterable Values no menu Alterable Values hehe. Bem, ela compara o valor de um Alterable Value. Ainda que seja só uma, tem tudo o que você vai precisar. Em Choose Value, você seleciona a variável que se quer comparar. Em Choose comparison method, você seleciona o que quer comparar. Exemplo: A variável está IGUAL ao valor tal? Ou então, A variável está DIFERENTE ao valor tal? As opções são: Equal (Igual), Different (Diferente), Lower or equal (Menor ou igual), Lower (Menor), Greater or equal (Maior ou igual) e Greater (Maior). E em Enter expression é a expressão a qual a variável será comparada. Ela não precisa ser necessariamente um número: pode ser também uma expressão, o valor de algum outro objeto. Então, depois de mexer em tudo, aqui vai um exemplo: se em Choose Value, coloco o Alterable Value E, em Choose comparison method, coloco menor e em Enter expression coloco 10, a condição será a seguinte: Se o Alterable Value E for menor do que 10... e então, a ação.

Ações:
As ações relacionadas a Alterable Values se encontram no menu Alterable Values do Active Object que contém as variáveis.

Set - Define o valor de uma variável para um valor de sua escolha.
Add to - Adiciona um determinado valor a uma variável.
Subtract from - Subtrai um determinado valor de uma variável.
Spread value - Hehe, até hoje não entendi o que seria essa função. Matheus, Ails, vários já me explicaram, mas cadê que eu entendi? Desculpem x.x. Quando descobrir, coloco aqui.

E é isso! Essas são as condições e ações de Alterable Values!

Global Values
As condições e ações são realmente bem parecidas com a dos Alterable Values. Mas vamos lá.

Condições:
Para ver as condições relacionadas aos Global Values, dê um duplo clique sobre o "objeto" Special (dois computadores).

Compare to a global value - Compara o valor de um Global Value. A estrutura é idêntica a dos Alterable Values (fora o fato de serem Global Values, não Alterable Values), por isso, não irei explicar.

Ações:
As ações relacionadas a Global Values se encontram no menu "Change a global value" do objeto Special.

Set - Define o valor de uma variável global para um valor de sua escolha.
Add to - Adiciona um valor a uma variável global
Subtract from - Subtrai um valor de uma variável global

E pronto! Essas são as condições e ações de Global Values! Agora é só usar seu cérebro e combiná-las com outras ações e condições, fazendo coisas maneiras no MMF2!
Falow o/

Movimento Custom TileBased - Parte II: Colisões

2010-07-28T23:39:00.004-03:00

Movimento Custom TileBased
Parte II: Colisões

Introdução:
Olá pessoal o/. O FireSoul acabou não postando a segunda parte do tutorial ¬¬. Brincadeira, já agradeço a ele por ter feito a parte 1 ^^. Então, eu mesmo vou postar! Ayuupi!! Quêê?! Como assim não me querem como professor? Dane-se, eu que vou ensinar assim mesmo e.e.

Nessa parte do tutorial vamos aprender a fazer colisões. E depois disso, você já vai poder estar criando seus jogos de RPG! Tá bom, nem tanto, um jogo de RPG não é só isso hehe. Mas já é um começo não é? Então, bora parar de faladeira e ir ao que interessa o/

Criando os Detectores:
Antes de programar, temos de criar os detectores de colisão. É eles que vão... err... é algo bem complicado... como posso explicar? Detectar as colisões! Tcharaaaam! Cada detector vai precisar ter a mesma largura e altura dos tiles, e ser preenchido com uma cor diferente. Além disso, é importante nomear cada um, para saber qual é qual, porque saber só pelas cores é difícil o.O. Se você não sabe o que é um detector... O QUE VOCÊ TÁ FAZENDO AQUI?! VOLTA PRO NÍVEL BÁSICO CARAMBA!

Ajuste o HotSpot do Personagem para bem no meio, tanto na horizontal quanto na vertical (use QuickMove, é bem mais prático). O Hotspot do Detector Cima deve ficar em baixo (em relação à vertical) e no meio (em relação à horizontal). O do Detector Baixo deve ficar em cima (em relação à vertical) e no meio (em relação à horizontal). O do Detector Direito tem de ficar no meio (em relação à vertical) e na parte esquerda (em relação à horizontal). E o do Detector Esquerdo, por fim, tem de ficar no meio (em relação à vertical) e na parte direita (em relação à horizontal).

Agora vá no personagem. Conte quantos pixels ele tem do centro para a parte de cima. Aqui deu 8px. O Detector Cima deve ficar 1px acima dele, então, o Detector Cima deve ficar 9px acima do referencial (HotSpot) do personagem (no MEU caso), pois 8+1=9. Mas como no Plano Computacional para cima são valores negativos, não deve ficar 9px e sim -9px. Agora, conte quantos pixel ele tem do centro para baixo. Aqui deu 7px. Como o detector deve ficar 1px abaixo dele, então adiciono 1, ficando 8px. Então, conte quanto tem do meio para a esquerda. Aqui deu 8px, somando um... 9px. Para a esquerda, assim como para cima, também são valores negativos. Então, não deve ficar 9px, e sim -9px. E pra terminar, conte quanto tem do meio para a direita. Aqui deu 7px, somando 1px, fica 8px.
Cima: -9px
Baixo: 8px
Esquerda: -9px
Direita: 8px
Pronto, anotei os valores que vou precisar. Lembre-se, esses valores dependem do tamanho dos Tiles que você está utilizando! Esses que peguei servem para 16x16, que são os que EU estou usando! Vamos utilizar esses valores para posicionar os detectores ;P.

Programando os Eventos:
Ok, agora está tudo preparado para começarmos a programar. Vamos começar posicionando os detectores. Faça o seguinte evento:
Start of Frame
(Detector Cima) Set position at (0,-9) from ("Personagem")
(Detector Baixo) Set position at (0,8) from ("Personagem")
(Detector Esquerda) Set position at (-9,0) from ("Personagem")
(Detector Direita) Set position at (8,0) from ("Personagem")

Beleza! Isso vai fazer com que quando começar o Frame, os detectores vão para os seus devidos lugares, não importando onde estão! Agora, vamos criar um loop para ficar posicionando os detectores sempre. Vamos chamar esse loop de Detectores. Crie o seguinte evento, repetindo as ações do evento anterior e mudando apenas a condição:
On loop "Detectores"
(Detector Cima) Set position at (0,-9) from ("Personagem")
(Detector Baixo) Set position at (0,8) from ("Personagem")
(Detector Esquerda) Set position at (-9,0) from ("Personagem")
(Detector Direita) Set position at (8,0) from ("Personagem")

Repetimos o que fizemos no Start of Frame. A diferença é que, enquanto lá, era pra posicionar assim que o Frame começar, aqui, é pra manter esse posicionamento constante. Muito bem. Agora, vamos usar este loop.

Lembram destas condições, da aula passada?
Alterable Value A of ("Personagem") < 0
Alterable Value A of ("Personagem") > 0
Alterable Value B of ("Personagem") < 0
Alterable Value B of ("Personagem") > 0

Adicione a cada uma delas o seguinte evento:
Start Loop "Detectores" X times

X é o número de vezes que a repetição será feita. Coloque o mesmo número do tamanho dos tiles. No meu caso seria, então, 16 vezes, pois o tamanho dos meus tiles é 16x16.

Ok, agora lembra daquelas condições de movimento?
Repeat while ("Player 1") Moved right
X Repeat while ("Player 1") Moved left
Alterable Value A = 0
Alterable Value B = 0

Repeat while ("Player 1") Moved left
X Repeat while ("Player 1") Moved right
Alterable Value A = 0
Alterable Value B = 0

Repeat while ("Player 1") Moved top
X Repeat while ("Player 1") Moved bottom
Alterable Value B = 0
Alterable Value A = 0

Repeat while ("Player 1") Moved bottom
X Repeat while ("Player 1") Moved top
Alterable Value B = 0
Alterable Value A = 0

Então, adicione a todas elas a seguinte condição também:
X (Respectivo Detector) is overlapping a backdrop

Escolhendo o Detector Direito para o movimento para a direita, o Detector Esquerdo para o movimento para a esquerda, o Detector Cima para o movimento para cima e o Detector Baixo para o evento para baixo! Ficando, respectivamente, assim:
Repeat while ("Player 1") Moved right
X Repeat while ("Player 1") Moved left
X (Detector Direita) is overlapping a backdrop
Alterable Value A = 0
Alterable Value B = 0

Repeat while ("Player 1") Moved left
X Repeat while ("Player 1") Moved right
X (Detector Esquerda) is overlapping a backdrop
Alterable Value A = 0
Alterable Value B = 0

Repeat while ("Player 1") Moved top
X Repeat while ("Player 1") Moved bottom
X (Detector Cima) is overlapping a backdrop
Alterable Value B = 0
Alterable Value A = 0

Repeat while ("Player 1") Moved bottom
X Repeat while ("Player 1") Moved top
X (Detector Baixo) is overlapping a backdrop
Alterable Value B = 0
Alterable Value A = 0

Isso fará com que ele só ande se o detector não estiver detectando um obstáculo! E... pronto! Terminamos! Agora ele já colide! Só falta deixar os Detectores Invisíveis... Seria super estranho vários quadrados coloridos ao redor do personagem =P.

Always
(Detector Cima) Make Invisible
(Detector Baixo) Make Invisible
(Detector Esquerda) Make Invisible
(Detector Direita) Make Invisible

Agora sim! Seu movimento está pronto! Agora é só começar a criar seus jogos em RPG! Só uma observação, antes de você sair por aí criando jogos de RPG... Particularmente, sempre uso esse Active Object, o qual programamos o movimento, como uma Máscara de Colisão (também conhecida como Collision Mask), a fim de evitar bugs.

Máscara de Colisão é um objeto que controla o movimento, e as animações ficam em outro Active Object, á parte. Ou seja, eu crio outro Active Object, com as animações, e posiciono-o em cima da Máscara de Colisão. Daí, programo as animações nesse novo Active Object.

Pode parecer bobagem, mas fica a dica. Claro, não estou dizendo que você não pode fazer as animações direto no Active que o movimento está programado, mas, na minha humilde opinião, Máscaras de Colisão são bem melhores. Não vou explicar nesse tutorial como programar as animações, porque, nesse ponto, vocês já devem saber fazer isso sozinhos. Se não sabe, recomendo você dar outras lidas nas aulas...

Falow o/

Download do Exemplo: Link Direto / MediaFire
Nota: Nos exemplos, pode-se andar em diagonais, e em dois sentidos "ao mesmo tempo", o que pode ocasionar alguns bugs. Além disso, nessa parte 2, substitui um método pré-histórico de posicionamento que eu usava por Fast Loops. Isso significa que os exemplos servem apenas para você ter uma base, e que não deve se espelhar totalmente neles. Entretanto, se você seguir o tutorial, obterá sucesso, com certeza.

Sprites - Sonic 1 Dr. Robotinik

2010-07-11T17:41:00.000-03:00

Só Atualizando. Sprites Sonic1 Dr. Robotinik.

É isso aí.

Movimento Custom TileBased - Parte I: Movimentação

2010-05-20T21:35:00.003-03:00

Movimento Custom TileBased
Parte I: Movimentação

FireSoul falando o/

Vou mostrar pra vocês como criar um movimento personalizado baseado em Tiles.

O que é um movimento baseado em Tiles?

Movimento baseado em Tiles é um movimento "quadriculado". Por exemplo, se os Tiles forem 32x32 e eu mover o personagem para direita, ele vai andar para direita até completar 32 pixels, e vai parar. Resumindo, é um movimento estilo RPG.

Agora, vamos em frente com o tutorial. Primeiro, crie um objeto e escolha um tamanho para os Tiles. Eu vou usar Tiles de 16x16 como exemplo. Os eventos serão bem básicos.

Movimentos Horizontais
Faça o seguinte evento:

Repeat While ("Player 1") Moved right
X Repeat While ("Player 1") Moved left
Alterable Value A ("Personagem") = 0
Alterable Value B ("Personagem") = 0
Set Alterable Value A ("Personagem") to 16

Explicando:

Este evento faz com que enquanto o jogador estiver pressionando para a direita, e a variável A for 0, mudar o valor da variável A para 16.

Modificamos o valor da variável A para 16 porque é o valor da variável A que vai determinar o movimento horizontal. E, como o tamanho dos tiles é 16x16, o personagem irá andar de 16 em 16 pixels. Logo, se o tamanho dos tiles fossem 32x32, deveríamos definir esse valor para 32. Se fossem 48x48, deveríamos definir esse valor para 48, e assim por diante.

Verificar se a variável B é igual a 0 serve para que o personagem não ande em diagonal. Isso pode ocasionar bugs mais tarde. E a condição negada, serve para que seja impossível andar para os dois lados ao mesmo tempo.

Agora, o próximo evento:
Repeat While ("Player 1") Moved left
X Repeat While ("Player 1") Moved right
Alterable value A ("Personagem") = 0
Alterable value B ("Personagem") = 0
Set alterable value A ("Personagem") to -16

Explicando:

Quase a mesma coisa do evento anterior. Contudo, como queremos que ele ande para a esquerda, devemos definir a variável A para -16, um valor negativo. Como você sabe, no Plano Computacional, no eixo X (horizontal), a direção para a direita é representada por números positivos, e a direção para a esquerda, é representada por números negativos. Logo, 16 fará o personagem andar 16 pixels para a direita, e -16, fará o personagem andar 16 pixels para a esquerda.

Verificar se a variável B é igual a 0 , mais uma vez, serve para que o personagem não ande em diagonal, pelo mesmo motivo já citado. Novamente, a condição negada é para que ele não ande para os dois lados.

Pronto, terminamos os Movimentos Horizontais. Note que, mesmo que tenhamos feito os Movimentos Horizontais, o personagem ainda não se move quando teclamos no jogo. Isso iremos resolver no final do tutorial, pois precisamos programar também o movimento em si.

Movimentos Verticais

Ok, beleza, quase a mesma lógica dos Movimentos Horizontais, mas vou explicar tudo de novo. Comece fazendo o seguinte evento:

Repeat While ("Player 1") Moved down
X Repeat While ("Player 1") Moved top
Alterable value B ("Personagem") = 0
Alterable value A ("Personagem") = 0
Set Alterable Value B ("Personagem") to 16

Explicando:

Este evento faz com que enquanto o jogador estiver apertando para baixo e a variável B do personagem for 0, mudar o valor da variável para 16.

O Alterable Value B = 0 só vai deixar com que o evento aconteça se o valor alterável B do personagem seja 0. Isso serve para que o movimento não saia do padrão.

Modificamos o valor da variável B para 16 porque é o valor da variável B que vai determinar o movimento vertical. E, como o tamanho dos tiles é 16x16, o personagem irá andar de 16 em 16 pixels. Logo, se o tamanho dos tiles fossem 32x32, deveríamos definir esse valor para 32. Se fossem 48x48, deveríamos definir esse valor para 48, e assim por diante.

Desta vez, é o contrário. O que faz o personagem não andar em diagonal, é o fato de verificarmos, agora, se a variável A (dos movimentos horizontais), e não mais a B, é igual a 0. Isso porque estamos trabalhando agora com a variável B como movimento, ou seja, a "intrusa" é a A. A intrusa a qual me refiro, é a cujo movimento é iniciado depois, sendo que a A representa os horizontais, e a B, os verticais. Isso significa que se o movimento horizontal já tiver sido iniciado, o vertical (intruso) não pode acontecer, e vice-versa. Já a condição negada, é para que ele não ande para cima e para baixo ao mesmo tempo.

Agora, vamos ao próximo evento:

Repeat While ("Player 1") Moved top
X Repeat While ("Player 1") Moved down
Alterable value B ("Personagem") = 0
Alterable value A ("Personagem") = 0
Set Alterable Value B ("Personagem") to -16

Explicando:

Quase a mesma coisa do evento anterior. Contudo, como queremos que ele ande para cima, devemos definir a variável B para -16, um valor negativo. Como você sabe, no Plano Computacional, no eixo Y (vertical), a direção para baixo é representada por números positivos, e a direção para cima, é representada por números negativos. Logo, 16 fará o personagem andar 16 pixels para baixo, e -16, fará o personagem andar 16 pixels para cima.

Novamente, verificamos se a variável A é igual a 0 a fim de impedir o movimento diagonal. A explicação é a mesma dos eventos anteriores. A Condição negada, mais uma vez, é para que ele não ande para cima e para baixo ao mesmo tempo.

Com isso, terminamos o Movimento Vertical.

O Movimento em Si

Agora, iremos fazer o movimento em si. O que fizemos antes foi para criar as direções do movimento, mas isso não fará o personagem se movimentar de fato. Então, vamos lá. Faça o seguinte evento:

Alterable Value A ("Personagem") > 0
Set position X ("Personagem") to X("Personagem")+1
Sub 1 from Alterable Value A

Explicando:

Agora, se a variável A for maior do que 0 (ou seja, se apertar para DIREITA), vai mudar a posição X do personagem para a sua própria posição X, mais um, ou seja, irá aumentar a posição X do personagem em 1. Ao mesmo tempo, precisamos fazer com que a variável A fique voltando a 0 conforme o personagem anda, para ele parar o movimento (porque senão, ele fica andando pra sempre =P). Como aqui o valor é positivo, para fazermos ele voltar a ser 0, devemos subtrair 1 dele. Assim, a cada pixel que o personagem anda, 1 é subtraído da variável A, logo, quando ele tiver andado 16 pixels, já terá subtraído 16, e a variável terá voltado a ser 0. Então, ele irá parar.

Os valores que adicionamos na posição e subtraímos na variável tem de serem iguais, e, esse valor, é a velocidade do movimento. A velocidade tem de ser divisível pelo tamanho dos Tiles. 1 é divisível por todos os números, logo, sempre poderá ser utilizado. 2 é divisível por 16, logo, poderia ser utilizado. 3 não é divisível por 16, logo, não poderia ser utilizado.

Outro evento:
Alterable Value A ("Personagem") < 0
Set position X ("Personagem") to X("Personagem")-1
Add 1 to Alterable Value A

Explicando:

A mesma lógica do evento anterior, só que para andar para a esquerda. Quando a variável for menor que 0, diminuiremos 1 da posição X (lembre que, a direção esquerda é representada por números negativos). Ao mesmo tempo, faremos a variável A voltar a ser 0. Como aqui o número é negativo, para a variável voltar a ser 0, devemos adicionar 1 à variável. Daí, quando o valor voltar a ser 0, o personagem vai parar de andar, e isso vai ser exatamente quando ele tiver chegado ao fim do Tile.

O normal é que a velocidade das quatro direções sejam iguais. Mas se quiser fazê-las diferentes, faça. E lembre-se que a velocidade (no caso, o valor que deve ser subtraído na posição e adicionado na variável) deve ser divisível pelo tamanho dos Tiles.

Então, vamos ao próximo evento:

Alterable Value B ("Personagem") > 0
Set position Y ("Personagem") to Y("Personagem")+1
Sub 1 from Alterable Value B

Explicando:

A mesma coisa, mas com a posição vertical. Como está "Quando o valor for MAIOR que 0...", então o evento irá acontecer quando apertar BAIXO.

Alterable Value B ("Personagem") < 0
Set position Y ("Personagem") to Y("Personagem")-1
Add 1 to Alterable Value B

Explicando:

Agora estamos fazendo exatamente o oposto do evento anterior. Esse evento é para quando o jogador apertar para cima, afinal, a variável B está "Quando o valor for MENOR que 0...".

Ei, não tente fazer seu jogo agora, na próxima parte do tutorial irei explicar colisões, para seu personagem não atravessar a parede!

EXTRA!

Antes de terminar, vou ensinar como criar uma grade para posicionar corretamente seu personagem e os obstáculos! Isso é muito importante, pois se eles forem posicionados de forma errada, pode ocorrer algum bug no seu jogo. A grade ajuda a alinhar o personagem e os objetos corretamente!

O primeiro passo é abrir seu Paint. Vá em Imagem > Atributos. Coloque a largura e a altura dos tiles que serão utilizados no seu jogo em Pixels nos seus respectivos campos. No meu caso, 16 de largura e 16 de altura. Então, pinte de cinza a imagem toda. Daí, volte em Imagem > Atributos, e, dessa vez, dobre a largura. Como a largura dos meus tiles é de 16px, dobrando, fica 32 (16x2=32). Dê Ok. Agora vá em Editar > Selecionar Tudo e depois em Editar > Copiar. Vá novamente em Imagem > Atributos, mas dessa vez dobre a altura. Como a altura dos meus tiles também é de 16px, dobrando fica 32 de novo. Agora, clique na Lupa e selecione 8x, a fim de aumentar a imagem para ver melhor. Então, vá em Editar > Colar. Clique com o botão direito do mouse nessa nova parte da imagem, e clique em Iverter / girar. Escolha Inverter horizontalmente e clique em Ok. Depois, arraste a nova parte da imagem para abaixo da antiga e salve sua imagem como (*.PNG)! Daí é só adicionar no MMF2 como QuickBackdrop Object e utilizar como base! Note que para encaixar direitinho com o tamanho do frame, a largura do frame deve ser divisível pela largura do tile e a altura do frame também deve ser divisível pela altura do tile!

Bom, é isso!

That's all for now, Folks!

Download do Exemplo: Link Direto / MediaFire

Nota: Nos exemplos, pode-se andar em diagonais, e em dois sentidos "ao mesmo tempo", o que pode ocasionar alguns bugs. Isso significa que eles servem apenas para você ter uma base, e que não deve se espelhar totalmente neles. Entretanto, se você seguir o tutorial, obterá sucesso, com certeza.

Instalando Widgets - Bibliotecas de Eventos

2010-05-01T22:30:00.001-03:00

Introdução:
Widgets são algo parecido com Libs. Tanto Widgets quanto Libs são Bibliotecas; a diferença é que enquanto Libs são Bibliotecas Gráficas, Widgets são Bibliotecas de Eventos. As Widgets contém objetos pré-programados, para você só arrastar para o Frame e editar. Os eventos são programados dentro dos Behaviors do objeto. Você pode baixar Widgets no fórum oficial da ClickTeam. O processo de instalação é igual ao das Libs.

1 - Vá até a pasta do Multimedia Fusion 2.
2 - Entre na pasta "Lib", e depois em "Object".
3 - Crie uma pasta chamada Widgets. Este passo não é obrigatório, mas é importante para ficar organizado e você não acabe se perdendo depois.
4 - Nesta pasta, coloque todas as Widgets que baixar. Você pode também criar pastas dentro dessa pasta, para ficar ainda mais organizado.
5 - Sempre que instalar uma ou mais novas Widgets, se seu Multimedia Fusion 2 estiver aberto, feche-o e abra-o novamente.

Pronto! Agora é só curtir suas Widgets!
Falow o/

Os Movimentos

2010-05-01T20:49:00.002-03:00

Os Movimentos

Introdução:
O Multimedia Fusion 2 vem com uma série de movimentos pré-definidos para serem aplicados a Active Objects. O problema é que a maioria desses movimentos são mal-feitos e, por isso, não são muito usados em jogos de nível intermediário ou superior. Com o tempo, você adquire a experiência necessária para fazer um Movimento Personalizado. Mas por ora, foque-se no Pré-definido; vamos deixar o Personalizado pra mais tarde. Nessa matéria, vamos aprender os movimentos pré-definidos mais simples: Static, Bouncing Ball, Path, Mouse Controlled, Eight Directions, Race Car e Platform.

Static Movement:
Não se tem o que falar sobre esse movimento. É estático, não se pode nem dizer que é um movimento. É utilizado quando se faz Movimento Personalizado, pois neste, é você que cria o Movimento por meio de eventos, e, por isso, o correto é não aplicar nenhum movimento no Objeto. Resumindo, Static é sem movimento. Pelo menos, sem Movimento Pré-definido.

Bouncing Ball Movement:
Movimento de bola quicante. É utilizado para jogos de Pinball, por exemplo.

Atributos:
Initial Direction: Direções iniciais que o Active Object pode assumir.
Speed: Velocidade de movimentação do Active Object.
Deceleration: Desaceleração do Active Object.
Moving at Start: Determina se o Active Object vai se mover ao começar o Frame ou não. Caso esteja marcada, vai se mover ao começar o Frame, caso esteja desmarcada, será necessário um evento para ativá-lo.
# of angles: Ângulos que o Active Object pode assumir.
Randomizer: Chance de quicar para outra direção.

Path Movement:
Movimento de "Caminho". Nesse movimento, nós traçamos um caminho que o Active Object deve percorrer, uma "trilha". Por exemplo: João sai de sua casa. Depois vai ao banco. Quando sai do banco vai pra padaria. Da padaria, ele vai pra casa de novo. Para definir a trilha a ser seguida, clique no botão Edit nos atributos do Movimento, e você verá o editor. No Editor, ele mostra um campo onde pode-se alterar a velocidade. Mas este campo é defeituoso, e você tem que mudar a velocidade por eventos, com o evento Start of Frame > Set speed to #.

Mouse Controlled Movement:
Movimento em que o Active Object é controlado pelo Mouse. É utilizado, por exemplo, em jogos de Tiro-ao-Alvo.

Atributos:
Player: Determina qual o Jogador do Active Object em questão.

Clicando no botão Edit, você delimita a área em que o Active Object pode se mover.

Eight Directions Movement:
Movimento em oito direções. É utilizado, por exemplo, em jogos de RPG, parecido com os do RPG Maker.

Atributos:
Player: Determina qual o Jogador do Active Object em questão.
Directions: Determina quais direções o Active Object pode assumir em seu movimento.
Initial direction: Determina quais podem ser as direções inicias do Active Object.
Speed: Velocidade do movimento.
Deceleration: Desaceleração do movimento, ou seja, quanto ele vai perdendo velocidade ao parar de se movimentar.
Acceleration: Aceleração do movimento, ou seja, quanto ele vai ganhando velocidade ao começar a se movimentar.
Moving at start: Neste tipo de movimento, esta opção é inútil.

Race Car Movement:
Movimento de carro de corrida. Utilizado em jogos de corrida vistos de cima, por exemplo.

Atributos:
Player: Determina qual o Jogador do Active Object em questão.
Initial direction: Determina quais podem ser as direções inicias do Active Object.
Speed: Velocidade do movimento.
Acceleration: Aceleração do movimento, ou seja, quanto ele vai ganhando velocidade ao começar a se movimentar.
Deceleration: Desaceleração do movimento, ou seja, quanto ele vai perdendo velocidade ao parar de se movimentar.
Enable reverse: Não vou mentir, não sei o que é. Testei para ver o que seria, mas não vi nenhuma mudança. Favor, se alguém souber, mandar um e-mail.
Moving at start: Neste tipo de movimento, esta opção é inútil.
# of angles: Ângulos em que o Active Object pode se movimentar.
Rotation Speed: Velocidade de rotação do carro, isto é, quando viramos para a esquerda ou para a direita.

Platform Movement:
Movimento de plataforma. Aquele, que você sai pulando nas plataformas com o personagem. Um exemplo desse tipo de jogo é Sonic.

Atributos:
Player: Determina qual o Jogador do Active Object em questão.
Initial direction: Determina quais podem ser as direções inicias do Active Object.
Speed: Velocidade do movimento.
Acceleration: Aceleração do movimento, ou seja, quanto ele vai ganhando velocidade ao começar a se movimentar.
Deceleration: Desaceleração do movimento, ou seja, quanto ele vai perdendo velocidade ao parar de se movimentar.
Moving at start: Neste tipo de movimento, esta opção é inútil.
Gravity: Gravidade do movimento.
Strenght: Força do pulo.
Control: Botão utilizado para pular.

Multiple Movements:
Um mesmo Active Object pode ter mais de um movimento. Para organizar os movimentos de um Active Object, clique sobre a opção do lado de Movement, e clique no botão +/-. Então, uma janela vai se abrir, onde você pode organizar os movimentos do Active Object. Uma vez que um Objeto tenha mais de um movimento, mais movimentos aparecerão no Atributo Movement, para que você possa mudar os atributos dos outros movimentos.

Condições e Eventos de Movimento:
Existem condições e eventos referentes aos movimentos, como já falei anteriormente. Se você não se lembra, foi quando eu estava falando sobre o Path Movement, no começo da matéria. Vou falar sobre cada condição e cada evento referente aos movimentos.

Condições:
Podem ser acessadas no SubMenu "Movement".
Nota: Sempre que utilizar o símbolo #, significa que é um valor escolhido por você.

Is "Nome do Objeto" stopped? - Se o objeto estiver parado...
Is "Nome do Objeto" bouncing? - Se o objeto estiver quicando...
Compare Speed of "Nome do Objeto" to a value - Se a velocidade do objeto for #...
Compare Acceleration of "Nome do Objeto" to a value - Se a aceleração do objeto for #...
Compare Deceleration of "Nome do Objeto" to a value - Se a desaceleração do objeto for #...

SubMenu "Path movement":
Has "Nome do Objeto" reached a node in the path - Quando o objeto finalizar uma linha do trajeto...
Has "Nome do Objeto" reached the end of its path - Quando o objeto finalizar o trajeto...
Path movement of "Nome do Objeto" has rechead a named node - Se o objeto tiver chegado a uma linha nomeada... (para nomear uma linha, você deve, no editor, clicar com o botão direito do mouse sobre ela e clicar em Set Name)

Eventos:
Podem ser acessados no SubMenu "Movement".
Nota: Sempre que utilizar o símbolo #, significa que é um valor escolhido por você.

Stop - Parar o movimento. É utilizado para fazer colisões.
Start - Começar o movimento.
Bounce - Fazer o objeto quicar no movimento. Também pode ser utilizado para fazer colisões. Prefiro, aliás, fazer com Bounce do que com Stop.
Reverse - Não vou mentir, não sei o que é. Testei para ver o que seria, mas não vi nenhuma mudança. Favor, se alguém souber, mandar um e-mail.
Wrap Around Play Area - O objeto vai ser transportado para a margem oposta do Frame.
Set Speed... - Definir velocidade do movimento para #.
Set Maximum Speed... - Definir velocidade máxima do movimento para #.
Set acceleration... - Definir aceleração do movimento para #.
Set deceleration... - Definir desaceleração do movimento para #.
Set gravity... - Definir gravidade do movimento para #.
Set rotating speed ... - Definir velocidade de rotação do movimento para #.
Set authorised directions... - Definir direções autorizadas no movimento.

SubMenu "Path movement":
Goto node... - Ir para determinada linha (por nome).
Branch node... - Ramificar determinada linha (por nome).

SubMenu "Multiple movements":
Next movement - Próximo movimento do objeto.
Previous movement - Movimento anterior do objeto.
Select movement - Selecionar um movimento do objeto.

Finalizando:
Você vai notar que quase todos esses movimentos tem pequenos bugs. Mas não se preocupe, o Movimento Pré-definido é só o começo. Como eu já falei, com o tempo, você vai adquirindo a exeriência necessária para fazer um Movimento Personalizado, que, se for programado corretamente, não tem erro nenhum.

Falow o/

Prioridades de um Objeto

2010-05-01T13:44:00.001-03:00

Introdução:
Assim como em um editor de imagens, os objetos no MMF2 tem uma prioridade: alguns ficam na frente, outros atrás... e nesse tutorial, vamos aprender a mudar essas prioridades, e algumas coisas que não podem ser mudadas. Assim como qualquer editor de imagens decente, o MMF2 tem uma Layer Toolbar (Janela de Camadas), que organiza os objetos em diferentes camadas, mas, infelizmente, essa ferramenta no Multimedia Fusion 2 é um pouco defeituosa.

Prioridades padrões:
Antes que possamos aprender a como mudar a prioridade dos objetos, ponham uma coisa na cabeça: muda-se mais a prioridade de objetos de um mesmo tipo (Active Objects, Backdrops, etc). Isso porque no MMF2, os objetos tem diferentes níveis de importância. Alguns objetos sempre ficam na frente de outros no MMF2 (alguns podem quebrar essa regra se forem colocados em uma layer, camada, superior). Alguns exemplos:

• Active Objects sempre ficam na frente de Backdrops em uma mesma camada;
• Active Objects sempre ficam na frente de Strings, não importando a camada;
• VideoPro, DirectShow e SubApplication sempre ficam na frente de tudo, não importando a camada.

Esses são alguns exemplos de que me recordo agora. Com certeza, existem mais, muito mais. Mas isso você aprende com experiência, mechendo, testando, na marra. Foi assim que aprendi, e espero que você também o faça.

Mudando prioridades:
Existem quatro opções para você mudar a prioridade de um objeto em determinada camada. São elas: To Front, To Back, Forward One e Backward One. Elas podem ser acessadas quando se clica com o botão direito do mouse sobre o objeto em questão e entra-se no SubMenu "Order". Veja as funções de cada uma:

• To Front: Move o objeto para a frente de todos os outros objetos de mesmo valor da camada. Quando usa-se isso em um Active Object, por exemplo, ele irá ficar na frente de todos os Active Objects. E quando usa-se em um Backdrop, ele ficará na frente de todos os Backdrops, mas não ficará na frente dos Active Objects, pois estes, tem um valor maior que o dele.

• To Back: Move o objeto para trás de todos os outros objetos de mesmo valor da camada. Quase a mesma coisa do anterior, mas considere que, desta vez, se usássemos isso em um Active Object, esse Active Object iria para trás dos outros Active Objects, mas não iria para trás de Backdrops, pois o valor dos Backdrops é inferior ao dele, e ele nunca poderá ficar atrás de um Backdrop na mesma camada.

• Forward One: Faz o objeto subir um nível na lista de prioridade. Mas só um, ou seja, ele não ficará na frente de todos os objetos, mas apenas na frente do que logo em seguida ficava na frente dele na lista, o que estava um nível acima. Se existem três Active Objects, Active 1, Active 2 e Active 3, sendo que o Active 1 está lá atrás, o Active 2 na frente do Active 1 e atrás do Active 3, e o Active 3 na frente de todos, se eu uso Forward One no Active 1, ele ficará na frente do Active 2, mas não do Active 3.

• Backward One: Faz o objeto descer um nível na lista de prioridade. Ele não ficará atrás de todos os outros de mesmo valor, como o To Back, apenas atrás do objeto que estava um nível antes na lista de prioridade. Se existem três Active Objects, Active 1, Active 2 e Active 3, sendo que o Active 1 está atrás de todos, o Active 2 na frente do Active 1 e atrás do Active 3, e o Active 3 na frente de todos, e eu uso Backward One no Active 3, ele ficará atrás do Active 2, mas continuará na frente do Active 1.

Layer Toolbar:
Indo em "View > Toolbars > Layer Toolbar" ou simplesmente apertando CTRL+K, o MMF2 abre uma janela chamada Layer Toolbar. A Layer Toolbar é onde você poderá organizar as camadas do Frame, determinar o que fica acima de quem, mesmo que tenha valor inferior (claro, existem exceções, como as Strings, que não importa em que camada estejam, sempre ficam atrás de Active Objects). Quem meche em programas de edição de imagens entende o que estou falando. Em cada camada você pode colocar determinados objetos, e quanto mais acima a camada estiver, maior é sua prioridade. Se você colocar um Backdrop na Camada 2, sendo que está está em cima da Camada 1, ainda que seja um Backdrop, ele ficará acima dos Active Objects. Veja:

Manipulando prioridades via eventos:
Apesar de não terem condições de prioridade, existem eventos, ações. Podem ser acessadas no SubMenu "Order", quando se vai escolher uma ação de um Active Object para determinada condição. Os eventos são:

• Bring to front: Equivale ao To Front, só que por eventos.
• Brint to back: Equivale ao To Back, só que por eventos.
• Move behind object: Faz ficar atrás de determinado objeto.
• Move in front of object: Faz ficar na frente de determinado objeto.
• Move to layer: Muda para determinada layer (camada).

Finalizando:
Beleza, enrolei demais só pra ensinar a mudar a posição de objetos, mas acho que, pelo menos, agora vocês sabem fazer isso xD. Continuem lendo as matérias certinho :D.

Flw.

Atualizações

2010-03-28T12:22:00.000-03:00

Sei que estou devendo pra vocês muitas atualizações. Não vou usar a desculpa de que estou sem tempo, apesar de ser isso também, porque todo fim de semana estou aqui, no PC. É realmente por preguiça; ando tendo preguiça mesmo de escrever novos tutoriais. E peço desculpa por isso.

É bem capaz que, ainda passemos algum tempo sem ter novas atualizações. Irei escrevendo-os a medida do possível, e pode, e vai demorar. Meu planejamento tem vários tutoriais novos, e levará tempo para escrevê-los. Vocês podem vê-los na página de tutoriais de MMF2; são aqueles que tem o título, mas não tem o link. São esses que pretendo escrever.

Mais uma vez, peço desculpas. E só para vocês saberem, nunca, NUNCA vou abandonar o blog. Ainda que ele passe muito tempo sem atualizações, não significa que eu o abandonei. E, se um dia o fizer, o que não pretendo, deixarei uma mensagem de despedida na página principal, mas todo o conteúdo continuará aí para quem quiser aprender.

Falow o/

Engine de Menu Rolante

2010-03-28T12:16:00.000-03:00

Autor: Eskyz

Descrição: Depois de ver uma engine de menu apontado por setas do Sonic ZK, tive vontade de fazer algo parecido. Daí pensei em um menu rolante. O efeito é bem bonito, a bolinha vai deslizando até a opção. Nessa engine, não usamos Counters, apenas uma variável para fazer a bolinha rolar, e para selecionar a opção, utilizamos a sua posição Y.

É bem fácil dar CTRL+C e CTRL+V e dizer que fez um jogo. Mas se você quer realmente aprender, se você quer mesmo ser um criador de jogos, e não só um noob que junta engines e diz que faz jogos, leia e releia os comentários, procure entender todos os eventos, e tente fazer sozinho. É mais trabalhoso, mas pelo menos, você que fez. Além do mais, uma vez que tenha entendido como funciona, poderá customizar como quiser.

Independente de dar CTRL+C e CTRL+V ou ler a engine, por favor me dê créditos. Eu perdi tempo fazendo essa engine, perdi tempo programando, comentando, tempo que eu podia estar fazendo algo pra mim. Então peço que, por favor que, se usar, dê créditos. Apesar de que, sei que isso é inútil, afinal, a maioria das pessoas hoje é maior cara de pau :\. Olha, rimou =D.

Download: MediaFire

SonicBiel Engines

2010-03-28T12:09:00.000-03:00

Descrição:
Fiquei com preguiça de postar uma a uma hehe... Então, vamo lá!

Esse é um pacote com seis engines feitas pelo nosso amigo do fórum Sonic Biel, ou Sonic ZK. Todas abordam o básico de funções importantíssimas para novatos no MMF2. Então, se você é novato, não deixe de baixar esse pacote hihi. E tenha ética, e se usar, dê créditos ao Sonic ZK. Olha, rimou. o.o

Engines que o pacote contém:
* System Tray Object
* Grupos de Eventos
* Engine de Save Game
* Engine de PopUp Menu
* Engine de Menu por Teclado
* Engine de Global Values

Download: MediaFire

Fórmulas Matemáticas

2010-03-26T21:42:00.000-03:00

Introdução:
MMF2 é pura matemática e física. Para fazer algo decente no MMF2, você tem que trabalhar com matemática. É isso aí, se quer ser um bom programador, pode ir deixando de dormir durante a aula de matemática. Mentira, não dá pra dispensar a sonequinha né? Aula de matemática foi feita para se dormir mesmo. Aqui, vou estar dando de mão beijada algumas fórmulas matemáticas pra você aplicar nos seus jogos. E já sabe: se usar, dá créditos hem?

Barra em Active: - by Eskyz (Always > Set XScale ou Set YScale to...)
(((value( "Counter" )+0.0)/(maxvalue( "Counter" )+0.0))*100)/100
Explicando: para achar-se o valor em porcentagem de um número, deve-se dividir o valor atual pelo valor total, e depois multiplicar o resultado por cem. Adicionamos 0.0 para quebrar os números; isso é coisa do MMF2. Então, dividimos o resultado dessa operação por 100, porque o tamanho normal da barra é 1. Ou seja, a escala vai de 0 a 1. Aliás, vai mais, mas se passar disso, ficará distorcido.

Mostrar Porcentagem: - by Eskyz (Always > Set Counter ou algo assim to...)
((value( "Counter" )+0.0)/(maxvalue( "Counter" ))+0.0)*100
Explicando: é a mesma lógica da barra em Active, só que, dessa vez, não dividimos por 100, porque queremos o valor em porcentagem (de 0 a 100, e não de 0 a 1).

Sprites de DBZ

2010-03-26T21:41:00.000-03:00

Vegetto

Blog Diário, Projeto de Verdade

2010-01-31T18:03:00.000-02:00

Éeh... Ok. A partir de hoje, esse blog vai ser só um diário de desenvolvimento. Esqueçam o fórum; ele não vai rolar. Só eu vou escrever por aqui. Porque é um "diário" meu. Conteúdo bom mesmo, vai ser no nosso novo projeto. A equipe vai ser a mesma, só que com um novo membro, o Skilo. Huhuh.

É isso, depois posto o link. As postagens aqui vão continuar normal. Eu escrevo um tuto, eu posto. Só que esse não vai ser um projeto "sério".

Falow o/

PMO Atualizado

2010-01-30T13:42:00.001-02:00

Atualizei a engine de Platform Movement Object. Só uma besteirinha na animação XD

Falow o/

date_create_datetime()

2010-01-26T18:38:00.000-02:00

Nome da função: date_create_datetime(year, month, day , hour , minute , second)
Tipo: Construtor
Descrição: Cria uma variavel do tipo "datetime" usando as variáveis : year, equivale ao ano, month, equivale ao mês, day, equivale ao dia, hour, equivalente a hora, minute, equivalente aos minutos e second, equivalente aos segundos.
Exemplo:

minhaDataEHora = date_create_datetime(2002,10, 21,13,12,59);

date_compare_datetime()

2010-01-26T18:30:00.000-02:00

Nome da função: date_compare_datetime(date1, date2)
Tipo: Retornavel , Necessita de argumento
Descrição: Recebe duas variáveis, precisam ser datas com horas (datetime), logo, as variaveis precisam conter o resultado da função date_create_datetime() . Ela retorna 1 caso a primeira data seja maior que a segunda e -1 caso a primeira seja menor do que a segunda. Caso ambos sejam iguais retorna 0.

NOTA: Essa função compara datetime ´s. Uma variável date tem dia e hora. Exite também a variável date, com dias, e time, somente horas.
Exemplo:

data1 = date_create_datetime(1999,11,19,10,11,00);
data2 = date_create_datetime(1999,12,10,10,11,00);
qualDataMaior = date_compare_datetime(data1,data2);

o valor de qualDataMaior será: -1

Construtor

2010-01-26T18:18:00.001-02:00

Um construtor cria um objeto

O construtor atribui a uma determinada variável todas as informações de um objeto. Variáveis desse tipo são necessárias para a execução de algumas funções. As variáveis criadas com construtores só podem ser modificadas por meio de funções do mesmo tipo.

Exemplo:
Algumas funções date_ utilizam variavéis do tipo data. Esse tipo de variável é criado por meio de um construtor.

date_create_date()

2010-01-26T18:18:00.000-02:00

Nome da função: date_create_date(year, month, day)
Tipo: Construtor
Descrição: Cria uma variavel do tipo "date" usando as variáveis : year, equivale ao ano, month, equivale ao mês, e day, equivale ao dia.
Exemplo:

minhaData = date_create_date(2009,12, 31);

date_compare_date()

2010-01-26T16:04:00.000-02:00

Nome da função: date_compare_date(date1, date2)
Tipo: Retornavel , Necessita de argumento
Descrição: Recebe duas variáveis, precisam ser datas, logo, as variaveis precisam conter o resultado da função date_create_date(). Ela retorna 1 caso a primeira data seja maior que a segunda e -1 caso a primeira seja menor do que a segunda. Caso ambos sejam iguais retorna 0.

NOTA: Essa função compara date ´s. Uma variável date tem ano, mes e dia. Exite também a variável datetime, com dia e hora, e time, somente horas.
Exemplo:

data1 = date_create_date(1999,11,19);
data2 = date_create_date(1999,12,10);
qualDataMaior = date_compare_date(data1,data2);

o valor de qualDataMaior será: -1

Necessita de argumento

2010-01-26T15:34:00.001-02:00

Essa função necessita de um valor para executar suas funções.

Uma função desse tipo necessita de um argumento, variável, que é inserida dentro dos parênteses. Em caso de múltiplos argumentos eles são separados por vírgula.

Exemplo:

myFunc( x, y, hspeed);
myFunc recebe os valores, x,y e hspeed (padrões do game maker).

Retornável

2010-01-26T15:17:00.000-02:00

Esse tipo de função retorna um valor.

Elas normalmente necessitam ser atribuidas a uma variável. Caso o contrário, o valor não será atribuido a lugar nenhum e, logo, ele irá lançar erros.

abs()

2010-01-26T14:57:00.000-02:00

Nome da função: abs( valor );
Tipo: Retornavel , Necessita de argumento
Descrição: Essa função recebe uma variável, valor, e retorna o valor absoluto dele. Valor absoluto é aquele não-negativo.
Exemplo:

velAtual = abs( hspeed );
variável = função( variável );

Banco de Códigos de GML

2010-01-25T21:27:00.000-02:00

Banco de Códigos de GML
por Untitled

O que é um banco de códigos?
É uma ferramenta que está sendo desenvolvida pela MMFM. É uma lista onde você poderá consultar todo e qualquer código do game maker.

Quando fica pronto?
Se você olhar a lista... vai ver que ela é enorme. Na verdade são exatamente 21 páginas A4, cada uma dessas linhas terá um post no blog e eles serão linkados aqui.

O que teremos dentro de cada post?
Uma breve descrição, o que ela retorna, o tipo dela, seus argumentos e um exemplo de como podemos utilizá-la!

Como será feita?
A ordem de produção é alfabética.

# A #

abs()
arccos()
arcsin()
arctan()
arctan2()

# B #

background_add()
background_add_alpha()
background_assign()
background_create_color()
background_create_from_screen()
background_create_from_surface()
background_create_gradient()
background_delete()
background_duplicate()
background_exists()
background_get_height()
background_get_name()
background_get_preload()
background_get_smooth()
background_get_texture()
background_get_transparent()
background_get_width()
background_replace()
background_replace_alpha()
background_save()
background_set_alpha_from_background()

# C #

cd_close_door()
cd_init()
cd_length()
cd_number()
cd_open_door()
cd_pause()
cd_paused()
cd_play()
cd_playing()
cd_position()
cd_present()
cd_resume()
cd_set_position()
cd_set_track_position()
cd_stop()
cd_track()
cd_track_length()
cd_track_position()
ceil()
choose()
chr()
clipboard_get_text()
clipboard_has_text()
clipboard_set_text()
collision_circle()
collision_ellipse()
collision_line()
collision_point()
collision_rectangle()
color_get_blue()
color_get_green()
color_get_hue()
color_get_red()
color_get_saturation()
color_get_value()
cos()

# D #

#D# #
d3d_draw_block()
d3d_draw_cone()
d3d_draw_cylinder()
d3d_draw_ellipsoid()
d3d_draw_floor()
d3d_draw_wall()
d3d_end()
d3d_light_define_direction()
d3d_light_define_point()
d3d_light_enable()
d3d_model_block()
d3d_model_clear()
d3d_model_cone()
d3d_model_create()
d3d_model_cylinder()
d3d_model_destroy()
d3d_model_draw()
d3d_model_ellipsoid()
d3d_model_floor()
d3d_model_load()
d3d_model_primitive_begin()
d3d_model_primitive_end()
d3d_model_save()
d3d_model_vertex()
d3d_model_vertex_color()
d3d_model_vertex_normal()
d3d_model_vertex_normal_color()
d3d_model_vertex_normal_texture()
d3d_model_vertex_normal_texture_color()
d3d_model_wall()
d3d_primitive_begin()
d3d_primitive_begin_texture()
d3d_primitive_end()
d3d_set_culling()
d3d_set_depth()
d3d_set_fog()
d3d_set_hidden()
d3d_set_lighting()
d3d_set_perspective()
d3d_set_ jection()
d3d_set_ jection_ext()
d3d_set_ jection_ortho()
d3d_set_ jection_perspective()
d3d_set_shading()
d3d_start()
d3d_transform_add_rotation_axis()
d3d_transform_add_rotation_x()
d3d_transform_add_rotation_y()
d3d_transform_add_rotation_z()
d3d_transform_add_scaling()
d3d_transform_add_translation()
d3d_transform_set_identity()
d3d_transform_set_rotation_axis()
d3d_transform_set_rotation_x()
d3d_transform_set_rotation_y()
d3d_transform_set_rotation_z()
d3d_transform_set_scaling()
d3d_transform_set_translation()
d3d_transform_stack_clear()
d3d_transform_stack_discard()
d3d_transform_stack_empty()
d3d_transform_stack_pop()
d3d_transform_stack_push()
d3d_transform_stack_top() javascript:void(0)
d3d_vertex()
d3d_vertex_color()
d3d_vertex_normal()
d3d_vertex_normal_color()
d3d_vertex_normal_texture()
d3d_vertex_normal_texture_color()
d3d_vertex_texture()
d3d_vertex_texture_color()

# DA #
date_compare_date()
date_compare_datetime()
date_compare_time()
date_create_date()
date_create_datetime()
date_create_time()
date_current_date()
date_current_datetime()
date_current_time()
date_date_of()
date_date_string()
date_datetime_string()
date_day_span()
date_days_in_month()
date_days_in_year()
date_get_day()
date_get_day_of_year()
date_get_hour()
date_get_hour_of_year()
date_get_minute()
date_get_minute_of_year()
date_get_month()
date_get_second()
date_get_second_of_year()
date_get_week()
date_get_weekday()
date_get_year()
date_hour_span()
date_inc_day()
date_inc_hour()
date_inc_minute()
date_inc_month()
date_inc_second()
date_inc_week()
date_inc_year()
date_is_today()
date_leap_year()
date_minute_span()
date_month_span()
date_second_span()
date_time_of()
date_time_string()
date_valid_date()
date_valid_datetime()
date_valid_time()
date_week_span()
date_year_span()

# DE #
degtorad()

# DI #
directory_create()
directory_exists()
discard_include_file()
display_get_colordepth()
display_get_frequency()
display_get_height()
display_get_width()
display_mouse_get_x()
display_mouse_get_y()
display_mouse_set()
display_reset()
display_set_all()
display_set_colordepth()
display_set_frequency()
display_set_size()
display_test_all()
distance_to_object()
distance_to_point()

# DR #
draw_arrow()
draw_background()
draw_background_ext()
draw_background_general()
draw_background_part()
draw_background_part_ext()
draw_background_stretched()
draw_background_stretched_ext()
draw_background_tiled()
draw_background_tiled_ext()
draw_button()
draw_circle()
draw_circle_color()
draw_clear()
draw_clear_alpha()
draw_ellipse()
draw_ellipse_color()
draw_get_alpha()
draw_get_color()
draw_getpixel()
draw_healthbar()
draw_highscore()
draw_line()
draw_line_color()
draw_line_width()
draw_line_width_color()
draw_path()
draw_point()
draw_point_color()
draw_primitive_begin()
draw_primitive_begin_texture()
draw_primitive_end()
draw_rectangle()
draw_rectangle_color()
draw_roundrect()
draw_roundrect_color()
draw_set_alpha()
draw_set_blend_mode()
draw_set_blend_mode_ext()
draw_set_circle_precision()
draw_set_color()
draw_set_font()
draw_set_halign()
draw_set_valign()
draw_sprite()
draw_sprite_ext()
draw_sprite_general()
draw_sprite_part()
draw_sprite_part_ext()
draw_sprite_stretched()
draw_sprite_stretched_ext()
draw_sprite_tiled()
draw_sprite_tiled_ext()
draw_surface()
draw_surface_ext()
draw_surface_general()
draw_surface_part()
draw_surface_part_ext()
draw_surface_stretched()
draw_surface_stretched_ext()
draw_surface_tiled()
draw_surface_tiled_ext()
draw_text()
draw_text_color()
draw_text_ext()
draw_text_ext_color()
draw_text_ext_transformed()
draw_text_ext_transformed_color()
draw_text_transformed()
draw_text_transformed_color()
draw_triangle()
draw_triangle_color()
draw_vertex()
draw_vertex_color()
draw_vertex_texture()
draw_vertex_texture_color()

# DS #
ds_grid_add()
ds_grid_add_disk()
ds_grid_add_grid_region()
ds_grid_add_region()
ds_grid_clear()
ds_grid_copy()
ds_grid_create()
ds_grid_destroy()
ds_grid_get()
ds_grid_get_disk_max()
ds_grid_get_disk_mean()
ds_grid_get_disk_min()
ds_grid_get_disk_sum()
ds_grid_get_max()
ds_grid_get_mean()
ds_grid_get_min()
ds_grid_get_sum()
ds_grid_height()
ds_grid_multiply()
ds_grid_multiply_disk()
ds_grid_multiply_grid_region()
ds_grid_multiply_region()
ds_grid_read()
ds_grid_resize()
ds_grid_set()
ds_grid_set_disk()
ds_grid_set_grid_region()
ds_grid_set_region()
ds_grid_shuffle()
ds_grid_value_disk_exists()
ds_grid_value_disk_x()
ds_grid_value_disk_y()
ds_grid_value_exists()
ds_grid_value_x()
ds_grid_value_y()
ds_grid_width()
ds_grid_write()
ds_list_add()
ds_list_clear()
ds_list_copy()
ds_list_create()
ds_list_delete()
ds_list_destroy()
ds_list_empty()
ds_list_find_index()
ds_list_find_value()
ds_list_insert()
ds_list_read()
ds_list_replace()
ds_list_shuffle()
ds_list_size()
ds_list_sort()
ds_list_write()
ds_map_add()
ds_map_clear()
ds_map_copy()
ds_map_create()
ds_map_delete()
ds_map_destroy()
ds_map_empty()
ds_map_exists()
ds_map_find_first()
ds_map_find_last()
ds_map_find_next()
ds_map_find_previous()
ds_map_find_value()
ds_map_read()
ds_map_replace()
ds_map_size()
ds_map_write()
ds_priority_add()
ds_priority_change_priority()
ds_priority_clear()
ds_priority_copy()
ds_priority_create()
ds_priority_delete_max()
ds_priority_delete_min()
ds_priority_delete_value()
ds_priority_destroy()
ds_priority_empty()
ds_priority_find_max()
ds_priority_find_min()
ds_priority_find_priority()
ds_priority_read()
ds_priority_size()
ds_priority_write()
ds_queue_clear()
ds_queue_copy()
ds_queue_create()
ds_queue_dequeue()
ds_queue_destroy()
ds_queue_empty()
ds_queue_enqueue()
ds_queue_head()
ds_queue_read()
ds_queue_size()
ds_queue_tail()
ds_queue_write()
ds_set_precision()
ds_stack_clear()
ds_stack_copy()
ds_stack_create()
ds_stack_destroy()
ds_stack_empty()
ds_stack_pop()
ds_stack_push()
ds_stack_read()
ds_stack_size()
ds_stack_top()
ds_stack_write()

# E #
effect_clear()
effect_create_above()
effect_create_below()
environment_get_variable()
event_inherited()
event_perform()
event_perform_object()
event_user()
execute_file()
execute_ gram()
execute_shell()
execute_string()
exp()
export_include_file()
export_include_file_location()
external_call()
external_define()
external_free()

# F #
file_attributes()
file_bin_close()
file_bin_open()
file_bin_position()
file_bin_read_byte()
file_bin_rewrite()
file_bin_seek()
file_bin_size()
file_bin_write_byte()
file_copy()
file_delete()
file_exists()
file_find_close()
file_find_first()
file_find_next()
file_rename()
file_text_close()
file_text_eof()
file_text_open_append()
file_text_open_read()
file_text_open_write()
file_text_read_real()
file_text_read_string()
file_text_readln()
file_text_write_real()
file_text_write_string()
file_text_writeln()
filename_change_ext()
filename_dir()
filename_drive()
filename_ext()
filename_name()
filename_path()
floor()
font_add()
font_add_sprite()
font_delete()
font_exists()
font_get_bold()
font_get_first()
font_get_fontname()
font_get_italic()
font_get_last()
font_get_name()
font_replace()
font_replace_sprite()
frac()

# G #
game_end()
game_load()
game_restart()
game_save()
get_color()
get_directory()
get_directory_alt()
get_integer()
get_open_filename()
get_save_filename()
get_string()

# H #
highscore_add()
highscore_add_current()
highscore_clear()
highscore_name()
highscore_set_background()
highscore_set_border()
highscore_set_colors()
highscore_set_font()
highscore_set_strings()
highscore_show()
highscore_show_ext()
highscore_value()

# I #
ini_close()
ini_key_delete()
ini_key_exists()
ini_open()
ini_read_real()
ini_read_string()
ini_section_delete()
ini_section_exists()
ini_write_real()
ini_write_string()
instance_activate_all()
instance_activate_object()
instance_activate_region()
instance_change()
instance_copy()
instance_create()
instance_deactivate_all()
instance_deactivate_object()
instance_deactivate_region()
instance_destroy()
instance_exists()
instance_find()
instance_furthest()
instance_nearest()
instance_number()
instance_place()
instance_position()
io_clear()
io_handle()
is_real()
is_string()

# J #
joystick_axes()
joystick_buttons()
joystick_check_button()
joystick_direction()
joystick_exists()
joystick_has_pov()
joystick_name()
joystick_pov()
joystick_rpos()
joystick_upos()
joystick_vpos()
joystick_xpos()
joystick_ypos()
joystick_zpos()

# K #
keyboard_check()
keyboard_check_direct()
keyboard_check_pressed()
keyboard_check_released()
keyboard_clear()
keyboard_get_map()
keyboard_get_numlock()
keyboard_key_press()
keyboard_key_released()
keyboard_set_map()
keyboard_set_numlock()
keyboard_unset_map()
keyboard_wait()

# L #
lengthdir_x()
lengthdir_y()
ln()
load_info()
log10()
log2()
logn()

# M #
make_color_hsv()
make_color_rgb()
max()
MCI_command()
mean()
median()
merge_color()
message_alpha()
message_background()
message_button()
message_button_font()
message_caption()
message_input_color()
message_input_font()
message_mouse_color()
message_position()
message_size()
message_text_font()
min()
motion_add()
motion_set()
mouse_check_button()
mouse_check_button_pressed()
mouse_check_button_released()
mouse_clear()
mouse_wait()
move_bounce_all()
move_bounce_solid()
move_contact_all()
move_contact_solid()
move_outside_all()
move_outside_solid()
move_random()
move_snap()
move_towards_point()
move_wrap()
mp_grid_add_cell()
mp_grid_add_instances()
mp_grid_add_rectangle()
mp_grid_clear_all()
mp_grid_clear_cell()
mp_grid_clear_rectangle()
mp_grid_create()
mp_grid_destroy()
mp_grid_draw()
mp_grid_path()
mp_linear_path()
mp_linear_path_object()
mp_linear_step()
mp_linear_step_object()
mp_potential_path()
mp_potential_path_object()
mp_potential_settings()
mp_potential_step()
mp_potential_step_object()
mplay_connect_status()
mplay_data_mode()
mplay_data_read()
mplay_data_write()
mplay_end()
mplay_init_ipx()
mplay_init_modem()
mplay_init_serial()
mplay_init_tcpip()
mplay_ipaddress()
mplay_message_clear()
mplay_message_count()
mplay_message_id()
mplay_message_name()
mplay_message_player()
mplay_message_receive()
mplay_message_send()
mplay_message_send_guaranteed()
mplay_message_value()
mplay_player_find()
mplay_player_id()
mplay_player_name()
mplay_session_create()
mplay_session_end()
mplay_session_find()
mplay_session_join()
mplay_session_mode()
mplay_session_name()
mplay_session_status()

~~# N #~~

# O #
object_add()
object_delete()
object_event_add()
object_event_clear()
object_exists()
object_get_depth()
object_get_mask()
object_get_name()
object_get_parent()
object_get_persistent()
object_get_solid()
object_get_sprite()
object_get_visible()
object_is_ancestor()
object_set_depth()
object_set_mask()
object_set_parent()
object_set_persistent()
object_set_solid()
object_set_sprite()
object_set_visible()
ord()

# P #
parameter_count()
parameter_string()
part_attractor_clear()
part_attractor_create()
part_attractor_destroy()
part_attractor_destroy_all()
part_attractor_exists()
part_attractor_force()
part_attractor_position()
part_changer_clear()
part_changer_create()
part_changer_destroy()
part_changer_destroy_all()
part_changer_exists()
part_changer_kind()
part_changer_region()
part_changer_types()
part_deflector_clear()
part_deflector_create()
part_deflector_destroy()
part_deflector_destroy_all()
part_deflector_exists()
part_deflector_friction()
part_deflector_kind()
part_deflector_region()
part_destroyer_clear()
part_destroyer_create()
part_destroyer_destroy()
part_destroyer_destroy_all()
part_destroyer_exists()
part_destroyer_region()
part_emitter_burst()
part_emitter_clear()
part_emitter_create()
part_emitter_destroy()
part_emitter_destroy_all()
part_emitter_exists()
part_emitter_region()
part_emitter_stream()
part_particles_clear()
part_particles_count()
part_particles_create()
part_particles_create_color()
part_system_automatic_draw()
part_system_automatic_update()
part_system_clear()
part_system_create()
part_system_depth()
part_system_destroy()
part_system_draw_order()
part_system_drawit()
part_system_exists()
part_system_position()
part_system_update()
part_type_alpha1()
part_type_alpha2()
part_type_alpha3()
part_type_blend()
part_type_clear()
part_type_color_hsv()
part_type_color_mix()
part_type_color_rgb()
part_type_color1()
part_type_color2()
part_type_color3()
part_type_create()
part_type_death()
part_type_destroy()
part_type_direction()
part_type_exists()
part_type_gravity()
part_type_life()
part_type_orientation()
part_type_scale()
part_type_shape()
part_type_size()
part_type_speed()
part_type_sprite()
part_type_step()
path_add()
path_add_point()
path_append()
path_assign()
path_change_point()
path_clear_points()
path_delete()
path_delete_point()
path_duplicate()
path_end()
path_exists()
path_flip()
path_get_closed()
path_get_kind()
path_get_length()
path_get_name()
path_get_number()
path_get_point_speed()
path_get_point_x()
path_get_point_y()
path_get_precision()
path_get_speed()
path_get_x()
path_get_y()
path_insert_point()
path_mirror()
path_reverse()
path_rotate()
path_scale()
path_set_closed()
path_set_kind()
path_set_precision()
path_shift()
path_start()
place_empty()
place_free()
place_meeting()
place_snapped()
point_direction() Calculate the angle from one point to another.
point_distance() Calculate the distance between two points.
position_change()
position_destroy()
position_empty()
position_free()
position_meeting()
power()

~~# Q #~~

# R #
radtodeg()
random()
real()
room_set_background()
room_set_background_color()
room_set_caption()
room_set_code()
room_set_height()
room_set_persistent()
room_set_width().
round()

# S #
screen_redraw()
screen_refresh()
set_automatic_draw()
sign()
sin()
sqr()
sqrt()
string()
string_char_at()
string_copy()
string_count()
string_delete()
string_digits()
string_format()
string_insert()
string_letters()
string_letters_digits()
string_lower()
string_pos()
string_repeat()
string_replace()
string_replace_all()
string_upper()

# T #
tan()
tile_add()
tile_delete()
tile_exists()
tile_get_x()

~~# U #~~
~~# V #~~
~~# W #~~
~~# X #~~
~~# Y #~~
~~# Z #~~

Flags

2010-01-23T22:31:00.001-02:00

Flags

por Eskyz

Introdução:

Flags são alavancas; podem estar ligadas ou desligadas. Imagine uma lanterna. Quando você aperta o botão uma vez, ela liga. Quando aperta de novo, ela desliga. É, assim é uma flag. Ainda no exemplo da lanterna, se a flag estiver ligada vai emitir luz, e se estiver desligada não vai emitir luz. Bem simples né?

Matéria:

Flags são alavancas internas de um Active Object. Existem infinitas flags, cada uma representada por um número. Existe a Flag 0, a Flag 1, a Flag 2, e assim vai. Relacionado a flags, temos 2 condições e 3 ações.

Condições:

Alterable Values > Flags > Is a flag on? - Se uma certa flag estiver ligada, vai acontecer coisa tal...

Alterable Values > Flags > Is a flag off? - Se uma certa flag estiver desligada, vai acontecer coisa tal...

Ações:

Flags > Set On - Liga uma certa flag

Flags > Set Off - Desliga uma certa flag.

Flags > Toogle - Inverte o estado de uma certa Flag. Se ela estiver ligada, vai desligar, e se estiver desligada, vai ligar.

Hora do Exercício!

Agora vamos fazer algo com o que acabamos de aprender.

("Active"): internal flag 0 is off

(Active) Reappear

("Active"): internal flag 0 is off

(Active) Make Invisible

Upon Pressing "Enter"

(Active) Toogle internal flag 0

O que fizemos aqui foi o seguinte: No primeiro evento, se a flag 0 estiver desligada, ele vai fazer o Active reaparecer (se ele já estiver visível, não vai mudar nada). Já no segundo, se a flag 0 estiver ligada, ele vai fazer o Active ficar invisível. O terceiro serve para se o jogador pressionar enter, inverter o estado da flag 0. Ou seja, vai mudar o estado de visibilidade do Active. O problema, é que não existe no MMF2 a função "Alterar o estado de visibilidade". Por isso, temos que usar flags.

Finalizando:

E isso... são flags ^^

Por hoje é só!

Falow o/

KODU Game Lab

2010-01-23T21:54:00.000-02:00

Depois de mais de 200 mil downloads da versão para Xbox, a Microsoft traz para o PC o KODU Game Lab, uma ferramenta para criação de jogos em 3D, voltado para as crianças (e todos que se interessam pelo desenvolvimento de jogos).

O aplicativo traz um editor de terrenos e também vem com tutoriais e games de exemplo. A programação é toda visual, no estilo "When... do..." (quando... faça...), bem parecida com a do MMF.

Download do techcnical preview

Para o programa funcionar você também precisa ter o Microsoft XNA Framework e o .NET Framework 3.5 instalados no computador.

Mario Mushroom Collect

2010-01-23T20:11:00.000-02:00

Menu

Hi-Scores

Jogo

Descrição:

Quando vi o tutorial do perdido Criando um jogo com apenas cinco eventos, decidi criar esse mini-game. O jogo em si foi feito em menos de cinco minutos, e com o mesmo método daquele tutorial. Eu demorei mesmo foi pra escolher os gráficos, fazer o menu e ajeitar as músicas. Ah sim, os gráficos são meio editados. Eu recolori os sprites originais do Mario com a Beta do Dokyz Recolor, que estou fazendo com o Dok-dok. Só vou liberar pra vocês quando estiver pronto.

História:

É um mini-game, mas a história veio na minha cabeça, e eu simplesmente desenvolvi. Quando eu realmente tento pensar em uma história, não sai nada, agora quando eu nem ligo, sai algo, digamos, aceitável.

Como sempre, o corno do Mario foi "salvar" a sua linda Princesa Peach, que foi "raptada" pelo Bowser. Antes de ir enfrentar Bowser, Mario precisa coletar o maior número de cogumelos reserva possível para ter uma vitória certa.

Progresso:

Programação: |||||||||| 100%

Gráficos: |||||||||| 100%

Sons: |||||||||| 100%

Total: |||||||||| 100%

Download:

Servidores: DropBox

Negando Condições

2010-01-23T14:02:00.004-02:00

Negando Condições
por Eskyz

Introdução:
Às vezes, nós precisamos que uma condição faça o oposto da sua função. Como por exemplo: se o personagem não estiver sobrepondo um obstáculo, ele vai perder HP. Para fazer isso, são necessários apenas dois cliques. Isso mesmo, dois cliques! Mas como não podia deixar de ser, vou enrolar pra caramba a matéria pra ver se realmente entra na cabeça de vocês.

Matéria:
Adicione normalmente a condição a ser negada. No caso seria ("Active") is overlapping a backdrop. Então, adicione a ação que seria Subtract 1 from Counter. Vai ficar assim:

("Active") is overlapping a backdrop
Subtract 1 from Counter

O Counter representa o HP. Ok, mas nós não queremos que ele perca HP enquanto sobrepõe um obstáculo, e sim enquanto não sobrepõe. Então, simplesmente clique com o botão direito do mouse sobre a condição a ser negada e escolha a opção Negate.

Negando a condição

Condição negada

Pronto, condição negada. Ficou assim:

X ("Active") is overlapping a backdrop
Subtract 1 from Counter

Só que não são todas as condições podem ser negadas! As que podem ser negadas são as que permanecem acontencedo, como a "Enquanto estiver pressionando tecla tal", ou "Enquanto estiver sobrepondo um obstáculo". Condições que acontecem uma vez e pronto, como a "Colidiu com um obstáculo" ou a "Pressionou tecla tal", não podem ser negadas.

Ah, sim, para desnegar uma condição, é a mesma coisa que negar, só que enquanto ela já estiver negada.

Outro exercício:
Agora vamos fazer outro exercício só pra fixar mesmo. Adicione um Counter na tela, e no Event Editor, coloque:

X Repeat While ("Player 1") Moved top
Add 1 to Counter

Ou seja, enquanto o jogador não estiver pressionando a tecla para cima, vai adicionar um ao Counter.

Finalizando:
Saber negar condições é tão importante quando saber combiná-las. Você vai usar muuuito essa função futuramente, pode ter certeza. Foi difícil encontrar exemplos realmente bons aqui porque vocês ainda estão começando. Se não entendeu ~~você é um bocó~~ recomendo que leia novamente e tente até conseguir.

Se for copiar, valorize meu trabalho e coloque os créditos!
Falow o/

Editando as imagens no MMF

2010-01-23T00:36:00.002-02:00

Clique duas vezes no objeto que você quer editar para abrir o Picture Editor (o editor de imagens do MMF2, parecido com o "Paint" do Windows). Ele contém todas as ferramentas necessárias para desenhar, importar e editar as imagens.

Quando for importar uma imagem, preste atenção na cor que está definida como "transparente", normalmente deve ser a cor ao redor da imagem que você quer importar (use o botão "Pick" para escolher a cor transparente diretamente da imagem). Se não quiser usar uma cor transparente selecione uma cor que não aparece na imagem para ser a transparente.

Para importar apenas uma parte da imagem marque "Import selection" e use o botão "Select". Depois use o ícone do quadrado cercado por setas para ajustar o tamanho da imagem.

Para importar todas as animações de um spritesheet você pode marcar a opção "Box Mode" e "Import as Animation". Mas para que essa opção funcione, cada imagem que você for importar precisa estar dentro de um retângulo de uma cor diferente da cor de fundo da imagem. Quase nunca dá certo comigo, e eu acabo importando as animações uma por uma mesmo...

Animation selector

Um objeto ativo pode ter diversas animações. As animações "padrão" são:
- Stopped (parado)
- Walking (andando)
- Running (correndo)
- Appearing (quando o objeto é criado)
- Disappearing (quando o objeto é destruido)
- Bouncing (quando o objeto colide em um obstáculo)
- Shooting (quando o evento shoot object é programado)
- Jumping (pulando)
- Falling (caindo)
- Climbing (subindo escadas)
- Crouch down (abaixando)
- Stand up (levantando)
Você também pode definir animações personalizadas.

Direction selector

Fica a direta do Animator selector. Para escolher o número de direções (4, 8, 16 ou 32) use a barra localizada abaixo do seletor. Clicando com o botão direito nos quadrados do seletor você pode recortar, copiar, colar, deletar, criar as animações em todas as direções e inverter horizontal e verticalmente as imagens. Na aba "Direction options" você define a velocidade mínima e máxima da animação e se ela vai repetir contínuamente (loop). Na aba "Frames", clicando com o botão direito, você pode inserir (clonar) novos frames, além de utilizar as demais opções de edição (recortar, copiar, etc).

Diferença entre o Hot spot e o Action spot:

- O Hot spot (o ícone do olho) é o ponto da imagem que corresponde as coordenadas X e Y do objeto (no centro, no topo da imagem, etc.), importante quando você estiver trabalhando com a posição do objeto no frame.

- O Action point (o ícone da estrela) é o ponto da imagem de onde a ação acontece (por exemplo, quando você escolhe "Shoot an object" no Event editor, o projétil é criado a partir dessa posição).

Se estiver editando uma animação, você pode mover o Hot spot e o Action spot de todas as imagens segurando a tecla ALT enquanto clica neles.

Bom, é isso!

Criando um jogo com apenas 5 eventos

2010-01-23T00:18:00.000-02:00

Vamos aprender a fazer um jogo simples (com apenas 5 eventos) no MMF. Para este exemplo vou usar sprites e sons de Mário. Você pode baixar vários no Mario Fan Games Galaxy (http://www.mfgg.net).

Primeiro, defina o tamanho (size) do seu frame (em Storyboard Editor ou em propriedades do frame, na aba "Settings") e o tamanho da tela (em propriedades da aplicação, na aba "Window") para 256 x 207 (que é o tamanho do Backdrop que vamos usar no jogo do exemplo).

Agora clique com o botão direito no frame e selecione "Insert object". Depois escolha "Active", que são os objetos animados. Clique duas vezes no objeto que você acabou de criar para abrir o Picture Editor. No nosso caso vamos importar um sprite do Mário.

Agora clique no Mário e na Properties Toolbar escolha a aba "Movement" (o bonequinho azul) e defina o tipo de movimento para "Platform". Depois, crie mais um Active object (um cogumelo), e na aba "Movement" defina o tipo de movimento para "Bouncing Ball" (deixe a "Initial direction" apenas para baixo e defina a "Speed" para 30).

Para terminar crie um "Backdrop object" (fundo de tela do jogo) e um "Score" (mostra os pontos do jogador).

Agora vamos programar.

Abra o Event Editor (Ctrl + E). São apenas 5 eventos:

CONDIÇÃO: Clique em "Storyboard controls" (o tabuleiro de xadrez), "Start of Frame".

AÇÃO: Em "Sound", selecione "Music" e em "Play music" escolha a música que vai tocar no jogo.

Esse evento é para colocar música.

CONDIÇÃO: Clique no (objeto) "Mário", "Position" e em "Test Position" (marcando todas as setas que indicam que o objeto estaria saindo da área do frame). Ou então, se quiser fazer o jogo com chão, clique no (objeto) "Mário", "Collisions", "Backdrop". Com esse segundo método, você precisa criar 3 obstáculos (backdrops): um para o chão, e dois para o Mário não sair da tela.

AÇÃO: No "Mário", selecione "Movement" e "Stop".

Esse evento impede que o Mário caia da tela quando você executa o jogo.

CONDIÇÃO: Clique em "The timer" (o relógio), selecione "Every" e coloque 00"-70.

AÇÃO: "Em Create new objects", selecione o "cogumelo" (x=128 y=-10). Depois no "cogumelo" selecione "Position", "Set X coordinate..." e escreva "Random(Frame Width)" no Expression Editor.

Esse evento cria, a cada 00"-70, um novo cogumelo em uma posição horizontal aleatória do frame.

CONDIÇÃO: Clique no "Mário", "Collisions", "Another object" e selecione o "cogumelo".

AÇÃO: Em "Sound", selecione "Sample" e em "Play sample" escolha o som que vai tocar. Em "Player 1", selecione "Score", "Add to score" e coloque "1". No "cogumelo" selecione "Destroy".

Esse evento adiciona 1 ponto ao seu Score para cada cogumelo que o Mário pegar, toca um som e destrói o cogumelo.

CONDIÇÃO: Clique no "cogumelo", "Position" e em "Test Position" (marcando a seta que indica que o objeto estaria saindo da área do frame pela parte de baixo).

AÇÃO: Em "Storyboard Controls", selecione "Next frame".

Esse evento passa para o próximo frame quando o Mário não conseguir pegar o cogumelo.

Clique em "Run aplication" para rodar o jogo e ver como ficou. Agora crie um frame para a tela de título e outro para os Hi-scores (use o objeto "Hi-score") e pronto! Terminamos nosso jogo!

Curso Multimedia Fusion 2

2010-01-22T23:30:00.020-02:00

Olá, e seja bem-vindo ao meu curso sobre uma incrível e poderosa ferramenta de criação de jogos desenvolvida pela ClickTeam - o Multimedia Fusion 2!

Aqui, abordarei os assuntos que julgo serem mais importantes para o desenvolvimento de um jogo... e do programador. Uma vez que entenda a essência do programa, estará apto a explorar novas áreas. Não somente dentro do programa (me refiro à funções mais complexas do deste, como OpenGL), mas também fora (entrando de cabeça nas linguagens de programação).

Ao fim de cada aula, se necessário, passarei um pequeno exercício para vocês - juntamente com o gabarito, para verificarem se fizeram corretamente. É muito importante que tentem fazê-los, pois servirá para a fixação da matéria. Além disso, aconselho a todos que deem uma olhada nas matérias Como-Fazer, e tentem fazê-las, pois são uma espécie de exercícios mais eficientes, que envolvem o conteúdo de mais de uma aula.

Boa sorte, e bom aprendizado!
.Eskyz

--//--

Básico
01. A Lógica de Programação (Eskyz)

02. Introdução ao Multimedia Fusion 2 (Eskyz)
03. Criando seu Primeiro Jogo (Eskyz)
04. Editando imagens no MMF2 (Perdido)
05. Prioridade de um Objeto (Eskyz)
06. Propriedades de um Objeto
07. Os Movimentos (Eskyz)
08. Tutorial Counters (Eskyz)
09. Recebendo Valores (Eskyz)
10. Comparando dois valores (Eskyz)
11. Condições de Tempo (Eskyz)
12. Combinando Condições (Eskyz)
13. Negando Condições (Eskyz)
14. Detectores de Colisão (Eskyz)
15. Flags (Eskyz)
16. Alterable Values e Global Values (Eskyz)
1 7. Alterable Strings e Global Strings (Eskyz)
18. Behaviors, Qualifiers e Global Events (Eskyz)
18. Grupos de Eventos (Eskyz)
20. Pontuações - Scores e HiScores
21. Platform Movement Object
22. Criando um jogo de plataforma simples

Intermediário
01. Como funciona o Fast Loop (Matheus290)
02. Movimento Personalizado - Parte 1: Introdução (Eskyz)
03. Movimento Personalizado - Parte 2: Movimento e Colisões
04. Movimento Personalizado - Parte 3: Resolvendo Bugs com Fast Loops
05. Movimento Custom TileBased - Parte I: Movimentação (FireSoul)
06. Movimento Custom TileBased - Parte II: Colisões (Eskyz)
07. Armazenando dados em arquivos INI (Eskyz)
08. Criptografando arquivos INI com Blowfish
09. Inteligência Artificial de um Inimigo - Parte 1
10. Inteligência Artificial de um Inimigo - Parte 2
11. Inteligência Artificial de um Inimigo - Parte 3
12. Inteligência Artificial de um Inimigo - Parte 4
13. Movimento Personalizado de Fast Loops - Parte 1: Movimento de 8 Direções
14. Movimento Personalizado de Fast Loops - Parte 2: Gravidade e Pulo
15. Movimento Personalizado de Fast Loops - Parte 3: Slope e Animações
16. Particle Spray Object

Avançado
01. Introdução ao 3D (Matheus290)
02. Fazendo jogos 3D usando Mode7ex (Matheus290)
03. Entendendo os Relevos do Mode7ex (Matheus290)
04. Gravidade e Relevos no Mode7ex (Matheus290)

Matérias Como-Fazer:
01. Criando um jogo com apenas cinco eventos (Perdido)
02. Retirando Bug dos Espinhos (Eskyz)
03. Tutorial Plataformas Invisíveis (Eskyz)
04. Path Movement Customizado (Eskyz)
05. Carregando Arquivos (Eskyz)
06. Matar Inimigo Pulando na Cabeça (Eskyz)
07. Fórmulas Matemáticas (Eskyz)
08. Invertendo Textos (Eskyz)

Turbinando o Programa:
01. Instalando Libs - Bibliotecas Gráficas (Eskyz)
02. Instalando Widgets - Bibliotecas de Eventos (Eskyz)
03. Instalando Extensões (Eskyz)

Video-aulas:
Prefere aprender MMF2 por video-aulas? Bem, você tem essa opção :D. Mas não me terá como professor xD. As video-aulas são feitas por um cara chamado MiltinhoEXE. Você pode conferir o canal do Youtube dele AQUI ;).

Combinando Condições

2010-01-22T22:09:00.004-02:00

Combinando Condições
por Eskyz

Introdução:
Eu ainda me lembro que, nos meus primeiros jogos eu sempre usava condições sozinhas. Só que em alguns casos, é necessário que nós limitemos ainda mais um evento. Hmm... por exemplo: eu quero que enquanto estiver pressionando a Tecla de Fogo 1, o personagem atire. Até aí tudo bem, vamos fazer os eventos:

Repeat while ("Player 1") Pressed Fire 1
(Active) Shoot ("bala") at speed 100

Agora, teste. Ficou rápido demais não? Ele precisa atirar mais devagar. Mas, como isso? Temos que estabelecer mais uma condição para o evento. Assim, a ação só se realizará se as duas condições forem cumpridas. Nós precisamos fazer com que enquanto o jogador estiver pressionando o botão, a cada cinquenta centésimos de segundos, ele atirar. Mas como fazer isso? É o que nós vamos ver nessa matéria.

Matéria:
Agora vamos resolver nosso problema do tiro. O que nós precisamos fazer é simples: adicionar outra condição, e essa seria um Every 00"-50 (A Cada 50 centésimos de segundos). Como fazer isso? É baba também.

Clique com o botão direito do Mouse sobre a primeira condição (no caso, a de pressionar o botão), e escolha a opção Insert (Inserir).

Clique com o botão direito sobre a primeira condição, e selecione a opção Inserir

Então, abrirá uma janela para você escolher a nova condição. Escolha, e veja que uma nova condição foi adicionada ao evento.

Adicionando a nova condição

Note que a nova condição foi adicionada ao evento

Pronto, vai ficar assim:
Repeat while ("Player 1") Pressed fire 1
Every 00"-50
(Active) Shoot ("bala") at speed 100

Algumas condições como a On loop, da classe Special (a do computadorzinho), precisam ficar no topo do evento. Não precisa entender esse negócio de Fast Loop por ora; não é aí que eu quero chegar. A questão é que certas condições só funcionam se estiverem no topo do evento. E algumas, não funcionam de jeito nenhum (como a Is the timer equal to a certain value). Para mover uma condição, simplesmente selecione-a e arraste-a até o local desejado, assim como você arrasta um ícone na sua Área de Trabalho.

Arrastando o Every para o topo

Every no topo

O Every realmente não precisa ficar no topo. Eu fiz isso só pra mostrar pra vocês como trocar o lugar de duas condições.

Colocando em prática o que aprendemos:
Agora, outro exercício. Já resolvemos o problema do tiro, agora vamos fazer alguma outra coisinha só pra fixar. Na verdade, é capaz que o que nós vamos fazer agora, nunca vá ter alguma utilidade pra você, mas vamos fazer assim mesmo só pra grudar na cabeça, certo?

Adicione um movimento de plataforma no Active Object. Não precisa mudar nada no Movimento. Agora adicione o seguinte evento:

Repeat while ("Player 1") Moved down
(Active) Stop

Ou seja, enquanto o jogador estiver apertando pra baixo, vai parar o movimento do Active. Pronto, agora insira uma nova condição: Repeat while ("Player 1") Moved top.

Vai ficar desse jeito:

Repeat while ("Player 1") Moved down
Repeat while ("Player 1") Moved top
(Active) Stop

Ou seja, enquanto o jogador estiver apertando para cima e para baixo, vai parar o movimento do personagem.

Finalizando:
Combinar condições é algo fundamental na criação de jogos. Por isso é importante que você tenha entendi tudo dessa matéria. Se você não entendeu, ~~você é um bocó~~ leia de novo, porque um dia você ainda vai precisar combinar condições. A propósito, lembra da matéria sobre Counters? Agora que você leu essa matéria, vai achar inúmeras utilidades para eles. Antes de saber combinar condições, os Counters não tinha muita utilidade. Agora, eles podem fazer coisas incriveis. É só pensar um pouco.

Bom galera, por hoje é só.
Falow o/

Sprites - Sonic

2010-01-22T21:32:00.000-02:00

Bem pessoal meu nome é Douglas mais conhecido como DragonSky, e vou estar dando alguns posts por aqui.

Certo então como acabei de chegar já me botaram para trabalhar XD

Bem vamos começar com Sprites do Sonic.

Sonic 3 & Knuckles - Sonic

Sonic 3 & Knuckles - Tails

Sonic 3 & Knuckles - Knuckles

Bem por hoje é só pessoal. Mais para frente vou trazendo mais sprites ^^

Kenshin BG

2010-01-20T17:06:00.001-02:00

Sem SS

Informações Técnicas:

Cenário: Kenshin BG
Descrição: É o dojo Kamiya (dojo onde o Samurai X vive) incendiado.
Origem: Sei lá
Autor: Não entendo Koreano
Criado em: ???
Versão: WinMugen
Última Atualização: ???
Tamanho: 273KB

Download Link:

MediaFire

Kenshin Character

2010-01-20T17:05:00.001-02:00

Sem SS

Informações Técnicas:

Personagem: Kenshin Himura
Descrição: É o personagem principal da série Samurai X para o Mugen
Origem: Sei lá
Autor: Não entendo Koreano
Criado em: ???
Versão: WinMugen
Última Atualização: ???
Tamanho: 1,62

Download Link:

MediaFire

Teste

2010-01-19T20:26:00.001-02:00

Teste