Como programar jogos de computador (com imagens)

2024 Autor: Robert Blare | [email protected]. Última modificação: 2024-01-31 12:19

Você tem uma ideia para um jogo de computador e quer torná-la real? Ou você já se perguntou como os jogos de computador são escritos? Este wikiHow ensina como escrever três jogos básicos de computador em Python. Você precisará de um conhecimento básico de Python e de conceitos gerais de programação para desenvolver seu primeiro jogo.

Passos

Parte 1 de 3: Fazendo um jogo baseado em texto

Etapa 1. Escolha uma linguagem de programação

Todas as linguagens de programação são diferentes, então você terá que decidir qual usar para escrever seu jogo. Todas as principais linguagens de programação suportam entrada de texto, saída de texto e construções if (as principais coisas que você precisa para um jogo simples baseado em texto), então explore as opções e decida com qual você se sente mais confortável e dedicado ao aprendizado. Aqui estão alguns fatores a serem considerados:

Qual é a linguagem mais usada?

Algumas linguagens de programação, como JavaScript, são projetadas para uso na web, enquanto outras, como Python, C ou C ++, são projetadas para executar programas de computador. Para seu jogo, procure uma linguagem com uma gama de uso mais ampla, como Python, C, C ++ ou JavaScript.
É difícil aprender?

Embora escrever um programa deva ser fácil o suficiente depois de alguma prática em qualquer linguagem de programação normal (ou seja, não uma especificamente projetada para ser confusa como Malbolge), alguns são mais amigáveis para iniciantes do que outros. Java e C, por exemplo, exigirão que você entenda conceitos de programação mais profundos do que algo como Python, que é conhecido por sua sintaxe mais acessível e direta.
Onde posso usar?

Você provavelmente deseja que pessoas em sistemas diferentes, como Linux, Mac ou Windows, possam jogar seu jogo. Portanto, você não deve usar uma linguagem com suporte apenas em alguns sistemas, como Visual Basic, que é compatível apenas com Windows.

Este artigo usará Python para os exemplos de um jogo baseado em texto, mas você pode ver como os conceitos são feitos em qualquer outra linguagem de programação.

Etapa 2. Prepare seu computador

Os dois componentes principais de que você precisa são um editor de texto, no qual escreverá seu código, e um compilador, que usará para transformá-lo em um jogo. Se quiser seguir o exemplo deste artigo, você deve instalar o Python e aprender a executar programas. Se desejar, você pode configurar um IDE (Integraded Desktop Environment), que combina edição, compilação e depuração em um único programa. O IDE do Python é denominado IDLE. Mas você também pode usar qualquer editor de texto que suporte texto simples, como o Notepad para Windows, TextEdit para macOS ou Vim para Linux.

Etapa 3. Escreva algum código para saudar o jogador

O jogador vai querer saber o que está acontecendo e o que ele tem que fazer, então você deve imprimir algum texto para ele.

Isso é feito com a função print () em Python. Para experimentar, abra um novo arquivo com a extensão.py, digite o seguinte código nele, salve e execute-o:
```
print ("Bem-vindo ao jogo de adivinhação de números!") print ("Digite um número inteiro entre 1 e 1000:")
```

Etapa 4. Gere um número aleatório

Vamos fazer um jogo baseado em texto que peça ao jogador para adivinhar o número correto. A primeira coisa que precisamos fazer é gerar um número aleatório no início do jogo para que o jogador nem sempre adivinhe o mesmo número. Uma vez que o número permanecerá o mesmo em todo o programa, você desejará armazenar o número aleatório em uma variável.

Python não tem uma função de número aleatório embutida, mas tem uma biblioteca padrão (isso significa que o usuário não terá que instalar nada extra) que faz. Portanto, vá para o início do seu código (antes das funções print ()) e digite a linha import random.
Use a função aleatória. É chamado de randint (), está na biblioteca aleatória que você acabou de importar e assume os valores mínimo e máximo que o número pode ter como argumento. Portanto, volte ao final do seu código e insira a seguinte linha:
```
rightNum = random.randint (0, 1000)
```

Etapa 5. Obtenha informações do jogador

Em um jogo, o jogador deseja fazer algo ou interagir com algo. Em um jogo baseado em texto, isso é possível inserindo texto. Agora que temos um número aleatório, nossas próximas linhas de código devem pedir ao jogador para inserir seu melhor palpite.

Uma vez que o código inserido imprime a instrução para inserir um número para o jogador, ele também deve ler o número inserido. Isso é feito com input () no Python 3 e raw_input () no Python 2. Você deve escrever no Python 3, pois o Python 2 ficará desatualizado em breve. Adicione a seguinte linha ao seu código para armazenar a entrada do jogador em uma variável chamada número:
```
userNum = input ()
```

Etapa 6. Transforme a entrada do jogador em um tipo de dados utilizável

O jogador inseriu um número - e agora?

Faça a entrada do jogador um número. Agora, isso pode parecer confuso porque eles acabaram de inserir um número. Mas há um bom motivo: o Python assume que todas as entradas são texto ou uma "string", como é chamada na programação. Este texto contém o número que você deseja obter. Python tem uma função que converte uma string que contém apenas um número para o número dentro. Modelo:
```
userNum = int (userNum)
```

Etapa 7. Compare o número do jogador com o número correto

Assim que o jogador inserir seu número, você precisará compará-lo com aquele que foi gerado aleatoriamente. Se os números não forem iguais, seu jogo pode fazer o jogador tentar outro número. Se os números corresponderem, você pode dizer ao jogador que ele acertou e sair do programa. Isso é feito com o seguinte código:

enquanto userNum! = rightNum: userNum = int (input ())

Etapa 8. Dê feedback ao jogador

Embora você já tenha processado sua entrada, o player não verá isso. Você precisará imprimir os resultados ao player para que ele entenda o que está acontecendo.

Certamente, você poderia simplesmente dizer ao jogador se o número dele está certo ou errado. Mas com essa abordagem, o jogador pode ter que adivinhar 1000 vezes no pior caso, o que seria muito chato.
Portanto, diga ao jogador se o número dele é muito pequeno ou muito grande. Isso reduzirá significativamente o número de suposições. Se, por exemplo, o jogador adivinhar 500 primeiro e o jogo responder "Muito grande. Tente novamente", haverá apenas 500 números possíveis em vez de 1000. Isso é feito com construções if, então substitua a impressão ("Errado. Tente novamente. ") Com um.
Esteja ciente de que verificar se dois números são iguais é feito com ==, não com =. = atribui o valor à direita dele para a variável à esquerda dele!

if userNum <rightNum: print ("Muito pequeno. Tente novamente:") if userNum> rightNum: print ("Muito grande. Tente novamente:")

Etapa 9. Teste seu código

Como programador, você deve ter certeza de que seu código funciona antes de considerá-lo concluído.

Ao programar em python, certifique-se de obter as indentações corretas. Seu código deve ser assim:

import random print ("Bem-vindo ao jogo de adivinhação de números!") print ("Insira um número inteiro entre 1 e 1000:") rightNum = random.randint (0, 1000) userNum = input () userNum = int (userNum) while userNum! = rightNum: if userNum <rightNum: print ("Muito pequeno. Tente novamente:") if userNum> rightNum: print ("Muito grande. Tente novamente:") userNum = int (input ()) print ("Você adivinhou corretamente.")

Etapa 10. Validar a entrada

O jogador não deve ser capaz de quebrar seu jogo simplesmente digitando a coisa errada. "Validar a entrada" significa certificar-se de que o jogador digitou a coisa correta antes de processá-la.

Abra o jogo novamente e tente inserir qualquer coisa que não seja um número. O jogo será encerrado com um ValueError. Para evitar isso, você pode implementar uma maneira de verificar se a entrada foi um número.
Defina uma função. Visto que validar a entrada é muito longo e você precisa fazer isso várias vezes, você deve definir uma função. Não levará nenhum argumento e retornará um número. Primeiro, escreva def numInput (): no topo do seu código, diretamente sob a importação aleatória.
Obtenha a entrada do jogador uma vez. Use a função input () e atribua o resultado à variável inp.
Quando a entrada do jogador não for um número, peça a ele para inserir um número. Para verificar se uma string é um número, use as funções isdigit (), que permitem apenas um número inteiro, então você não terá que verificar isso separadamente.
Se a entrada for um número, converta-o de string em número e retorne o resultado. Use a função int () para converter a string em um inteiro. Isso tornará a conversão no código principal desnecessária, e você deve removê-lo de lá.
Substitua todas as chamadas para input () no código principal por chamadas para numInput ().
O código da função numInput () será semelhante a este:

def numInput (): inp = input () enquanto não inp.isdigit (): print ("Disseram para você inserir um número inteiro! Insira um número inteiro:") inp = input () return int (inp)

Etapa 11. Teste o jogo novamente

Insira as coisas erradas de propósito para ver o que acontece e, em seguida, corrija os erros à medida que surgirem.

Tente inserir algum texto quando o programa solicitar um número. Agora, em vez de sair com uma mensagem de erro, o programa pedirá novamente um número

Etapa 12. Sugira reiniciar o jogo quando terminar

Desta forma, o jogador pode jogar por mais tempo sem ter que reiniciá-lo constantemente.

Coloque todo o código, exceto a importação e a definição da função, em um loop while. Defina True como a condição: isso sempre será verdadeiro, então o loop continuará para sempre.
Pergunte ao jogador se deseja jogar novamente depois de adivinhar o número corretamente. Use a função print ().
Se eles responderem "Não", saia do look. Se eles responderem mais alguma coisa, continue. A quebra de um loop é feita com a instrução break.
Mova o "Bem-vindo ao jogo de adivinhação de números" para fora do loop while. O jogador provavelmente não quer ser bem-vindo toda vez que joga. Mova a instrução para imprimir ("Bem-vindo ao jogo de adivinhação de números!" Acima de enquanto True:, para que seja impressa apenas uma vez, quando o usuário iniciar o primeiro jogo.

Etapa 13. Teste o jogo

Você precisará testar seu jogo sempre que implementar um novo recurso.

Certifique-se de responder "Sim" e "Não" pelo menos uma vez para ter certeza de que ambas as opções funcionam. Esta é a aparência do seu código:

import random def numInput (): inp = input () enquanto não inp.isdigit (): print ("Disseram para você inserir um número inteiro! Insira um número inteiro:") inp = input () return int (inp) print ("Bem-vindo ao jogo de adivinhação de números!") While True: print ("Insira um número inteiro entre 1 e 1000:") rightNum = random.randint (0, 1000) userNum = numInput () enquanto userNum! = RightNum: if userNum <rightNum: print ("Muito pequeno. Tente novamente:") if userNum> rightNum: print ("Muito grande. Tente novamente:") userNum = numInput () print ("Você adivinhou corretamente.") print ("E você quer jogar de novo? Digite Não para sair. ") if input () ==" Não ": break

Etapa 14. Escreva outros jogos baseados em texto

Que tal escrever uma aventura em texto a seguir? Ou um jogo de perguntas e respostas? Seja criativo.

Gorjeta: Às vezes, é útil consultar a documentação se você não tiver certeza de como algo é feito ou como uma função é usada. A documentação do Python 3 pode ser encontrada em https://docs.python.org/3/. Às vezes, pesquisar o que você deseja fazer na Internet também retorna bons resultados.

Parte 2 de 3: Fazendo um jogo com gráficos 2D

Etapa 1. Escolha uma biblioteca de gráficos

Criar gráficos é muito complicado, e a maioria das linguagens de programação (incluindo Python, C ++, C, JavaScript) oferece suporte mínimo ou mesmo nenhum suporte para gráficos no núcleo ou nas bibliotecas padrão. Então você terá que usar uma biblioteca externa para poder fazer gráficos, por exemplo Pygame para Python.

Mesmo com uma biblioteca de gráficos, você terá que se preocupar com coisas como como exibir um menu, como verificar o que o jogador clicou, como exibir as peças e assim por diante. Se você preferir se concentrar no desenvolvimento do jogo real, pode usar uma biblioteca de mecanismo de jogo como o Unity, que implementa essas coisas facilmente

Este artigo usará Python com Cocos2D para mostrar como fazer um jogo de plataforma 2D simples. Alguns dos conceitos mencionados podem não existir em outros motores de jogo. Consulte a documentação para obter mais informações.

Etapa 2. Instale a biblioteca de gráficos que você escolheu

O Cocos2D para Python é fácil de instalar. Você pode obtê-lo em https://python.cocos2d.org/index.html ou executando sudo pip3 install cocos2d se estiver usando Linux.

Etapa 3. Crie um novo diretório para seu jogo e mídia

Você usará coisas como imagens e sons em seu jogo. Mantenha essas coisas no mesmo diretório do programa. Este diretório não deve conter mais nada para que você possa ver facilmente quais ativos você tem no jogo.

Etapa 4. Crie um novo arquivo de código no novo diretório

Chame-o de principal, com a extensão de arquivo de sua linguagem de programação. Se você escrever um programa grande e complexo no qual faz sentido ter vários arquivos de programa, isso mostrará qual é o arquivo principal.

Neste exemplo, criaremos um arquivo chamado main.py que conterá todo o nosso código

Etapa 5. Crie a janela do jogo

Este é o pré-requisito básico para um jogo com gráficos.

Importe os submódulos cocos2d necessários: cocos.director, cocos.scene e cocos.layer. Isso é feito com subModuleName import *, onde sub-Module name é o submódulo que você deseja importar. A diferença entre from… import * e import… é que você não precisa colocar o nome do módulo antes de tudo que você usa daquele módulo com o anterior.
Defina uma subclasse MainMenuBgr do ColorLayer. Isso basicamente significa que qualquer plano de fundo do menu principal que você criar se comportará como uma camada de cores com algumas alterações feitas.
Comece o diretor cocos. Isso abrirá uma nova janela. Se você não definir uma legenda, a janela terá a mesma legenda que o nome do arquivo (main.py), o que não parecerá profissional. Permita que a janela seja redimensionada definindo redimensionável como True.
Defina uma função showMainMenu. Você deve colocar o código para mostrar o menu principal em uma função, pois isso permitirá que você retorne facilmente ao menu principal chamando a função novamente.
Crie uma cena. A cena consiste em uma camada por enquanto, que é um objeto da classe MainMenuBgr que você definiu.
Execute esta cena na janela.

from cocos.director import * from cocos.scene import * from cocos.layer import * class MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenu, self)._ init _ (0, 200, 255, 255) def showMainMenu (): menuSc = Scene (MainMenuBgr ()) director.run (menuSc) director.init (caption = "IcyPlat - um jogo de plataforma simples", redimensionável = True) showMainMenu ()

Etapa 6. Adicione um menu principal à janela

Além do jogo em si, você precisará adicionar um menu que o jogador pode usar para fechar a janela, entre outros elementos que você pode adicionar mais tarde.

Importe cocos.menu (novamente com a instrução from) e pyglet.app (desta vez com import).
Defina MainMenu como uma subclasse de Menu.
Defina o alinhamento do menu principal. Você deve definir o alinhamento vertical e horizontal separadamente.
Crie uma lista de itens de menu e adicione-os ao menu. Você deve ter os itens de menu "Iniciar Jogo" e "Sair" no mínimo. Cada item do menu deve ser colocado entre colchetes. Cada item deve ter um rótulo e uma função de retorno de chamada que determina o que acontece quando o jogador clica nele. Para o item "Start Game", use a função startGame (você escreverá em breve), para o item "Quit", use "pyglet.app.exit" (já existe). Crie o menu real chamando self.create_menu (menuItems).
Defina startGame (). Basta inserir a definição por enquanto, você a substituirá quando escrever o jogo real.
Vá para o local em seu código onde você criou a cena menuSc e adicione um objeto MainMenu a ela.

Todo o seu código agora deve ter a seguinte aparência:

de cocos.director import * from cocos.menu import * from cocos.scene import * from cocos.layer import * import pyglet.app class MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) class MainMenu (Menu): def _init _ (self): super (MainMenu, self)._ init _ ("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Start Game ", startGame)), (MenuItem (" Quit ", pyglet.app.exit))] self.create_menu (menuItems) def startGame (): pass def showMainMenu (): menuSc = Scene (MainMenuBgr ()) menuSc.add (MainMenu ()) director.run (menuSc) director.init (caption = "IcyPlat - um jogo de plataforma simples", redimensionável = Verdadeiro) showMainMenu ()

Etapa 7. Teste seu código

Teste o código antecipadamente, enquanto ele ainda é curto e relativamente simples. Então, você pode identificar e corrigir quaisquer erros na estrutura básica antes que as coisas se tornem muito complicadas.

O código das instruções deve abrir uma janela com a legenda "IcyPlat - um jogo de plataforma simples." O fundo é azul claro e você pode redimensionar a janela. Quando você clica em "Iniciar Jogo" no menu, nada deve acontecer (ainda). Quando você clicar em "Sair", a janela será fechada

Etapa 8. Crie um sprite

Um sprite é um "objeto de jogo" ou uma imagem bidimensional. Sprites podem ser objetos do jogo, ícones, decorações de fundo, personagens e qualquer outra coisa que você possa representar com uma imagem no jogo. Começaremos criando um sprite para um personagem com o qual o jogador possa interagir.

Importe o submódulo cocos.sprite com a expressão from-import.
Encontre uma imagem para representar o sprite. Você não pode exibir um sprite se não tiver uma imagem para ele. Você pode desenhar um, ou pode obter um na Internet (no entanto, preste atenção às licenças, se estiver planejando publicar seu jogo). Para este exemplo, vá para https://opengameart.org/content/tux-classic-hero-style e salve a imagem-p.webp" />
Crie uma camada como um novo objeto da classe ScrollableLayer. Em seguida, crie o sprite como um objeto Sprite e defina sua posição para (8, 250). Para referência, o ponto (0, 0) está no canto esquerdo inferior. É bem alto, mas vai garantir que o pinguim não fique preso no gelo.
Adicione o sprite à camada do sprite.
Crie uma nova cena fora da camada do sprite e execute-a.

def startGame (): figLayer = ScrollableLayer () fig = Sprite ('pingu.png') fig.position = (75, 100) figLayer.add (fig) # gameSc = Cena (figLayer) director.run (gameSc)

Execute o código. Você deve ver uma pequena figura de pinguim (ou o que quer que tenha desenhado) em um fundo preto depois de clicar Começar o jogo.

Etapa 9. Sonhe com sua paisagem

Na maioria dos jogos, seus sprites não devem apenas flutuar no vazio. Eles devem realmente estar em alguma superfície, com algo ao redor deles. Em jogos 2D, isso geralmente é feito com um conjunto de blocos e um mapa de blocos. O conjunto de ladrilhos basicamente diz que tipo de quadrados de superfície e quadrados de fundo existem e como eles se parecem.

Crie um conjunto de peças. O conjunto de peças para este jogo será muito básico: uma peça para o gelo e uma para o céu. A placa de gelo usada neste exemplo é daqui, sob CC-BY-SA 3.0.
Crie uma imagem de conjunto de peças. Essa é uma imagem de todas as peças, que devem ser todas do mesmo tamanho (edite-as se não forem) e ter o tamanho que você deseja ver no jogo, uma ao lado da outra. Salve sua imagem como icyTiles.png.
Crie a descrição do conjunto de blocos. Esse é um arquivo XML. O arquivo XML contém informações sobre o tamanho dos ladrilhos na imagem do conjunto de ladrilhos, qual imagem usar e onde encontrar qual ladrilho lá. Crie um arquivo XML denominado icyTiles.xml com o código abaixo:
```
     
```

Etapa 10. Faça um mapa de blocos para sua paisagem

Um mapa de blocos é um mapa que define qual bloco está em qual posição em seu nível. No exemplo, você deve definir uma função para gerar mapas de ladrilhos porque projetar mapas de ladrilhos manualmente é muito tedioso. Um jogo mais avançado normalmente teria algum tipo de editor de níveis, mas para se familiarizar com o desenvolvimento de jogos 2D, um algoritmo pode fornecer níveis bons o suficiente.

Descubra quantas linhas e colunas são necessárias. Para isso, divida o tamanho da tela pelo tamanho do ladrilho tanto na horizontal (colunas) quanto na vertical (linhas). Arredonde o número para cima; você precisa de uma função do módulo matemático para isso, então adicione from math import ceil às importações no topo do seu código.
Abra um arquivo para gravação. Isso apagará todo o conteúdo anterior do arquivo, portanto, escolha um nome que nenhum arquivo no diretório ainda tenha, como levelMap.xml.
Grave as tags de abertura no arquivo.
Gere um mapa de blocos de acordo com o algoritmo. Você pode usar o do código abaixo ou pode criar um sozinho. Certifique-se de importar a função randint do módulo random: ela é necessária para que o código abaixo funcione, e tudo o que você descobrir provavelmente também precisará de inteiros aleatórios. Além disso, certifique-se de colocar blocos de céu e blocos de gelo em camadas diferentes: o gelo é sólido, o céu não.
Grave as marcas de fechamento no arquivo e feche o arquivo.

def generateTilemap (): colAmount = ceil (800/16) * 3 # (largura da tela / tamanho do bloco) * 3 rowAmount = ceil (600/16) # altura da tela / tamanho do bloco tileFile = open ("levelMap.xml", " w ") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) para i no intervalo (0, colAmount): tileFile.write ('') makeHole = False se randint (0, 50) == 10 e i! = 0: # não permite buracos no ponto de desova makeHole = True para j no intervalo (0, rowAmount): if makeHole: tileFile.write ('\ n') else: if j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight + 5) se iceHeight <0: # limitar os blocos de irem muito baixo iceHeight = randint (1, 5) if iceHeight> rowAmount: # limita os blocos de irem muito alto iceHeight = randint (int (rowAmount / 2) -5, int (rowAmount / 2) +5) tileFile.write ('\ n') tileFile.write ('\ n / n') para i no intervalo (0, colAmount): tileFile.write ('') para j no intervalo (0, rowAmount): tileFile.write ('\ n') tileFile.write ('\ n ') tileFile.write (' / n / n ') tileFile.close ()

Etapa 11. Exibir o mapa de blocos

Importe tudo de cocos.tiles e depois vá para a função startGame para isso.

No início de sua função startGame, gere um mapa de blocos usando a função que você definiu para isso.
Crie um novo gerenciador de rolagem. Faça isso diretamente abaixo da linha onde você adiciona o sprite à sua camada.
Crie uma nova camada contendo os blocos, que serão carregados do mapa de blocos levelMap.xml gerado por sua função generateTilemap.
Adicione a camada não sólida, a camada sólida e a camada de sprite ao gerenciador de rolagem, exatamente nesta ordem. Você pode adicionar uma posição z se desejar.
Em vez de criar a cena a partir da camada de sprite, crie-a no gerenciador de rolagem.

Sua função startGame agora deve ser semelhante a esta:

def startGame (): generateTilemap () # fig = Sprite ('pingu.png') fig.position = (8, 500) figLayer = ScrollableLayer () figLayer.add (fig) # tileLayer = load ('levelMap.xml') solidTiles = tileLayer ['solid'] nsoliTiles = tileLayer ['not_solid'] # scrMang = ScrollingManager () scrMang.add (nsoliTiles, z = -1) scrMang.add (solidTiles, z = 0) scrMang.add (figLayer, z = 1) # gameSc = Scene (scrMang) director.run (gameSc)

Etapa 12. Teste seu código

Você deve testar seu código com freqüência para se certificar de que os novos recursos implementados realmente funcionam.

O código do exemplo agora deve mostrar alguma paisagem gelada atrás do pinguim. Se parecer que o pinguim está pairando sobre o gelo, você não fez nada de errado e o problema será corrigido na próxima etapa

Etapa 13. Adicione os controles

O jogador tem muito mais maneiras de interagir com o programa em um jogo 2D do que em um jogo baseado em texto. Um comum inclui mover sua figura quando a tecla correta é pressionada.

Importe tudo de cocos.mapcolliders e de cocos.actions. Também importe a chave de pyglet.window.
"Declare" algumas variáveis globais. Variáveis globais são compartilhadas entre funções. Você realmente não pode declarar variáveis em Python, mas deve dizer que existe uma variável global no código principal antes de usá-la. Você pode atribuir 0 como o valor porque uma função se encarregará de atribuir o valor correto posteriormente. Portanto, adicione nas expressões de importação:
```
# "declarando" variáveis globais keyboard = 0 scrMang = 0
```

Ajuste sua função startGame:

Digamos que você use o teclado de variáveis globais e scrMang. Faça isso escrevendo teclado global, scrMang na parte superior da função.
Faça a janela ouvir os eventos do teclado.
Diga à figura para agir com base em um PlatformerController. Você implementará esse PlatformerController em breve.
Crie um colisor de mapa para lidar com as colisões entre os ladrilhos sólidos e a figura.

def startGame (): teclado global, scrMang generateTilemap () # fig = Sprite ('pingu.png') fig.position = (8, 250) figLayer = ScrollableLayer () figLayer.add (fig) # tileLayer = load ('levelMap.xml ') solidTiles = tileLayer [' solid '] nsoliTiles = tileLayer [' not_solid '] # keyboard = key. KeyStateHandler () director.window.push_handlers (teclado) # fig.do (PlatformerController ()) mapcollider = RectMapCollider (velocity_on_bump = 'slide') fig.collision_handler = make_collision_handler (mapcollider, solidTiles) # scrMang = ScrollingManager () scrMang.add (nsoliTiles, z = -1) scrMang.add (solidTiles, z = 0) scrMang.add (figLayer, z = 1) # gameSc = Scene (scrMang) director.run (gameSc)

Crie um controlador de plataforma. Isso é o que moverá a figura de acordo com seus pressionamentos de tecla.
- Defina o controlador de plataforma como uma subclasse de ação.
- Defina a velocidade do movimento, a velocidade do salto e a gravidade.
- Defina a função de início. Esta função é chamada uma vez, quando o controlador de plataforma é conectado à figura. Ele deve definir sua velocidade para 0 na direção xe na direção y.
- Defina a função de etapa. Isso será repetido enquanto a cena estiver em execução.
- Diga à função step para usar o teclado de variáveis globais e scrMang.
- Obtenha e altere a velocidade. Salve a velocidade xey em variáveis separadas. Defina a velocidade x para 1 ou -1 (dependendo se a tecla esquerda ou direita foi pressionada) multiplicada pela velocidade de movimento. Adicione gravidade à velocidade y. Multiplique pelo tempo de inatividade para que funcione da mesma maneira em dispositivos mais lentos. Se a tecla de espaço for pressionada e a figura estiver no chão, salte alterando a velocidade y para velocidade de salto.
- Calcule para onde a figura deve se mover. Em seguida, deixe o controlador de colisão ajustar essa posição se estiver dentro de um ladrilho sólido. Finalmente, mova a figura para a nova posição ajustada.
- Defina o foco do gerenciador de rolagem na figura. Isso faz com que a câmera se mova de forma razoável quando a figura se move.
```
classe PlatformerController (Action): teclado global, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) def step (self, dt): teclado global, role se dt> 0.1: # não faça nada durante o tempo de inatividade para grande retorno vx, vy = self.target.velocity vx = (teclado [tecla. RIGHT] - teclado [tecla. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt if self.on_ground e teclado [key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect () novo = last.copy () novo.x + = dx new.y + = dy self.target.velocity = self.target.collision_handler (last, new, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (* new.center)
```

Etapa 14. Teste seu código

Se você seguiu o exemplo, agora deve ser capaz de mover o pinguim com as setas do teclado e pular pressionando a barra de espaço. Além disso, o pinguim agora deve cair em vez de pairar no chão.

Etapa 15. Crie um final para o jogo

Mesmo os jogos que podem durar indefinidamente devem ter a possibilidade de perder. Como o nível que você fez no exemplo com uma função tem um fim, você também precisará possibilitar a vitória chegando a esse fim. Caso contrário, o jogador só pularia nos blocos de gelo ali, o que ficaria entediante.

Dentro do controlador de plataforma, após o conjunto de foco, obtenha as posições xey da figura. Se a posição y for menor que 0, chame a função finishGame () (você escreverá mais tarde) com "Game Over" como argumento. Se a posição x for maior do que o tamanho da tela, multiplicado por 3 (você havia definido isso como tamanho do nível antes).
```
posX, posY = self.target.position if posY <0: finishGame ("Game Over") return if posX> 800 * 3: # level size finishGame ("Level Completed") return
```
Defina um terminarMenu de classe. Deve ser como a classe do menu principal que você definiu antes, mas em vez de ter uma string vazia como título, deve usar um texto variável que a função _init_ leva como argumento. Os itens do menu devem ser identificados como "Tentar novamente" e "Sair" agora, mas as funções que eles chamam permanecem as mesmas.
```
class FinishMenu (Menu): def _init _ (self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Tente novamente", startGame)), (MenuItem ("Quit", pyglet.app.exit))] self.create_menu (menuItems)
```
Defina a função finishGame (). Deve tomar o texto como argumento. Ele deve fazer uma cena do fundo do menu principal, um FinishMenu com o argumento de texto sendo passado para este menu. Então deve rodar esta cena.
```
def finishGame (texto): menuSc = Cena (MainMenuBgr ()) menuSc.add (FinishMenu (texto)) director.run (menuSc)
```

Etapa 16. Adicione créditos

É aqui que você recebe crédito por seu código incrível, bem como dá crédito a qualquer pessoa que o ajudou ao longo do caminho. Se você usou uma imagem de outro site (com permissão), certifique-se de atribuir essa imagem ao seu criador.

Crie um arquivo CRÉDITOS e insira todos os seus créditos lá, assim:

Pinguim: Kelvin Shadewing, sob CC0 Bloco de gelo: Michał Banas digit1024 em opengameart.org sob CC-BY-SA 3.0

Volte para o seu código Python e importe Label de cocos.text.

Defina uma subclasse de Créditos da Camada. Em sua função _init_, leia o arquivo CREDITS e faça um rótulo de texto na posição correta de cada linha nele.

class Credits (Layer): def _init _ (self): super (Credits, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n ") para i no intervalo (0, len (creds)): credLabel = Label (creds , font_size = 32, anchor_x =" left ", anchor_y =" top ") credLabel.position = 25, 500- (i +1) * 40 self.add (credLabel)

Vá para a classe do menu principal e adicione um item de menu denominado "Créditos" que chama a função showCredits quando clicado.
Defina uma subclasse BackToMainMenuButton de Menu. Faça disso um menu com um item, denominado "Voltar", que chama a função showMainMenu. Este "menu", que é mais como um botão, deve ser alinhado verticalmente para baixo e horizontalmente para cima.
```
class BackToMainMenuButton (Menu): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("Voltar", showMainMenu)) self. create_menu (menuItems)
```

Defina a função showCredits. Deve fazer uma cena de uma camada MainMenuBgr e uma camada de Créditos e executar essa cena.

def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenuButton ()) director.run (credSc)

Etapa 17. Verifique seu código

Quando você achar que terminou seu código, deve examinar tudo novamente. Isso pode ajudá-lo a perceber se algo pode ser otimizado ou se há algumas linhas desnecessárias que você se esqueceu de excluir. Se você seguiu o exemplo, todo o seu código agora deve ter a seguinte aparência:

from cocos.director import * from cocos.menu import * from cocos.scene import * from cocos.layer import * from cocos.sprite import * from cocos.tiles import * from cocos.mapcolliders import * from cocos.actions import * from cocos.text import Label import pyglet.app from pyglet.window import key from math import ceil from random import randint # "declarando" variáveis globais keyboard = 0 scrMang = 0 class MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) class MainMenu (Menu): def _init _ (self): super (MainMenu, self)._ init _ ("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Start Game", startGame)), (MenuItem ("Credits", showCredits)), (MenuItem ("Quit", pyglet.app.exit))] self.create_menu (menuItems) class Credits (Layer): def _init _ (self): super (Credits, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n") para i no intervalo (0, len (creds)): credLabel = Label (creds , font_size = 32, anchor_x = "left", anchor_y = "top") credLabel.position = 25, 500- (i + 1) * 40 self.add (credLabel) class BackToMainMenuButton (Menu): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("Back", showMainMenu))] self.create_menu (menuItems) class FinishMenu (Menu): def self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Tente novamente", startGame)), (MenuItem ("Sair", pyglet. app.exit))] self.create_menu (menuItems) class PlatformerController (Action): teclado global, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) def step (self, dt): teclado global, scroller if dt> 0.1: # não faça nada durante o tempo de inatividade muito grande return vx, vy = self.target.velocity vx = (teclado [tecla. RIGHT] - teclado [key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt if self.on _ground e teclado [key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect () new = last.copy () new.x + = dx new.y + = dy self.target.velocity = self.target.collision_handler (last, new, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (* new.center) posX, posY = self.target.position if posY <0: finishGame ("Game Over") return if posX> 800 * 3: # level size finishGame ("Level Completed") return def finishGame (text): menuSc = Cena (MainMenuBgr ()) menuSc.add (FinishMenu (texto)) director.run (menuSc) def showCredits (): credSc = Cena (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenuButton ()) director.run (credSc) def generateTilemap (): colAmount = ceil (800/16) * 3 # (largura da tela / tamanho do bloco) * 3 rowAmount = ceil (600/16) # altura da tela / tamanho do bloco tileFile = aberto ("levelMap.xml", "w") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) para i no intervalo (0, colAmount): tileFile.write ('') makeHole = Falso se rand int (0, 50) == 10 e i! = 0: # não permite buracos no ponto de desova makeHole = True para j no intervalo (0, rowAmount): if makeHole: tileFile.write ('\ n') else: if j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight + 5) se iceHeight <0: # limita os blocos de ir também low iceHeight = randint (1, 5) if iceHeight> rowAmount: # limita os blocos de irem muito altos iceHeight = randint (int (rowAmount / 2) -5, int (rowAmount / 2) +5) tileFile.write ('\ n ') tileFile.write (' / n / n ') para i no intervalo (0, colAmount): tileFile.write (' ') para j no intervalo (0, rowAmount): tileFile.write (' / n ') tileFile.write ('\ n') tileFile.write ('\ n / n') tileFile.close () def startGame (): teclado global, scrMang generateTilemap () # fig = Sprite ('pingu.png') fig.position = (8, 250) figLayer = ScrollableLayer () figLayer.add (fig) # tileLayer = load ('levelMap.xml') solidTiles = tileLayer ['solid'] nsoliTiles = tileLayer ['not_solid'] # keyboard = key. KeyStateHandler () director.window.push_handlers (keybo ard) # fig.do (PlatformerController ()) mapcollider = RectMapCollider (velocity_on_bump = 'slide') fig.collision_handler = make_collision_handler (mapcollider, solidTiles) # scrMang = Manager () scrMang.add (nsoliTiles, z = -1) scrMang. add (solidTiles, z = 0) scrMang.add (figLayer, z = 1) # gameSc = Cena (scrMang) director.run (gameSc) def showMainMenu (): menuSc = Cena (MainMenuBgr ()) menuSc.add (MainMenu ()) director.run (menuSc) window = director.init (caption = "IcyPlat - um jogo de plataforma simples", redimensionável = True) showMainMenu ()

Isso são 168 linhas no total e 152 linhas se você contar apenas o código. Isso pode parecer muito, mas para um jogo tão complexo, isso na verdade é uma quantia pequena.

Etapa 18. Concluído

Agora teste o jogo. Quando você programa algo, deve verificar se funciona sempre que você implementa algo novo. Além disso, você pode gostar de jogar o jogo que escreveu por algum tempo.

Parte 3 de 3: publicando um jogo

Etapa 1. Anote as dependências

Qualquer pessoa que use outro computador não terá o mesmo software e bibliotecas instalados que você. Portanto, você precisará garantir que todos os que instalam seu jogo saibam exatamente o que precisam para executá-lo. Você não precisa escrever todas as dependências de todas as dependências de todas as dependências e assim por diante, mas deve pelo menos escrever as dependências de seus pacotes e suas dependências.

Etapa 2. Certifique-se de ter permissão para usar todas as mídias

Isso se aplica a todos os gráficos, incluindo modelos 3D, música, diálogo, música, bibliotecas e estruturas que você usou para o seu jogo. Qualquer coisa que você não escreveu.

Freqüentemente, existem algumas condições, como ter que creditar o autor ou compartilhar modificações da mídia sob a mesma licença. Às vezes, você poderá usar gráficos sem atribuir os criadores, desde que não cobre pelo jogo. Se você tiver que dar crédito ao autor, faça-o em um lugar bem visível, como uma guia "Créditos" em seu jogo.
Também há mídia com direitos autorais reivindicados e nenhuma licença especificada, às vezes com algum texto como "Todos os direitos reservados". Se for esse o caso, você deve obter permissão explícita do autor antes de incluí-lo em seu jogo.
As bibliotecas geralmente são lançadas sob licenças que permitem seu uso como biblioteca. Uma exceção notável é a GPL sem exceção de vinculação: tal licença só permite o uso em um programa com certas licenças. E você deve sempre ler pelo menos os pontos básicos da licença para se certificar de que tudo o que está fazendo com a mídia ou biblioteca é permitido.

Aviso: Usar mídia ou bibliotecas de uma forma que a licença não permite em um jogo que você publica pode causar sérios problemas legais. Portanto, pergunte ao autor ou evite a mídia se não tiver certeza se seu uso é permitido.

Etapa 3. Decida as condições em que deseja publicar seu jogo

Você venderá seu jogo? Você quer permitir que outras pessoas usem suas imagens e ideias? Embora você tenha que ter cuidado com a mídia que usa em seu projeto, geralmente pode decidir como deseja permitir que outras pessoas usem seu jogo. Você pode usar uma licença Creative Commons CC0 para lançar seu jogo em domínio público. Para permitir a distribuição e modificação sob algumas condições enquanto retém alguns direitos, tente a Licença Pública Geral Gnu (GPL) ou a licença Berkeley Software Distribution (BSD). Ou você pode tornar seu software proprietário, o que significa que ninguém tem permissão para distribuí-lo ou modificá-lo sem sua permissão.

Embora seja possível ganhar dinheiro vendendo jogos, é improvável que as pessoas comprem seu primeiro jogo, que geralmente tem poucos recursos e nada de especial. Além disso, se um programa gratuito não funcionar, as pessoas que o baixaram ficarão desapontadas. Se eles pagaram por isso, entretanto, eles exigirão seu dinheiro de volta, causando mais problemas para você e para os usuários. Portanto, considere disponibilizar seus primeiros programas gratuitamente

Etapa 4. Decida como você deseja publicar seu jogo

Cada método tem algumas vantagens e desvantagens, então você mesmo deve decidir.

Publicando em um site:

Se você tiver um site, poderá fazer upload do jogo para disponibilizá-lo para download. Certifique-se de fornecer instruções claras sobre como instalar o software, bem como todas as dependências necessárias. A desvantagem disso é que os jogadores terão que instalar as dependências manualmente, o que pode ser difícil para algumas pessoas.
Fazendo um pacote para um gerenciador de pacotes:

Existem diferentes gerenciadores de pacotes, como apt, Yum e Homebrew, que tornam mais fácil para as pessoas instalarem aplicativos em ambientes Linux e baseados em Linux. Todos eles têm formatos de pacote diferentes. O bom dos pacotes é que eles instalam automaticamente todas as dependências (se você configurá-los corretamente). Assim, o jogador só precisa instalar o seu pacote e pode jogar o jogo. O problema é que existem muitos gerenciadores de pacotes diferentes em plataformas diferentes, então você terá que se esforçar para fornecer pacotes para todos os mais comuns.

Etapa 5. Direcione a atenção para o seu programa

Considere enviar seu programa a um repositório de pacotes principal, como os que o Ubuntu e o Debian mantêm, para permitir instalações fáceis. Além disso, poste em fóruns apropriados, como a seção de projetos do GameDev ou uma parte do tigSource. Mas não fique desapontado se seus primeiros jogos não se tornarem famosos. Se você acha que muitas pessoas gostam, seu jogo pode se tornar conhecido.

Pontas

Seja paciente e esteja disposto a aprender. A programação pode ser frustrante às vezes!
Se você quer saber como algo é feito em outro jogo, e o jogo é de código aberto, você pode olhar seu código-fonte.
Ao procurar mídia, tente encontrar conteúdo que seja de domínio público. Pesquise imagens e músicas "Creative Commons" ou "Domínio Público" e use sites como https://opengameart.org ou
Não copie partes importantes do código sem verificar a licença. Freqüentemente, é proibido e, se não for, geralmente requer atribuição.
Não faça spam ou poste em locais inadequados ao promover seu jogo. Isso provavelmente fará com que você seja bloqueado na página, é simplesmente irritante e prejudicará sua reputação.