Criando jogos de quebra-cabeça no Puzzle Script

O Puzzle Script é um mecanismo de jogo minimalista para a criação de quebra-cabeças para HTML5, possui fontes abertas. Exemplos de jogos prontos podem ser encontrados aqui .

Parte 1. Criamos o primeiro jogo no Puzzle Script.

O Puzzle Script é um programa online gratuito usado para criar jogos de quebra-cabeça. Ela é mais conhecida por criar quebra-cabeças como o meu The Nodus . Nesta parte, criaremos um jogo, tendo estudado as funções básicas do Puzzle Script, e na próxima iniciaremos a programação.


Vá para o site do mecanismo. Clique em Criar um jogo para abrir o editor de Script de quebra - cabeça .

Exemplos de download

Para começar, vejamos alguns exemplos. Na parte superior da tela, abra a lista "Carregar exemplo" e selecione o primeiro exemplo chamado "Básico". Agora clique em "Executar".



A tela do jogo aparecerá. Clique dentro da janela e pressione Enter no teclado.


Tente jogar o jogo. Seu objetivo é empurrar as caixas laranja para os quadrados pretos do alvo. Quando houver uma caixa em cada alvo, o nível será passado. Você pode pressionar Z para cancelar o movimento ou R para reiniciar o nível.

Faça o primeiro jogo

Agora vamos criar vários níveis. Vou criar um junto com você e aconselho os outros a criarem o meu. Clique em "Level Editor" no menu superior.


Se você não vir a tela do editor de níveis, clique em "Executar" e inicie o jogo. Uma vez no nível, clique novamente no botão "Editor de Nível". Isso permitirá que você edite o nível em que estava apenas.

Crie um novo nível

No topo estão os objetos do jogo. Ao clicar com o botão esquerdo, o objeto selecionado é desenhado. Clique com o botão direito do mouse para desenhar um objeto "plano de fundo". Clicar com o botão esquerdo na borda do mapa aumenta seu tamanho; clicar com o botão direito reduz-o.


Para passar de nível, você precisa colocar uma caixa em cada uma das metas; portanto, em cada nível, deve haver um mínimo:

• 1 caixa
• 1 golo
• 1 jogador

Clique com o botão direito do mouse para transformar tudo em grama. Em seguida, clique com o botão esquerdo na borda do nível para aumentá-lo e, finalmente, desenhe um nível parecido com o mostrado abaixo.

Adicione-o à lista de níveis.

Depois de criar o nível, vamos adicioná-lo à lista de níveis. No editor de níveis, clique na letra branca S ao lado da lista de objetos do jogo para salvar o nível criado.


Uma mensagem sobre compilação bem-sucedida e uma grade de personagens engraçados deve ser exibida abaixo do editor de níveis, como mostrado abaixo.


Esses personagens engraçados indicam o nível que acabamos de criar. Cada caractere representa um objeto separado. No lado esquerdo da tela, desça e encontre LEGEND. A legenda fornece uma explicação para cada um dos personagens:

. = Histórico
# = Mural
P = jogador
* = Caixa
@ = Caixa e destino
O = alvo

Tudo o que está no lado esquerdo da tela é o código do jogo, dividido em partes diferentes, como OBJETOS ou LEGENDA. Desça até NÍVEIS. Aqui vemos os níveis que são usados ​​no exemplo.


Para adicionar um novo nível, crie uma nova linha vazia na parte inferior da seção de nível. Em seguida, copie os caracteres gerados para o nosso nível e cole-os lá. Todo o nível adicionado.


Vamos testar. Depois de criar um novo nível, você precisa pressionar o botão "Executar" na parte superior da tela novamente para reiniciar o jogo com um novo nível. Às vezes, isso não funciona, e você precisa clicar no botão "Reconstruir" e, em seguida, clicar em "Executar" novamente.

Salvando e carregando um jogo

Tente criar mais alguns níveis novos. Quando você estiver pronto para salvar o jogo, vá até o início do código e digite seu próprio nome, nome do autor e página inicial e clique no botão "Salvar".



Um número limitado de salvamentos é armazenado no menu “Carregar” do seu computador. No entanto, existe um botão "Compartilhar" na parte superior da tela. Quando você clica nele, uma mensagem com dois links da web é gerada.


Um dos links é o código fonte do seu projeto. O segundo é um link para uma versão jogável do jogo que você pode compartilhar com os amigos. Eu recomendo criar periodicamente um novo link para o código-fonte e salvá-lo em um documento de texto para que você tenha uma versão permanentemente armazenada do projeto.

Exportação de jogos

Você também pode exportar o jogo como um arquivo html5, que pode ser carregado nos portais do jogo, como itch.io , Kongregate ou Newgrounds . Basta clicar em "Exportar" e enviar o arquivo html baixado para o portal do jogo.

Nosso projeto de amostra pode ser encontrado aqui .

Parte 2. Introdução ao Script do Puzzle

Nesta parte, aprenderemos como começar a programar no Puzzle Script .

Código

Abra um projeto de amostra . O código do programa está no lado esquerdo da tela, é dividido em partes: objetos, legenda, sons etc. Na seção Regras, regras para a interação de objetos são definidas. Entre nisso. Deve haver apenas uma linha de código:

[ > Player | Crate ] -> [ > Player | > Crate ]

Essa linha significa que, se o jogador estiver perto da caixa e se mover em sua direção, o jogo moverá o jogador e empurrará a caixa. Para explicar como isso funciona, você precisa entender que o código do Script de quebra-cabeça segue esta estrutura:

[ ] -> [ ]

Isso significa o seguinte:

[ ] -> [ ]

O Script de quebra-cabeça verifica as condições à esquerda da seta, por exemplo, se o objeto do jogador está próximo ao objeto da caixa. Se a condição for verdadeira, faremos algo, por exemplo, empurrar a caixa.

Exemplos de condições

Aqui está um exemplo de uma condição:

[ object1 | object2 ]

Este evento verifica se o objeto1 está próximo ao objeto2. Você pode verificar se dois objetos estão próximos um do outro, colocando uma | | inserida pressionando shift + \. As condições são sempre colocadas [ ] .

[ crate | crate ]

O código acima verifica se duas caixas estão próximas uma da outra.

[ crate | crate | crate ]

Essa condição verifica se três caixas estão próximas.

[ crate target ]

Essa condição verifica se a caixa está no topo do destino porque a | | entre dois objetos. Os objetos podem estar em cima uns dos outros se estiverem localizados em diferentes camadas de colisões, que abordaremos nas seguintes partes do tutorial.

Mantemos a igualdade

As regras devem ser equilibradas. A verificação da condição e o evento a seguir devem ser descritos da mesma maneira. Vou mostrar o que isso significa.

[ player | crate ] -> [ player | ]

Essa linha de código destrói a caixa se o jogador estiver próximo a ela. Você não pode escrever:

[ player | crate ] -> [ player ]

porque a condição à esquerda verifica a presença de objetos vizinhos em dois espaços de grade separados, mas o evento descreve apenas um espaço de grade que o jogador ocupa. O Puzzle Script precisa saber o que fazer com os espaços verificados. O código correto para destruir a caixa deve relatar o seguinte:

[ | ] -> [ | ]

[ player | crate ] -> [ player | ]

Ou seja, mesmo os espaços vazios no código são importantes. No entanto, a seguinte entrada é válida:

[ player target ] -> [ player ]

Como na condição de que estamos falando apenas de um espaço de grade, o evento descreve o mesmo espaço de grade.

Como mover caixas

Vamos voltar à linha de código original.

[ > Player | Crate ] -> [ > Player | > Crate ]

Em outras palavras:

[ | ] -> [ | ]

Seta> enfatiza o movimento.

Às vezes, precisamos escrever comentários para lembrar o que o código faz. O Script de quebra-cabeça ignora os comentários - eles são apenas para o usuário. Para escrever um comentário, você precisa colocar o texto entre colchetes. Escrevemos um comentário sobre nossa regra que descreve o que ela faz:

( )
[ > Player | Crate ] -> [ > Player | > Crate ]

Agora, sob o código de envio da caixa, escreva o seguinte:

( )
[ < Player | Crate ] -> [ < Player | < Crate ]

A seta invertida significa que, se o jogador se afastar da caixa, ele puxa a caixa. Clique em "Executar" para testar esta ação. Você deve poder empurrar e arrastar caixas. Na programação, mesmo com um erro de digitação em uma letra, o computador pode não entender o código, portanto, livre-se de todos os erros. Ao fazer alterações no código, clique em "Executar" novamente para fazer o download das alterações. Se o jogo não se comportar como deveria, tente clicar em "Reconstruir" para limpar a memória do programa e clique em "Executar".

Às vezes é necessário desativar uma linha de código. Basta transformá-lo em um comentário para economizar no futuro. Vamos comentar o código para empurrar caixas, para que o jogador possa carregar apenas caixas:

( )
([ > Player | Crate ] -> [ > Player | > Crate ])
( )
[ < Player | Crate ] -> [ < Player | < Crate ]

Se isso funcionou, comente o código para puxar as caixas e tente o seguinte:

[ < Player | Crate ] -> [ < Player | > Crate ]

Se o jogador se afastar da caixa, ele e a caixa se moverão em direções opostas. As setas determinam em qual direção o objeto está se movendo ou se moverá. Agora, comente isso e tente o seguinte:

[ > Player | Crate ] -> [ Player | > Crate ]

A caixa se move, mas o jogador permanece no lugar. Experimente ^ e v (letra v) para ver como os objetos se moverão.

Erros

Vamos escrever intencionalmente a regra errada e ver o que acontece. Digite a seguinte linha:

[ < Player | Crate ] -> [ < Player ]

Tente executar o programa. Você deve ver uma mensagem como esta:

linha 81: Em regra, cada padrão a corresponder à esquerda deve ter um padrão correspondente à direita de igual comprimento (número de células).

Normalmente, o Puzzle Script descreve muito bem o erro. No entanto, às vezes, o Puzzle Script é confundido por si só. Nesses casos, você precisa analisar o código por conta própria e descobrir onde está o erro.

Mais algumas experiências

Tente experimentar e escreva as regras você mesmo. Aqui estão alguns exemplos.

[ > Player | … | Crate ] -> [ > Player | … | > Crate ]

No exemplo acima, o jogador empurrará a caixa se estiver em qualquer lugar na mesma linha do nível, e o jogador se moverá para a caixa.

[ > Player | Crate ] -> [ Crate | Player ]

Este código troca o player e a caixa.

[ > Player | Crate ] -> [ Player | Target ]

Nesse código, se o jogador estiver perto da caixa e se mover em direção a ela, o jogador irá parar de se mover, mas a caixa se tornará um alvo. A melhor coisa sobre o Puzzle Script é a facilidade de criar coisas novas e a possibilidade de experimentação.

Parte 3. Criando Objetos

Todos os fragmentos gráficos nos jogos do Puzzle Script indicam objetos. Para criar jogos no Puzzle Script, você deve criar seus próprios objetos. Nesta parte, mostrarei como criá-los e adicioná-los ao meu código.

Informação geral

Abra um projeto de amostra . O processo de criação de um objeto consiste nas seguintes etapas:

• Crie-o na lista de objetos
• Adicionando um item a uma legenda
• Adicionando colisões a uma camada

Depois de executar todas essas etapas, você pode começar a usar o objeto.

Criação de Objetos

Vários objetos já existem. Cada jogo deve ter um objeto em segundo plano. Todos os objetos são criados a partir de uma grade de 5 x 5 pixels e têm pelo menos uma cor. O objeto de plano de fundo é mostrado abaixo.

Background
LIGHTGREEN GREEN
11111
01111
11101
11111
10111

Os números indicam pixels na imagem. Cada número corresponde à sua cor. A primeira cor tem o número 0, a segunda - 1 e assim por diante até 9. Pode haver até dez cores. No nosso caso, cada 1 pinta o pixel em verde claro (verde claro) e 0 - em verde (verde). O resultado fica assim:


Os objetos são sempre criados da seguinte maneira:

• Título
• Cores
• Imagem

O nome está sempre na linha superior. As cores estão sempre na segunda linha e a imagem ocupa as próximas 5 linhas, 5 caracteres por linha, formando uma grade 5 x 5. Ou você pode fazer o seguinte:

Background
LIGHTGREEN

Este código criará um objeto chamado "Plano de fundo", que será uma grade de 5 x 5 pixels em verde claro. Se você não descrever a grade da imagem, obteremos um bloco de cores sólidas, que às vezes pode ser útil.

Dar nomes aos objetos

Os objetos podem ser chamados como você quiser, mas o nome não pode começar com um símbolo e deve ser uma única palavra sem espaços. Dê aos objetos nomes claros, mas não exagere. PlayerStill é um bom nome, PlayerThatIsStandingStill é muito longo e detalhado.

Cores

Você deve declarar as cores que deseja usar para o objeto e separá-las com um espaço. O Script do Quebra-cabeça possui cores predefinidas:

• preto
• branco
• cinza
• darkgrey
• lightgrey
• cinza
• cinza escuro
• cinza claro
• vermelho
• darkred
• leve
• castanho
• castanho escuro
• castanho claro
• laranja
• amarelo
• verde
• verde escuro
• verde claro
• azul
• azul claro
• azul escuro
• roxo
• rosa
• transparente

Você também pode definir cores em hexadecimal, o que nos dá uma gama muito maior de cores. Você pode usar sites como esse para selecionar cores hexadecimais. Selecione a cor desejada e reescreva o código de cor acima da imagem. Os códigos de cores hexadecimais são escritos no Puzzle Script da seguinte maneira:


#51A2BD #ff0000 #ffffff

O código de cores é sempre precedido pelo caractere #.

Adicionar um objeto à legenda

Depois de criar o objeto, você precisa adicioná-lo à legenda. A lenda é assim:

. = Background
# = Wall
P = Player
* = Crate
@ = Crate and Target
O = Target

Cada símbolo representa um objeto em um nível. Ou seja, quando vemos uma grade de caracteres:

#p.*.##
#.**.##
#..#..#
##....#
##...o#
#######

na verdade, descreve o nosso nível:


Cada objeto criado deve receber uma letra, símbolo ou número que designe esse objeto no nível. Assim:

P = player

Agrupar objetos na legenda

Também podemos criar grupos de objetos na legenda. Por exemplo, se tivermos várias caixas multicoloridas, podemos fazer o seguinte:

O = OrangeCrate
B = BlueCrate
G = GreenCrate

Isso nos permitirá usar caixas no nível do editor. Mas para criar o código, você pode agrupá-los no Legend, assim:

Crates = OrangeCrate or GreenCrate or BlueCrate

E todos juntos ficarão assim:

=======
LEGEND
=======
O = OrangeCrate
B = BlueCrate
G = GreenCrate

Crates = OrangeCrate or GreenCrate or BlueCrate

Por que fazer isso? Porque então, em vez de criar essas regras:

[ > Player | OrangeCrate ] -> [ > Player | > OrangeCrate ]
[ > Player | BlueCrate] -> [ > Player | > BlueCrate ]
[ > Player | GreenCrate] -> [ > Player | > GreenCrate]

você pode simplesmente escrever:

[ > Player | Crates ] -> [ > Player | > Crates ]

E esse código funcionará para todo o grupo de objetos.

Além disso, na seção Camadas de colisão , você pode consultar a camada em que o grupo está localizado, em vez de inserir cada objeto individual.

Camadas de colisão

Por padrão, a seção da camada de colisão é a seguinte:

Background
Target
Player, Wall, Crate

Cada linha seleciona objetos em sua própria camada. A ordem das camadas de objetos determina quais objetos estarão sobre os outros. Os objetos na linha superior estarão na camada inferior, a próxima linha estará na camada acima dela e assim por diante. O plano de fundo sempre deve estar na linha superior para estar na camada inferior. Objetos em uma camada não podem estar em cima uns dos outros. Ou seja, isso não pode ser:

[ player wall ] -> [ player wall ]

Você pode fazer objetos em diferentes camadas interagirem entre si. Por exemplo, você pode escrever:

[ > Player | Target ] -> [ > Player | > Target ]

Um experimento

Crie alguns novos objetos. Crie um tipo de caixas que você só pode enviar por push. Crie outra caixa que só pode ser arrastada. Crie uma caixa que desaparece quando você toca nela. Continuando os experimentos, você se lembrará melhor de como tudo é feito.

Parte 4. Condições de vitória

Todo mundo gosta de ganhar. Nós, como jogadores, queremos ganhar. Nesta parte, aprenderemos como programar as condições para ganhar um jogo.

Condições de vitória

Faça o download do projeto de amostra e vá para a seção de código Condições de vitória. Você deve ver o seguinte:

All Target on Crate

O jogo é ganho se houver uma caixa em cada gol. Se você tem 3 caixas e 2 gols, ganha com apenas 2 caixas nos gols. Se estiver trocando:

All crate on target

então cada caixa terá que estar no alvo.

Pode haver uma ou várias condições. No caso de múltiplas condições, todas elas devem ser satisfeitas. Por exemplo, podemos ter o seguinte:

All Target on Crate
All Target2 on Crate2

Se o nível tiver target e target2, crate e crate2, respectivamente. Se no nível não houver um dos objetos necessários para atender a uma determinada condição de vitória, por exemplo, não há alvo2, essa condição será satisfeita automaticamente.

Diferentes tipos de condições de vitória

Existem vários tipos diferentes de condições de vitória.

No Object

Nesse caso, a vitória ocorre quando não existe um desses objetos no nível.

Some Object

Você ganha quando há pelo menos um objeto do tipo especificado no nível.

Some Object1 on Object2

Pelo menos um dos objetos do Object1 deve estar no Object2.

No Object1 On Object2

Essa condição é o oposto de All Target on Crate . Nesse caso, precisamos que todos esses objetos sejam separados um do outro e não um em cima do outro. Você também pode combinar diferentes condições de vitória.

Um experimento

Vamos experimentar diferentes condições de vitória. Tente criar um jogo no qual a vitória ocorra se todas as caixas não estiverem no alvo. Ou faça um jogo em que você precisa destruir todas as caixas de um determinado tipo, mas há outras caixas empurradas no seu caminho.

Meu projeto de exemplo concluído pode ser visto aqui .

Parte 5. Comando atrasado

O PuzzleScript possui um comando muito útil chamado "tarde". A ordem de origem dos eventos no jogo é importante e, às vezes, você precisa de um código que seja executado posteriormente para obter os resultados desejados. Nesta parte, falarei sobre o uso do comando late .

Por que precisamos disso

Abra um projeto de exemplo , cole o seguinte código no jogo e execute-o:

[ player | target ] -> [ player | ]

Pode-se esperar que, assim que o jogador estiver próximo ao gol, o gol será destruído, mas isso não acontece. Em vez disso, o alvo desaparece no percurso depois que o jogador fica ao lado dele. Então tente outro código:

late [ player | target ] -> [ player | ]

Assim que você estiver próximo ao objetivo, ele desaparecerá. Isso aconteceu porque tudo designado como atrasado acontece depois que todo o restante do código é executado. Às vezes isso é necessário.

Ordem dos eventos

Veja como o código no Puzzle Script é executado a cada movimento.

1. Script de quebra-cabeça descobre que o jogador quer se mover
2. Sempre que possível, as regras são lidas e executadas de cima para baixo.
3. O jogador se move se possível
4. Aplicam-se regras tardias

O computador inicia na linha superior do código e lê, linha por linha. verificando todas as condições. Portanto, quando você tenta se movimentar, o Puzzle Script lê todas as regras e verifica se as condições são verdadeiras e, nesse caso, faz alguma coisa. Por exemplo, a primeira linha pode ser assim:

[ player | spikeTrap ] -> [ | spikeTrap ]

Se o jogador não estiver ao lado da armadilha da estaca, o código continuará a execução. Isso significa que a ordem de escrever linhas de código é importante. Você pode usar o comando late em alguns casos, que aprenderá com o tempo na prática.

Maneiras de usar o atraso na prática

Na minha experiência, é melhor usar o comando late quando estiver verificando se os objetos estão em cima uns dos outros ou próximos um do outro, mas existem outros casos. Se você verificar se um objeto está em outro, o evento não será registrado até a próxima curva, a menos que você use o comando late:

[ player spikeTrap ] -> [ spikeTrap ]

No caso acima, o jogador não será morto por uma armadilha com apostas até o próximo turno depois de passar para a armadilha. Para fazer o jogador morrer instantaneamente, basta adicionar o comando late,

late [ player spikeTrap ] -> [ spikeTrap ]

Para reiniciar o nível inteiro quando o personagem morre, você pode fazer o seguinte:

late [ player spikeTrap ] -> restart

E o nível será reiniciado quando o jogador cair na armadilha com apostas.

Você pode ver o exemplo de projeto finalizado aqui .

Parte 6. Trabalhe com efeitos sonoros.

Fizemos um ótimo jogo no Puzzle Script , mas agora precisamos adicionar sons a ele. Como fazer isso? Agora eu vou te contar!

Geração de som

Abra um projeto de amostra . Adicione sons a ele. Sob a tela do jogo, você pode ver quadrados pretos com símbolos brancos. Eles são usados ​​para gerar som. Cada personagem gera um tipo único de som e uma cruz exclui os sons criados. Tente clicar nos quadrados e ouvir os sons.


Números amarelos são códigos únicos que precisam ser copiados e colados em locais do código em que os sons são necessários.

Como usar sons

Depois de encontrar o som certo, você deve inseri-lo na seção Sons do código do jogo.


Os sons podem ser usados ​​de várias maneiras. O mais fácil é criar um novo efeito sonoro (sfx). Eles devem ser numerados. Criamos um novo sfx, atribuindo um número de 0 a 10 ao inserir um ID de som numérico. Na lista Sons, crie um novo sfx chamado sfx0 e atribua a ele o som gerado:

sfx0 36301705

Para usar o som, você precisa inseri-lo nas regras após o evento. Vamos anexar o sfx0 recém-criado ao evento de destruição da caixa (o evento já está presente no exemplo do projeto):

(The player destroys a crate)
[ > Player | CrateVanish ] -> [ Player | ] sfx0

Os sons também podem ser declarados para reprodução com determinados eventos, por exemplo:

Crate MOVE 36772507

Nesse caso, o som será reproduzido quando você mover a caixa. Gere um novo efeito sonoro para arrastar e soltar objetos CratePull e faça com que seja reproduzido quando você move o CratePull:

CratePull MOVE 12735307

Os sons dos eventos devem ser declarados apenas na seção Sons: eles não precisam ser mencionados nas regras.

Lista de métodos de reprodução de som

Abaixo está uma lista dos vários sons de eventos que você pode usar, extraídos da documentação do Puzzle Script.

Ação do objeto 541566 - é reproduzida quando um objeto é exposto a uma ação durante uma movimentação.

Criação de objeto 641667 - reproduz ao criar um objeto específico.

EndGame 5416789 - joga quando o jogo termina.

Nível final 6417822 - é reproduzido após a conclusão do nível.

Objeto CantMove 781673 - é reproduzido quando um objeto tenta, sem êxito, mover-se em qualquer direção.

Jogador CantMove Down Left 464674 - é reproduzido quando um objeto tenta mover-se para baixo ou para a esquerda sem sucesso.

CloseMessage 344456 - é reproduzido quando o player fecha a caixa de mensagem.

Object Destroy 187975 - é reproduzido quando um objeto é destruído.

Mover objeto 264567 - é reproduzido quando um objeto se move com sucesso em qualquer direção.

Mover para baixo do objeto para a esquerda 765432 - reproduz quando o objeto foi movido para baixo ou para a esquerda com êxito.

Mover objeto na horizontal 345367 - é reproduzido quando o objeto foi movido com sucesso na horizontal. Você também pode usar Vertical.

Reiniciar 7865435 - é reproduzido quando um jogador pressiona o botão de reinicialização R.

SFX0 765743 - pode ser qualquer coisa, de SFX0 a SFX10. Estes são eventos sonoros especiais que podem ser executados a partir das regras.

ShowMessage 478483 - reproduz quando uma mensagem é exibida.

StartGame 234626 - joga no início de um novo jogo.

Nível inicial 765436 - é reproduzido no início de cada nível.

TitleScreen 876543 - reproduz após o carregamento do protetor de tela.

Desfazer 436234 - é reproduzido quando um jogador pressiona a tecla Cancelar (Z).

Você pode especificar as direções para mover e mover para que, ao se mover em direções diferentes, sons diferentes sejam reproduzidos.

Um exemplo pronto do projeto está aqui .

Parte 7. Tocar música

Aprendemos como criar jogos no Puzzle Script, mas não seria ótimo adicionar música a eles? É possível, e agora vou lhe dizer como fazê-lo.

Nota: parece que, no momento em que esta função está quebrada, siga para a próxima parte.

O que fazer

Abra o projeto em branco . A música funciona no Puzzle Script da seguinte maneira: você pode inserir um link para um único vídeo do Youtube no jogo.O PuzzleScript reproduzirá automaticamente todos os sons deste vídeo. Abra o Youtube e selecione qualquer vídeo ou use o seguinte:

youtube.com/watch?v= CKAc3nYEatw

Para reproduzir música de um vídeo, precisamos obter um ID de vídeo exclusivo. A parte verde na linha acima é um ID exclusivo.


Sob a página inicial do autor, no início do projeto, adicione o rótulo do youtube e, depois, um ID de vídeo exclusivo, por exemplo, como este:

youtube CKAc3nYEatw

Para garantir que funcione corretamente, clique em "Compartilhar" e clique no link do jogo (não no link do código-fonte). Durante os testes dentro do editor, a música do Puzzle Script não pode ser reproduzida. Se você deseja que o jogo tenha música, é necessário enviá-lo como um vídeo no Youtube e inserir um ID exclusivo no seu projeto. Cada projeto pode ter apenas um vídeo do Youtube.

Exemplo de projeto

Um exemplo de projeto de Script de Puzzle pode ser encontrado aqui .

Parte 8. Como usar o comando Ação

Já sabemos como mover, empurrar e arrastar blocos, mas e se precisarmos fazer algo pressionando uma determinada tecla, como um espaço ?

As possibilidades de entrada no PuzzleScript são bastante limitadas, principalmente teclas de seta, Z para cancelar, R para reiniciar e não podemos alterá-las.Mas o motor dá-nos uma chave extra para ações - pressionando a barra de espaço , ou pressione o X .

O trabalho com a equipe Ação segue o formato descrito acima. Usamos o formato de código básico do PuzzleScript:

[ ] -> [ ]

Se a condição for verdadeira, executamos o evento. O comando action é usado da mesma maneira, mas possui suas próprias regras. É assim:

[ Action ] -> [ ]

Aqui está um exemplo do uso do comando Action:

[ Action Player ] -> [ Crate ]

Primeiro, ação é sempre a primeira palavra de uma condição.

Em segundo lugar, se queremos influenciar um determinado objeto no jogo, precisamos mencionar esse objeto tanto na condição quanto no evento (se mencionarmos outro objeto, o programa excluirá o original e o substituirá por um novo, e se você não especificar o objeto, então ele apenas se aposentará).

Finalmente, a palavra Ação deve ser usada apenas na condição , mas às vezes vale a pena usá-la na condição e no evento. Vou falar sobre isso abaixo.

Verifique o código mostrado acima no projeto do jogo. Você pode começar com este exemplo . Você verá que, ao pressionar a barra de espaço ou X, o jogador se torna uma caixa.

A condição diz [ Se pressionarmos a tecla Ação e houver um objeto Player no nível ] -> then [ substituir o objeto player por uma caixa]

Agora, vamos tentar o seguinte código no exemplo do projeto:

[ Action Player | Crate ] -> [ Player | > Crate ]

Certifique-se de estar cercado por todos os lados por caixas, como na imagem acima. Você notará que uma ação afeta apenas uma caixa de cada vez. Não sei exatamente qual é o motivo, mas se você quiser influenciar vários objetos usando o comando Action , precisará especificá-lo na condição e no evento.

Substitua o código pela versão atualizada:

[ Action Player | Crate ] -> [ Action Player | > Crate ]

Agora podemos empurrar todas as caixas de uma só vez. Se você precisar aplicar uma ação a vários objetos, coloque Ação na condição e no evento.

Parte 9. Verificando várias condições

Vamos aprender a verificar várias condições, por exemplo, a presença de uma bomba E um bloco destrutível.


Abra um projeto de amostra . Agora adicione o seguinte código a ele:

late [Player Switch][DoorClosed] -> [Player Switch][DoorOpen]

O código segue este formato:

[ 1 ] [ 2 ] -> [ 1 ] [ 2 ]

Se a condição 1 for verdadeira e a condição 2 for verdadeira, serão executadas as etapas 1 e 2. No nosso caso, a condição 1 verifica se o Player está no Switch. Se sim, a condição 2 é verificada, ou seja, a presença ao nível de uma porta fechada? Se a condição for verdadeira, o objeto DoorClosed se transformará em um objeto DoorOpen, abrindo a porta.


Suponha que precisamos que a porta se feche quando o herói sair do interruptor, porque queremos que o jogador empurre a caixa no interruptor para abrir a porta. Você pode escrever algo como isto:

late [Player | Switch][DoorOpen] -> [Player | Switch][DoorClosed]

Se o jogador estiver ao lado do interruptor e em algum lugar no nível houver uma porta aberta, então fechamos a porta. Por fim, precisamos que a porta permaneça aberta se pressionarmos a caixa no interruptor:

late [Crate Switch][DoorClosed] -> [Crate Switch][DoorOpen]

Agora a porta permanecerá aberta enquanto a gaveta estiver no interruptor.

Você pode ver o exemplo de projeto finalizado aqui .

Parte 10. Criando pontos de interrupção

Talvez você tenha uma boa idéia para jogar o Puzzle Script, mas ele precisa de pontos de controle (pontos de verificação) para que o jogador os recupere em caso de morte. Como fazer isso? Muito simples, e agora vou explicar como.

Criar pontos de interrupção

Abra um projeto de amostra . Agora precisamos programar um ponto de interrupção. Apenas uma linha de código é suficiente para isso:

late [ Player FlagRed ] -> CHECKPOINT

FlagRed é um ponto de verificação. Quando o jogador está no topo da bandeira, esse código cria um ponto de verificação (CHECKPOINT). Se você não usar tarde, a função de ponto de verificação não funcionará.

Teste o jogo. Vá sobre o ponto de controle e, em seguida, um pouco mais e pressione R. Você precisará começar pelo ponto de controle.

Vários pontos de controle

Se houver vários pontos de controle, o jogo usa o último ativado pelo jogador.

Para evitar a reativação de um ponto de controle já usado, é necessário alterá-lo para outro objeto. Para fazer isso, crie uma cópia branca na seção OBJETOS do código sob a bandeira vermelha.

FlagWhite
White Orange
.1…
.00..
.000.
.1…
.1…

Agora reescreva esta linha na legenda:

Flag = FlagRed or FlagWhite

Nós podemos criar um grupo de objetos. Nesse caso, Flag será FlagRed ou FlagWhite. Enquanto pelo menos um dos objetos agrupados recebe um símbolo (nós atribuímos FlagRed a um símbolo F), não precisamos atribuir símbolos a outros objetos do grupo, e você pode acessá-los apenas no código, mas não no editor de níveis. Em seguida, você pode atribuir camadas de colisão ao grupo, o que fizemos. Um acesso a um grupo de objetos, por exemplo, Flag, refere-se ao grupo inteiro. Portanto:

[ > Player | Flag ] -> [ > Player | ]

Esse código afetará a bandeira vermelha e a branca.

Alterar objeto de sinalizador

Veja como alterar FlagRed para FlagWhite:

late [ Player FlagRed ] -> [ Player FlagWhite ]

Se no final do turno o jogador estiver na bandeira vermelha, então a transformaremos em branca. No entanto, você precisa alterar os gráficos do sinalizador depois de criar o ponto de interrupção, porque o código é lido de cima para baixo. Teste o programa.

Alterar a segunda bandeira

Existem dois sinalizadores no projeto. Vamos garantir que, quando o segundo sinalizador for ativado, o antigo sinalizador branco se torne preto, para que não possa ser usado novamente. Escrevemos o seguinte:

late [ Player FlagRed ][ FlagWhite] -> [ Player FlagRed ][FlagBlack]

O código diz: se o jogador estiver na bandeira vermelha e em algum lugar do jogo houver bandeiras brancas, será necessário que as bandeiras brancas fiquem pretas. Como o código é lido de cima para baixo, precisamos fazer isso na seguinte ordem:

late [ Player FlagRed ] -> CHECKPOINT
late [ Player FlagRed ][ FlagWhite] -> [ Player FlagRed ][FlagBlack]
late [ Player FlagRed ] -> [ Player FlagWhite ]

Se você não entender por que o código deve estar nessa ordem, tente alterar a ordem das linhas e teste o programa. Para resolver seus próprios problemas, você precisa aprender a dar um passo atrás e refletir sobre o que o código faz. Mas vou dar uma dica: quando você joga, onde estão as bandeiras vermelhas durante a última linha do código no exemplo incorreto a seguir?

[ > Player | Crate ] -> [ > Player | > Crate ]
[ > Crate | Flag ] -> [ Crate | Flag ]
late [ Player FlagRed ] -> CHECKPOINT
late [ Player FlagRed ] -> [ Player FlagWhite ]
late [ Player FlagRed ][ FlagWhite] -> [ Player FlagRed ][FlagBlack]

Veja o exemplo do projeto finalizado aqui . Além disso, mostrei a maneira mais fácil de animar. Na próxima parte, falarei sobre a criação de animações mais complexas, como explosões.

Parte 11. Animações

Existem duas maneiras de criar animações no PuzzleScript. Um deles usa tempo real, mas nesta parte não vou falar sobre isso. Outro é usado para animações únicas rápidas, como uma explosão ou um personagem descendo uma escada vertical.

Abra um projeto de amostra . Criaremos uma bomba e uma série de tiros da explosão e os animaremos.

Animação de objeto

Para animações 2D, você precisa de vários desenhos de um objeto que se deslocam de um estado para outro, por exemplo, um sprite de um Mario em execução. Ele contém 4 quadros de animação.


Para simular a transição de um quadro de animação para outro, criaremos vários objetos no PuzzleScript que serão quadros de animação e, em seguida, usaremos o código para alternar entre eles.

Bomb

Crie um objeto dessa bomba.

Bomb
black yellow grey
..1..
..1..
.000.
00020
.000.

Lembre-se de adicioná-lo às camadas e à legenda.

Para animar a explosão, precisamos criar cada quadro da animação como um objeto separado e depois alternar entre eles no código. Vamos criar objetos de explosão.

Explosion1
black yellow grey red
..1..
..1..
.000.
00320
.000.

Explosion2
black yellow grey red
..1..
..1..
.333.
03330
.333.

Explosion3
black yellow grey red
..1..
.333.
33333
33333
.333.

Explosion4
black yellow grey red
.333.
33333
33333
33333
.333.

Explosion5
black yellow grey red
.333.
33333
33.33
33333
.333.

Explosion6
black yellow grey red
.333.
3...3
3...3
3...3
.333.

Explosion7
black yellow grey red
.....
.....
.....
.....
.....

Numerará corretamente os objetos para saber qual quadro da animação precisamos. Depois de adicioná-los às camadas e à legenda, podemos adicionar várias linhas de código.

[Explosion7] -> []
[Explosion6] -> [Explosion7]
[Explosion5] -> [Explosion6]
[Explosion4] -> [Explosion5]
[Explosion3] -> [Explosion4]
[Explosion2] -> [Explosion3]
[Explosion1] -> [Explosion2]
[Bomb] -> [Explosion1]

Tente adicionar esse código e, em seguida, coloque uma bomba no nível e inicie o jogo. Você notará que a cada movimento, a animação da bomba muda em um quadro. Alternando entre objetos, criamos uma animação.

A ordem de alternar entre animações é crítica. O último quadro deve estar no topo e o primeiro - no fundo. Não esqueça que o código é lido de cima para baixo. Se os quadros da animação estiverem em uma ordem diferente, nunca veremos as alterações. Veremos apenas o último quadro e, no nosso caso, a bomba simplesmente desaparecerá. Ele mudará para o primeiro quadro, depois para o segundo e assim por diante, em um quadro, mesmo antes de ver o gráfico. Ao colocar o último quadro no início, em cada turno, veremos a próxima alteração.

Usando novamente

Para animar tudo juntos, precisamos de uma equipe novamente . Novamente significa que, depois de ler todo o código, o PuzzleScript fará uma pausa e, em seguida, ele lerá o código novamente, executando todos os comandos novamente . Pode ser usado para a gravidade, deslizando no gelo e, no nosso caso, para animações. Tudo o que é necessário é reescrever o código da seguinte maneira:

[Explosion7] -> []
[Explosion6] -> [Explosion7] again
[Explosion5] -> [Explosion6] again
[Explosion4] -> [Explosion5] again
[Explosion3] -> [Explosion4] again
[Explosion2] -> [Explosion3] again
[Explosion1] -> [Explosion2] again
[Bomb] -> [Explosion1] again

Teste o jogo. Você verá que toda a animação da bomba é reproduzida imediatamente. Se, na sua opinião, for muito lento ou rápido, a velocidade poderá ser alterada. No início do texto do programa, na página inicial, escreva o seguinte código:

again_interval 0.1

Isso faz parte do que o PuzzleScript chama de prelúdio . É o local em que, antes do restante do código, você pode definir regras adicionais que determinam o comportamento do jogo. Agora a animação deve ser reproduzida mais rapidamente. Tente alterar o número após again_interval e verifique se ele foi alterado.

Você pode ver o exemplo de projeto finalizado aqui .

Parte 12. Gravidade

Normalmente, o PuzzleScript é usado para criar jogos de cima para baixo, mas, na verdade, você pode simular alguns elementos dos side-scrollers, embora com regras limitadas do PuzzleScript, ou seja, elas ainda sejam passo a passo. Nesta parte, vou explicar como implementar a gravidade.

Exemplo de projeto

Abra um projeto de amostra . Eu criei um nível simples, ele tem um jogador, uma caixa na borda e uma porta abaixo. Queremos ter certeza de que, quando um jogador empurra uma caixa de uma borda, ele cai no chão. Também queremos que o jogador caia no chão quando ele sair da borda.

Etapa 1 do outono

Aqui está a primeira parte do código que usaremos:

down [ Player | no Object ] -> [ | Player ]
down [ Crate | no Object no Player ] -> [ | Crate ]

Tente empurrar a caixa pela borda. Você notará que depois de mover a caixa fica no ar, mas após outra jogada ela cai no chão. Aqui algumas coisas acontecem.

Primeiro, vamos falar sobre a palavra - chave down . Ao adicionar para baixo , limitamos a regra ao fato de que ela se aplica apenas na direção descendente. É por isso que a caixa se move para baixo. Se você substituir para baixo na direita , você vai ver que a caixa fica preso na parede da direita, como em um jogo com antigravidade. Tente fazer isso.

Em seguida, faremos algo incomum. Em vez de verificar se o jogador está próximo a um objeto específico (por exemplo, uma caixa), verificamos se ele está próximo a um objeto generalizado. Se você observar a legenda no código de exemplo, verá que definimos objeto como um grupo de objetos, ou seja, a cada uso da palavra objeto, queremos dizer um grupo de objetos. Ou seja, verificamos se há algum desses objetos sob o player. Caso contrário, ordenamos que o jogador ocupe esse espaço vazio e deixe o espaço anterior, por causa da palavra abaixo, seguindo em uma direção descendente.

Mas você também pode notar que, após colidir com uma borda, a caixa não cai até o próximo movimento e atinge instantaneamente o chão. Para eliminar esse travamento atrasado, você pode usar a palavra-chave final:

late down [ Player | no Object ] -> [ | Player ]
late down [ Crate | no Object no Player ] -> [ | Crate ]

Mas como fazê-lo cair gradualmente, quadro a quadro?

Etapa 2 do outono

Agora usamos a palavra-chave aleatória . Reescrevemos o código da seguinte maneira:

random down [ Player | no Object ] -> [ | Player ]
random down [ Crate | no Object no Player ] -> [ | Crate ]

Execute o código. Funciona de maneira muito semelhante ao código anterior, mas com uma diferença importante. A caixa congela no ar, mas cada vez que o jogador se move, ela cai uma célula. Isto é devido à palavra aleatória . A rigor, o random foi projetado para criar jogos com elementos aleatórios, mas foi útil aqui. Força a linha de código correspondente a ser executada uma vez por turno. O PuzzleScript executa cada regra em um movimento o máximo de vezes possível e somente então o jogador vê alterações gráficas. É por isso que parece que a caixa cai no chão instantaneamente. Porém, ao usar a palavra aleatória, permitimos que ela caia apenas uma célula por vez.

Etapa 3 do outono

Agora vamos adicionar a palavra - chave novamente :

random down [ Player | no Object ] -> [ | Player ] again
random down [ Crate | no Object no Player ] -> [ | Crate ] again

Inicie o jogo. Tudo está quase perfeito. A caixa congela por algum tempo no ar, mas se você se mover novamente, gradualmente cai no chão. Já estamos familiarizados com a palavra - chave novamente ; em essência, isso significa que, no final do curso, o PuzzleScript lê o código novamente e tenta executar todos os comandos novamente como um movimento separado, após o qual faz uma pausa e depois os repete quantas vezes for possível. O importante aqui é que ele faz uma pausa entre os turnos novamente , o que nos permite ver a caixa cair.

Última etapa

E o toque final. Para que a caixa caia no chão imediatamente após ser empurrada pela borda, precisamos adicionar outra linha de código acima da que acabamos de escrever:

[moving Player] -> [moving Player] again
random down [ Player | no Object ] -> [ | Player ] again
random down [ Crate | no Object no Player ] -> [ | Crate ] again

A palavra-chave móvel usada entre colchetes [] na frente do player significa que estamos verificando se o player está se movendo. Isso significa que, se um jogador se mover, ordenamos que ele continue se movendo e conduza o time novamente . Então, imediatamente, tudo o que usar a palavra - chave novamente funcionará ; no nosso caso, é uma animação de uma caixa suspensa.

Você pode ver o exemplo de projeto finalizado aqui .

Parte 13. Verificando a direção da viagem

Indicação de direção

Às vezes acontece que você precisa verificar algo em apenas uma direção. Por exemplo, você precisa criar blocos que só podem ser empurrados horizontalmente ou criar um pato que só pode andar para a esquerda.

Seja como for, podemos indicar que os eventos ocorrem apenas em determinadas direções.

Abra o PuzzleScript, crie um jogo baseado no exemplo Básico e substitua-o por Regras pelo seguinte código:

[ Left Player ] -> [ Crate ]

Inicie o jogo e veja o que acontece.

Se você tentar ir para a esquerda, o jogador se transformará em uma caixa. Este é um bom exemplo de como o direcionamento funciona.

Já estamos acostumados ao formato em que expliquei o código do PuzzleScript:

[ ] -> [ ]

Se o evento for verdadeiro, o evento ocorrerá.

Mas agora, quando precisamos verificar as instruções, ele seguirá as novas regras:

[ Movement Direction Object Affected ] -> [ New State of Object ]

Esse é o nosso código anterior:

[ Left Player ] -> [ Crate ]

verifica se o jogador está se movendo para a esquerda ( esquerda ). Nesse caso, substituímos o player pelo objeto box.

Tipos de destinos

Você pode escolher entre os seguintes tipos de destinos:

• Para cima
• Para baixo
• Esquerda
• Direito
• Horizontal (verifica se há movimento horizontal)
• Vertical (verifica se há movimento vertical)

Parte 14. Criando Movimentos Customizados

Por alguma razão, o jogo pode precisar de uma jogada personalizada. Os patos só podem andar para a esquerda, as caixas só podem ser empurradas horizontalmente e assim por diante. É muito fácil de fazer. Vamos dar uma outra olhada no formato de código básico do PuzzleScript:

[ ] -> [ ]

Se a condição for verdadeira, ocorre um evento. Para criar uma movimentação personalizada, faça o seguinte:

[ Condition ] -> [ Movement Direction Object To Move ]

Aqui está a aparência do exemplo:

[ Player | Crate ] -> [ Player | Left Crate ]

Faça o download do PuzzleScript , abra o exemplo Básico , cole este código e veja o que acontece. Vá para a caixa em torno da qual não há paredes.

Você verá que quando um jogador está perto da caixa, ela é empurrada para a esquerda. No entanto, como não há palavra-chave Late , isso acontece no curso após o primeiro passo em direção a ela.

Ao especificar no Evento, além do objeto, a direção do movimento , por exemplo Esquerda , o PuzzleScript tentará mover o objeto na direção especificada. É por isso que a caixa, e não o jogador, se move para a esquerda - a esquerda fica ao lado da caixa .

Lembra-se deste código da parte anterior?

[ ] -> [ ]

Se você indicar a direção do movimento na condição próxima ao objeto, verificará se esse objeto está se movendo nessa direção. Essa é uma diferença importante. Você pode reescrevê-lo assim:

[ ] -> [ ]

Movimentos personalizados permitidos

Movimentos personalizados podem ser criados com qualquer uma destas palavras:

• Para cima
• Para baixo
• Esquerda
• Direito

Você não pode usar Horizontal ou Vertical , porque o PuzzleScript não entenderá em qual direção você deseja mover o objeto ou, para fazer isso, serão necessárias várias soluções alternativas. É necessário indicar uma direção específica.

Parte 15. Verificando células ao lado de objetos

Às vezes é necessário verificar o que está próximo ao objeto. Isso é bem fácil de fazer. Vamos dar uma outra olhada no formato do código PuzzleScript:

[ ] -> [ ]

isso é

[ ] -> [ ]

Para verificar o lado do objeto, precisamos adicionar um elemento. O formato é o seguinte:

[ object1 | object2 ] -> [ object1 | object2 ]

Antes da condição, verificamos em que lado do objeto queremos realizar a verificação.

Dentro da condição, assumimos que são necessárias pelo menos duas células. Uma célula é, de fato, qualquer objeto que esteja no mesmo espaço e não próximo um do outro.

[ ]

[ | | ]

A primeira célula é o objeto cujos lados estamos verificando. A segunda célula é o objeto cuja presença estamos verificando. Tente os seguintes exemplos:

Left [ Player | Crate ] -> [ Player | ]

O código mostrado acima exclui as caixas se elas estiverem no quadrado à esquerda do jogador.

Left [ Crate | Crate ] -> [ Player | Crate ]

Este código verifica se a caixa está à esquerda de outra caixa. Nesse caso, a caixa cujo lado está marcado se tornará o novo objeto do jogador.

Left [ Crate | Crate ] -> [ Crate | Player ]

No código acima, há a mesma verificação, mas a caixa à esquerda se torna o objeto do jogador.

Left [ Crate | Crate | Crate ] -> [ Crate | Player | Crate ]

Este código também usa um padrão semelhante. A caixa imediatamente à esquerda do marcado se torna um jogador se três caixas estiverem próximas uma da outra na horizontal.

Left [ Crate | Crate | Crate ] -> [ Crate | Crate | Player ]

Se três caixas estiverem próximas uma da outra na horizontal, a caixa mais à esquerda se tornará um jogador.

Se você testar cada um desses exemplos, começará a entender o padrão. A primeira célula é o objeto que verificamos para ver o que vem a seguir. As células a seguir, da mais próxima à mais distante, são os objetos que verificamos.

Palavras-chave

• Up - verifica um objeto
• Para baixo - verifica sob o objeto
• Esquerda - verifica à esquerda do objeto
• Direita - verifica à direita do objeto
• Horizontal - verifica à esquerda e à direita do objeto
• Vertical - verifica acima e abaixo do objeto