TUTORIAL DE INSTALAÇÃO E USO

Instalando as dependências do projeto:

Pré-requisito: possuir Python 3 instalado, com seu gerenciador de pacotes, pip, funcionando.

• Instalar o TKinter, pela linha de comando sudo apt-get install python3-tk
• Pronto. Já temos tudo necessário para executar o projeto.

Executando o projeto:

• No terminal, executar make start
• Para construir um jogo com o atual mapa de jogo, clicar em BUILD.
• Para executar o jogo gerado, clicar em RUN.

Criando seu próprio jogo:

• Para criar um jogo nesta versão do Padloper, é necessário editar o arquivo map.json
• Há modelos de jogos na própria pasta do projeto que contemplam todos os casos de uso da ferramenta. No entanto, é possível criar muitos estilos diferentes de jogos com aquelas poucas funcionalidades.
• Para mais informações, consultar Game Map (Mapa de Jogo)

Padloper - Projetando uma game engine por subtração

Este repositório foi criado para o meu projeto de conclusão de curso pelo CEFET/RJ, no curso de Sistemas de Informação.

Conteúdo:

1. O que é o Padloper?
2. Por que Game Engine por Subtração?
3. Glossário
4. Como funciona um jogo no Padloper?
5. Como o Padloper é construído?
   1. Game Map (Mapa de Jogo)
      1. Screen
      2. Scoreboard
      3. Actors
      4. Rules
   2. PadGame Builder (Construtor de um PadJogo
      1. Screen Builder
      2. Actor Builder
      3. Manager Builder
      4. Scoreboard Builder
      5. Rule Builder
      6. Game Builder

O que é o Padloper?

Padloper é uma game engine construída como um framework, uma camada acima da biblioteca gráfica Turtle Graphics, para o Python. O objetivo final do projeto é possibilitar a um usuário sem qualquer conhecimento em programação a experiência de ser um game designer e desenvolver um jogo arcade simples, de apenas uma tela e poucos elementos, como o jogo Frogger. A ferramenta tem como principal meta ser uma opção viável para o primeiro contato de alguém com o desenvolvimento de jogos e game designing.

O nome Padloper vem da menor tartaruga terrestre do mundo, cujo nome científico é Homopus signatus, e condiz com o escopo do projeto, que visa ser uma game engine pequena, enxuta e diminuta, e que usa os Turtle Graphics para atingir seus objetivos.

https://www.portaldosanimais.com.br/informacoes/caracteristicas-da-tartaruga-de-padloper-tamanho-e-nome-cientifico/

Por que "Game Engine Por Subtração" ?

O termo 'por subtração' surge de 'design por subtração', atribuído ao game designer Fumito Ueda, diretor dos jogos Ico e Shadow of The Colossus, e se refere à retirada de tudo que não for essencial à forma, tornando o produto final mais enxuto, simples e de escopo bem reduzido.

Tal filosofia se encaixa perfeitamente na proposta do Padloper, que foi pensada com foco total no primeiro contato de alguém com a construção de jogos, e por isso muitas das funcionalidades mais "comuns" de game engines mais tradicionais são removidas - subtraídas - para que a linha de aprendizado seja a mais suave possível.

Uma pergunta importante a se fazer para garantir que um elemento é passível de subtração é: "Caso um jogo não possua tal elemento, ele ainda é um jogo?". Em casos como a interação do usuário, a resposta é certamente não. Um jogo sem interação do usuário é uma outra coisa, mas não um jogo. Já em casos como o áudio, no entanto, a resposta pode ser sim. Um jogo sem som ainda é um jogo. E é aqui que a subtração age.

Glossário

• Ator : Elemento de jogo que possui componentes e comportamentos. Regras podem ser aplicadas a um ator e este poderá ser parte das consequências destas regras.
  
• Tela : Espaço onde o jogo é executado.
  
• Ciclo de jogo: Espaço de tempo no qual o jogo é executado. Pode-se dizer que uma 'volta' neste ciclo corresponde a um frame do jogo. Um ciclo de jogo possui os métodos Input, Update e Render, e também é dentro deste ciclo que as regras do jogo são checadas.
  
• Classe-Gerente: Em construção

Em construção

Como funciona um jogo no Padloper?

Um jogo construído pelo padloper possui 4 componentes principais: Tela, Ciclo de Jogo, Atores e suas Classes-Gerentes. Durante a execução do ciclo de jogo, as classes-gerentes checam as regras e executam suas ações, eventualmente interagindo entre si, ou com a tela.

stateDiagram-v2
	[*] --> Setup
	Setup --> Input
	Input --> Update
	Update --> Render
	Render --> Input
	Render --> [*]

Loading

O ciclo de jogo compreende os métodos após o Setup (configuração inicial das classes-gerentes de jogo).

Cada um destes métodos do ciclo de jogo possui um correspondente nas classes-gerentes dos atores. Isto permite que se chame cada um dos métodos próprios e que se personalize estes métodos dentro das classes-gerentes.

sequenceDiagram
    Padmain.Update()->>+AtorGerente.Update(): Realize o método Update!
    AtorGerente.Update()->>+Ator: Atualize sua posição!
    Ator-->>-AtorGerente.Update(): Posição atualizada!
    AtorGerente.Update()-->>-Padmain.Update(): Ator Atualizado!

Loading

No exemplo, o método Update, inserido dentro do Padmain, chama seu correspondente dentro da classe ator-gerente, que atualiza a posição do ator, e retorna o ator já atualizado, que será renderizado na próxima atualização de tela.

Como o Padloper é construído?

A ferramenta é construída em algumas partes, que compõem o todo do software. Abaixo estão descritas as ferramentas e suas funções:

Game Map (Mapa de Jogo):

O mapa de jogo é um arquivo JSON que será o guia, ou a planta do jogo. O software está preparado para ler o arquivo e usar as informações nele contidas para construir o jogo.

Um mapa de jogo típico do Padloper é assim construído:

{
	"name" : "Padloper Game",
	"screen" : {},
	"scoreboard" : {},
	"rules" : [
		{}
	],
	"actors" : [
		{}
	]
}

Cada um dos elementos do mapa possui em si uma série de outros elementos, e além do "name", que é o título do jogo, são eles:

Screen

O Objeto de Tela de um jogo executado com Turtle é o espaço no qual os objetos são desenhados, ou seja, é o espaço onde o jogo realmente acontece. Um elemento de tela num mapa de jogo construído pelo Padloper é como descrito abaixo:

"screen" : {
	"width" : 1000,
	"height" : 1000,
	"color" : "green"
}

Elementos:

Width: Largura da tela em pixels;
Height: Altura da tela em pixels;
Color: Cor do background, que pode ser informada em hexadecimal;

Scoreboard

Um elemento de Scoreboard no mapa de jogo Padloper é como disposto abaixo:

"scoreboard": {
	"position" : "top"
	"color" : "black"
	"font" : "Courier"
	"size" : "18"
}

Elementos:

Position: Posição do placar na tela (top|bottom);
Color: Cor das letras do placar, que pode ser informado em hexadecimal;
Font: Fonte da escrita do placar;
Size: Tamanho da escrita do placar;

Actors

O array 'Actors' do jogo é uma lista dos atores que estarão presentes na execução do jogo, incluindo tanto atores que o jogador controla quanto os inimigos ou outros assets não controlados pelo jogador.

Um ator é possui dentro de si alguns objetos, como descrito abaixo:

{
      "name" : "player",
      "components" : {
	      "size" : 2,
          "speed" : 10,
          "heading" : 0,
          "collision_field": 3
      },
      "spawn" :
      {
        "type" : "multiple",
	"max_num" : 300,
        "screen_update_count" : 12,
        "positions" : [
          {"x" :0, "y" : 470}
        ],
        "colors" : [
          "red"
        ]
      },
      "behaviors" :
        {
          "inputs" : [
            {"key" :  "w", "action" : "forward", "param" :  "10"},
            {"key" :  "s", "action" :  "backward", "param" :  "10"},
            {"key" :  "a", "action" :  "strife_left", "param" :  "10"},
            {"key" :  "d", "action" :  "strife_right", "param" :  "10"}
          ]
        },
        {
          "updates": [
            { "action" : "strife_left", "param" :  "10"}

          ]
      },
    }

Elementos:

Name: Nome do ator;

Components: Atributos estáticos do ator;

• Speed: Atributo de velocidade do ator na tela ( 1 - 10 );
• Size: Dimensão do ator. ( 1 - 10 );
• Heading: Direção com a qual o ator vai ser gerado. ( 0 - 359 )
• Collision Field: Campo de colisão quadrado, gerado à partir do centro do ator. ( 1 - 10 )

Spawn: Objeto com os parâmetros de geração do ator na tela;

• Type: Tipo de geração ( unique | multiple );
• Positions : Array de posições que o ator pode assumir ao ser gerado. o ator será gerado numa destas coordenadas, aleatoriamente.
  • x: Posição x onde o ator será gerado;
  • y: Posição y onde o ator seŕa gerado;
• Colors : Array de cores que o ator pode assumir ao ser gerado. o ator escolherá uma cor aleatoriamente.

Behaviors: Comportamentos que o ator pode possuir. Há dois tipos de ações que se encaixam dentro de "Behaviors": os inputs e os updates.

• Inputs: lista de ações que o ator tomará ao pressionar de uma tecla. Um input possui:

  • Key: Tecla que, quando pressionada, executará a ação definida (a-z0-9) ;
  • Action: Ação executada ao pressionar a tecla;
    1. "forward" - move o ator para a frente em pixels (baseado no heading);
    2. "backward" - move o ator para trás em pixels (baseado no heading);
    3. "right" - vira o ator para a direita em graus (baseado no heading);
    4. "left" - vira o ator para a esquerda em graus (baseado no heading);
    5. "strife_left" - move o ator para a esquerda em pixels (baseado no heading);
    6. "strife_right" - move o ator para a direita em pixels (baseado no heading);
  • Param: Parâmetro com o qual a ação será executada, que pode ser, por exemplo, o número de pixels que um ator andará, quantos graus ele se voltará, etc;

• Updates: lista de ações que serão executadas pelo ator a cada novo frame, sem necessidade de uma interação do usuário.

  • Action: Ação executada ao pressionar a tecla.
    1. "forward" - move o ator para a frente em pixels (baseado no heading);
    2. "backward" - move o ator para trás em pixels (baseado no heading);
    3. "right" - vira o ator para a direita em graus (baseado no heading);
    4. "left" - vira o ator para a esquerda em graus (baseado no heading);
    5. "strife_left" - move o ator para a esquerda em pixels (baseado no heading);
    6. "strife_right" - move o ator para a direita em pixels (baseado no heading);
  • Param: Parâmetro com o qual a ação será executada, que pode ser, por exemplo, o número de pixels que um ator andará, quantos graus ele se voltará, etc;

Rules

Esta lista contém os objetos que descrevem as regras do jogo. Regras são condições a serem atingidas e suas consequências, bem como o ator ou atores envolvidos nesta regra. Abaixo estão alguns exemplos de objeto de regras incluído no mapa de jogo:

• Condições-Gatilho:
  1. "collision" - checa a colisão entre o ator1 e o ator2;
  2. "position" - checa a posição do ator1 baseado nos eixos x e y;
  3. "score" - checa a pontuação;

Exemplo de regra de colisão:

{
	"trigger" : "collision",
	"actor1" : "player",
	"actor2" : "enemy",
	"consequences" : []
}

Elementos da Regra de Colisão:

Trigger: Tipo de condição-gatilho para a regra ser ativada; ( collision | position | score )
Actor1: Primeiro ator a ser checado; (ator)
Actor2: Segundo ator a ser checado; (ator)
Consequences: Lista de consequências a serem executadas assim que a condição-gatilho for atingida;

Importante: a condição-gatilho 'collision' checa apenas colisões entre dois tipos de atores, e não é possível checar colisão entre três tipos de atores nesta versão do Padloper.

Exemplo de regra de posição:

{
	"trigger" : "position",
	"x_pos" : "",
	"x_cond" : "",
	"y_pos" : "480",
	"y_cond" :"greater",
	"actor1" : "player",
	"consequences" : []
}

Elementos da Regra de Posição:

Trigger: Tipo de condição-gatilho para a regra ser ativada; ( collision | position | score)
Actor1: Ator cuja posição será checada; (ator)
X_pos: Posição no eixo X para que o a regra seja ativada; ( number | "" )
X_cond: Condição relacionada ao eixo X para que a regra seja ativada; ( lesser | equal | greater )
Y_pos: Posição no eixo Y para que o a regra seja ativada; ( number | "" )
Y_cond: Condição relacionada ao eixo Y para que a regra seja ativada; ( lesser | equal | greater )
Consequences: Lista de consequências a serem executadas assim que a condição-gatilho for atingida;

Importante: a condição-gatilho 'position' poderá checar se um ator passou de uma coordenada na tela, no eixo x ou y caso apenas uma das coordenadas sejam informadas, ou se este ator atingiu um certo ponto da tela, caso as duas coordenadas sejam fornecidas.

Exemplo de regra de pontuação:

{
	"trigger" : "score",
	"win_score" : 10
	"consequences" : []
}

Elementos da Regra de Pontuação:

Trigger: Tipo de condição-gatilho para a regra ser ativada; ( collision | position | score)
Win_Score: Pontuação a ser atingida para que a regra seja ativada. ( number > 0 )
Consequences: Lista de consequências a serem executadas assim que a condição-gatilho for atingida;

• Consequências:
  1. "remove_actor" - remove o ator2 da tela;
  2. "set_heading" - muda a direção que o ator1 está apontado;
  3. "bounce_x" - faz o ator1 'quicar' no eixo x, em 45 graus;
  4. "bounce_y" - faz o ator1 'quicar' no eixo y, em 45 graus;
  5. "game_won" - finaliza o jogo com condição de vitória;
  6. "point" - acrescenta um ponto ao placar;
  7. "game_over" - finaliza o jogo com condição de derrota;
  8. "move_to" - move o ator1 para uma nova posição;

Padgame Builder

O Padloper Game Builder é o motor primordial da ferramenta. Esta peça do Padloper é o interpretador do mapa de jogo e o construtor do jogo de fato.

Cada um dos elementos descritos do Mapa de Jogo possui um construtor próprio, e opera sob regras específicas para cada um dos objetos.

Quais são as peças do Game Buider?

Screen Builder

Em construção

Actor Builder

Em construção

Manager Builder

Em construção

Scoreboard Builder

Em construção

Rule Builder

Em construção

Game Builder

Em construção