Como Fazer Um Fan Game? Aprenda

Já ouviu falar de Christian Whitehead? Se você é um fã dos jogos do Sonic, certamente já jogou Sonic Mania ou já leu sobre Sonic Origins ou Sonic Superstars.

Ele é um desenvolvedor de jogos (assim como você pode ser), fundador da Headcannon Studios. Mas, antes de tudo isso ele era apenas um criador de fan games do Sonic que, por seu talento, acabou indo trabalhar com o que gostava.

Whitehead era um dos criadores de fan games mais respeitados na fanbase de Sonic e tinha ideias muito interessantes para jogos, como Sonic Before the Sequel e Sonic After Sequel, que se passam respectivamente, entre e após os acontecimentos de Sonic 1 e Sonic 2.

Com histórias animadas de transição entre as fases e uma engine que ele mesmo desenvolveu para simular a física dos jogos 2D da era 16-bits, esses jogos eram considerados melhores que os oficiais.

Outro detalhe, é que a engine criada por ele acabou sendo usada nos remakes oficiais dos jogos da era do Mega Drive para Android e em Sonic Mania.

Essa não é uma história tão incomum e nem tão improvável de ter um final feliz para aqueles que amam jogos e querem um dia fazer seu próprio jogo baseado em um personagem que gosta. Mas, como fazer um fan game? Tem que saber programação? Dominar uma engine como Unity (site oficial) ou Unreal Engine (site oficial)?

Vamos falar um pouco sobre os fan games e principalmente como fazer um do zero e, se você ficar com dúvidas, é só deixar aí nos comentários.

Você também vai gostar:
Jogos em Unreal Engine
Tudo sobre Pixel Art
Aprenda a Criar Games 2D
Melhor Curso de Criação de Jogos
Criando Jogos no GameMaker

Como Dominar a Arte de Fazer Jogos?

O que é um Fan Game?

Um fan game é um jogo criado por fãs que se baseia em propriedades intelectuais existentes, como personagens, enredos ou universos de jogos, filmes, séries, etc. Geralmente desenvolvidos como uma forma de homenagem ou expressão de amor pelo material original, os fan games podem variar em escopo e qualidade, desde simples modificações de jogos existentes até projetos totalmente originais.

Eles podem ser desenvolvidos por indivíduos ou equipes de desenvolvimento amadoras, muitas vezes sem fins lucrativos. Como falamos, o Christian Whitehead é um criador de fan games que se tornou muito popular entre a comunidade e acabou trabalhando na área em que ama.

No entanto, alguns fan games podem enfrentar questões legais devido aos direitos autorais, especialmente se utilizarem propriedades intelectuais protegidas sem permissão. Quase todos os dias, vemos notícias sobre a Nintendo derrubando sites ou projetos de fã games de Pokémon, não é?

Apesar disso, os fan games continuam a prosperar como uma forma de comunidade criativa e devoção aos universos de ficção populares.

O que é Necessário e Como Fazer um Fan Game?

Criar um fan game envolve uma série de passos e requisitos essenciais. Primeiro, é importante escolher a inspiração para o jogo, seja uma franquia de videogame, filme, série de TV ou outro tipo de mídia.

Depois, é necessário planejar o conceito do jogo, incluindo enredo, mecânicas de jogo e estilo artístico. Para desenvolver o fan game, são necessárias habilidades em programação, design de jogos, arte, música e escrita, ou então uma equipe com essas habilidades.

A escolha da engine de jogo é crucial, com opções que vão desde as mais complexas, como Unity e Unreal Engine, até as mais simples, como RPG Maker. Durante o desenvolvimento, é importante testar o jogo regularmente para identificar e corrigir bugs e problemas de jogabilidade.

Após o polimento final, o jogo pode ser lançado e compartilhado com a comunidade de fãs. No entanto, é importante estar ciente das questões legais relacionadas ao uso de propriedades intelectuais protegidas e buscar permissão quando necessário.

Começando seu Fan Game

A primeira parte de um fan game, como falamos acima, é a inspiração. Você já deve ter tido essa inspiração, por isso, estamos aqui, não é? Então, vamos para a parte do planejamento. Uma parte que facilita em se criar um fan game é a parte onde você vai precisar dos assets e sprites dos personagens, em caso de um jogo 2D. Já existem vários por aí na internet que você pode baixar.

Se você quer criar um personagem novo para esse jogo (a fan base de Sonic adora criar personagens e alguns são até meio bizarros) você vai precisar saber alguma coisa sobre a criação de pixel art, caso seja um jogo de pixels. Se for um jogo 3D, aí você vai precisar saber de modelagem no Blender, por exemplo, de personagens em 3D.

Para facilitar nosso exemplo, aqui, vamos trabalhar com um simples jogo em sprites que homenageia o personagem Pac-Man e será feito em Unity.

Desenvolvimento do Jogo:

Para facilitar, vamos começar com um cenário simples. Ele será em um fundo preto e será delimitado por um quadrado branco de 1200×1200 vazado, ou, para facilitar, quatro traves brancas, uma em cima, uma embaixo, uma na esquerda e uma na direita, conectadas uma na outra pelas pontas.

1. Criando o Projeto:

• Abra o Unity e crie um novo projeto 3D.
• Na janela do Hierarchy, exclua o GameObject padrão “Main Camera”.

2. Definindo o Fundo Preto:

• Na janela do Hierarchy, clique com o botão direito e selecione “Create Empty”.
• Renomeie o GameObject para “Background”.
• Na janela do Inspector, adicione um componente “Mesh Renderer”.
• No componente “Mesh Renderer”, selecione “Create Material” no campo “Material”.
• No material recém-criado, defina a cor para preto na propriedade “Albedo”.

3. Criando o Quadrado Branco:

• Na janela do Hierarchy, clique com o botão direito e selecione “3D Object” > “Cube”.
• Renomeie o GameObject para “WhiteFrame”.
• Posicione o “WhiteFrame” no centro da cena (0, 0, 0).
• Na janela do Inspector, defina a escala do “WhiteFrame” para 1200, 1200, 1.
• Altere o material do “WhiteFrame” para o mesmo material preto criado anteriormente.

4. Criando as Traves Brancas:

• Repita os passos 3 e 4 para criar três novos cubos, nomeando-os “TopBar”, “BottomBar”, “LeftBar” e “RightBar”.
• Posicione as traves da seguinte maneira:
  • “TopBar”: (0, 600, 0)
  • “BottomBar”: (0, -600, 0)
  • “LeftBar”: (-600, 0, 0)
  • “RightBar”: (600, 0, 0)
• Ajuste a escala de cada trava para 1200, 100, 1.
• Certifique-se de que o material de todas as traves seja o mesmo material preto.

5. Ajustando a Câmera:

• Na janela do Hierarchy, selecione a câmera principal.
• Na janela do Inspector, ajuste a posição da câmera para que o cenário esteja no campo de visão.
• Você também pode ajustar a rotação da câmera se desejar.

6. Testando o Cenário:

• Pressione o botão “Play” para visualizar o seu cenário.
• Você deve ver um fundo preto com um quadrado branco vazado de 1200×1200 ou quatro traves brancas conectadas.

Preenchendo o Cenário

Agora, vamos preencher o cenário. Aqui você fará o cenário como você quiser. Coloque as barras brancas, assim como você fez com essas 4 barras brancas. Se você não quiser fazer na mão, pode usar um algoritmo de Geração Procedural:

• Algoritmo de Geração: Utilize um algoritmo de geração de labirintos procedural, como o algoritmo de Depth-First Search (DFS) ou o algoritmo de Backtracking. Esses algoritmos criam aleatoriamente um labirinto com base em regras predefinidas.
• Implementação: Você pode implementar o algoritmo em C# ou usar uma biblioteca pronta como a deste vídeo.
• Personalização: Ajuste os parâmetros do algoritmo para controlar a complexidade do labirinto, o tamanho dos corredores e a presença de becos sem saída.

Agora, como eu poderia preencher esse labirinto com bolinhas, igual a um jogo do Pac-man? Queremos que elas fiquem no labirinto e, quando o personagem passar por elas, elas somem, como se tivessem sido ‘comidas’. Vamos ver como:

Posicionando as Bolinhas:

• Script: Crie um script C# para posicionar as bolinhas no labirinto.
• Percorrendo o Labirinto: Utilize um algoritmo para percorrer as células do labirinto (por exemplo, o mesmo algoritmo usado para gerar o labirinto).
• Instanciando Bolinhas: Em cada célula visitada, instancie um prefab de bolinha na posição da célula.
• Ajustando Posição: Ajuste a posição vertical das bolinhas para que fiquem um pouco acima do chão do labirinto.

C#
using UnityEngine;

public class PillSpawner : MonoBehaviour
{
    // Prefab da bolinha
    public GameObject pillPrefab;

    // Tamanho do labirinto
    public int width = 10;
    public int height = 10;

    // Celulas do labirinto
    private bool[,] cells;

    // Start is called before the first frame update
    void Start()
    {
        // Obtém as informações do labirinto
        cells = GetComponent<MazeGenerator>().cells;

        // Posiciona as bolinhas no labirinto
        for (int x = 0; x < width; x++)
        {
            for (int y = 0; y < height; y++)
            {
                if (cells[x, y])
                {
                    Instantiate(pillPrefab, new Vector2(x, y), Quaternion.identity);
                }
            }
        }
    }
}

Detectando Colisão:

• Componente Collider: Adicione um componente “Circle Collider 2D” às bolinhas para detectar colisões.
• Script do Personagem: No script do personagem, adicione um método para detectar colisão com as bolinhas.
• Destruindo Bolinhas: Quando o personagem colide com uma bolinha, destrua o GameObject da bolinha utilizando o método Destroy().

using UnityEngine;

public class PacManController : MonoBehaviour
{
    // Variável de pontuação
    private int score = 0;

    // Texto para exibir a pontuação
    public Text scoreText;

    // Start is called before the first frame update
    void Start()
    {
        scoreText.text = "Score: 0";
    }

    // OnCollisionEnter2D is called when this collider/rigidbody begins touching another rigidbody/collider
    void OnCollisionEnter2D(Collision2D collision)
    {
        // Verifica se a colisão foi com uma bolinha
        if (collision.gameObject.tag == "Pill")
        {
            // Destrói a bolinha
            Destroy(collision.gameObject);

            // Aumenta a pontuação
            score++;

            // Atualiza o texto da pontuação
            scoreText.text = "Score: " + score;
        }
    }
}

Pontuação:

• Variável de Pontuação: Crie uma variável para armazenar a pontuação do jogador.
• Aumentando Pontuação: Incremente a variável de pontuação cada vez que o personagem comer uma bolinha.
• Exibindo Pontuação: Exiba a pontuação do jogador na tela usando um componente “Text”.

Colocando o Pac-Man e os Fantasmas no Cenário

Agora temos que colocar nossas estrelas em campo. Nosso Pac-Man e os fantasmas que vão perseguir ele. Para os Fantasmas, temos um artigo completo sobre Pathfinding em Unity no site, que vai te explicar como fazer os fantasmas se movimentarem e perseguirem o seu jogador.

Se você quiser criar um novo Fantasma, por exemplo, que se comporte de uma maneira diferente dos outros, é sempre importante estudar sobre o Unity. Com os Fantasmas em campo, vamos colocar o Pac-Man. Como fazer que ele se movimente pelas setas do teclado em um cenário 2D sem que ele atravesse as paredes que colocamos no cenário?

Para fazer o Pac-Man se mover pelas setas do teclado em um labirinto 2D na Unity, sem atravessar as paredes, siga estas etapas:

1. Script de Controle do Personagem:

• Crie um script C# para o Pac-Man.
• Atribua o script ao GameObject do Pac-Man.
• Implemente a lógica de movimento:
  • Captura de teclas: Utilize o método Input.GetKey() para detectar o pressionamento das setas do teclado (cima, baixo, esquerda, direita).
  • Movimento horizontal:
    • Se a seta esquerda for pressionada, defina a velocidade horizontal para -1.
    • Se a seta direita for pressionada, defina a velocidade horizontal para 1.
    • Caso contrário, defina a velocidade horizontal para 0.
  • Movimento vertical:
    • Se a seta para cima for pressionada, defina a velocidade vertical para 1.
    • Se a seta para baixo for pressionada, defina a velocidade vertical para -1.
    • Caso contrário, defina a velocidade vertical para 0.
  • Aplicação da velocidade: Utilize o método transform.Translate() para mover o Pac-Man de acordo com a velocidade horizontal e vertical.

using UnityEngine;

public class PacManController : MonoBehaviour
{
    // Velocidade de movimento
    public float speed = 2f;

    // Start is called before the first frame update
    void Start()
    {
        // Define a velocidade inicial para 0
        GetComponent<Rigidbody2D>().velocity = Vector2.zero;
    }

    // Update is called once per frame
    void Update()
    {
        // Captura das teclas pressionadas
        float horizontalInput = Input.GetAxis("Horizontal");
        float verticalInput = Input.GetAxis("Vertical");

        // Cálculo da velocidade
        Vector2 movement = new Vector2(horizontalInput, verticalInput) * speed;

        // Aplicação da velocidade
        GetComponent<Rigidbody2D>().velocity = movement;
    }
}

2. Colisão com Paredes:

• Componente Collider: Adicione um componente “Circle Collider 2D” ao Pac-Man para detectar colisões.
• Script de Detecção de Colisão: Crie um novo script C# para detectar colisões com as paredes.
• OnTriggerEnter2D: Implemente o método OnTriggerEnter2D para detectar colisões com objetos com a tag “Wall”.
• Verificação de Posição: Verifique a posição do Pac-Man em relação à parede.
• Correção de Posição: Se o Pac-Man estiver dentro da parede, corrija sua posição para que fique fora dela.

using UnityEngine;

public class WallCollision : MonoBehaviour
{
    // OnCollisionEnter2D is called when this collider/rigidbody begins touching another rigidbody/collider
    void OnTriggerEnter2D(Collider2D collision)
    {
        // Verifica se a colisão foi com uma parede
        if (collision.gameObject.tag == "Wall")
        {
            // Obtém a posição do Pac-Man
            Vector2 pacManPosition = transform.position;

            // Obtém a posição da parede
            Vector2 wallPosition = collision.gameObject.transform.position;

            // Calcula a direção da colisão
            Vector2 collisionNormal = (pacManPosition - wallPosition).normalized;

            // Corrige a posição do Pac-Man para que fique fora da parede
            transform.position = wallPosition + collisionNormal * 0.1f;
        }
    }
}

Como lidar com questões legais ao criar um fan game?

Lidar com questões legais ao criar um fan game é uma preocupação fundamental para os desenvolvedores. Uma das principais considerações é entender os direitos autorais e a propriedade intelectual relacionados à obra que você está homenageando. Isso envolve pesquisar os detentores dos direitos e verificar se é necessário obter permissão para usar elementos protegidos por direitos autorais.

Em alguns casos, é possível invocar a doutrina do “fair use”, que permite o uso limitado de material protegido por direitos autorais sem permissão, sob certas circunstâncias. No entanto, a aplicação do fair use pode variar dependendo da jurisdição e das circunstâncias específicas do caso.

Outra abordagem comum é realizar uma transformação criativa significativa nos elementos protegidos por direitos autorais, tornando-os substancialmente diferentes do material original. Isso pode ajudar a evitar problemas legais, mas é importante lembrar que não há uma linha clara sobre o que constitui uma transformação criativa suficiente.

Além disso, é importante reconhecer e creditar os detentores dos direitos autorais das obras originais que você está homenageando. Isso demonstra respeito pelos criadores originais e pode ajudar a mitigar potenciais preocupações legais.

Em casos de incerteza ou complexidade, consultar um advogado especializado em direitos autorais ou propriedade intelectual pode ser uma medida prudente. Um profissional legal pode oferecer orientação específica com base na legislação aplicável e nas circunstâncias do seu projeto, ajudando a garantir conformidade legal e minimizando os riscos associados à criação do fan game.

FAQ Rápido