Como projetar um mecanismo de jogo em uma linguagem orientada a objetos? [fechadas]

Sempre que tento escrever um jogo em qualquer linguagem orientada a objetos, o primeiro problema que sempre enfrento (depois de pensar em que tipo de jogo escrever) é como projetar o mecanismo. Mesmo que eu esteja usando bibliotecas ou estruturas existentes como SDL, ainda me vejo tendo que tomar certas decisões para cada jogo, como usar uma máquina de estado para gerenciar menus, que tipo de classe usar para carregar recursos etc.

O que é um bom design e como ele seria implementado? Quais são algumas compensações que precisam ser feitas e seus prós / contras?

Duvido que alguém seja capaz de dizer 'Você precisa fazer isso e aquilo e isso e isso se encaixa no padrão X'.

No entanto, alguns recursos úteis:
Enginuity - uma série de artigos sobre construção de motores em Gamedev.net.
Codificação de jogos concluída - Eu possuo este livro, e ele aborda todos os aspectos da programação de jogos. Ele também possui um mecanismo construído ao longo do livro.
Arquitetura de Game Engine - Este é outro ótimo livro para o design de motores.
Layout do mecanismo C4 - Retirado do meu comentário, mas isso mostra uma maneira de alto nível de encaixar cada parte do mecanismo.

Isso pode ser um pouco demais para o que você precisa, mas você não pode saber muito sobre algo, e tenho certeza de que receberá um bom plano deles.

EDIT: esqueci os artigos Gamedev foram arquivados desde o novo site, corrigido :)

Como exemplo, veja como meu projeto atual roguelike está estruturado (em Java). Ele está usando um mecanismo de gráficos 2D, então muito do código de renderização já foi resolvido para mim. As críticas são bem-vindas.

class Game
Esta classe configura a máquina de estado que gerencia o estado atual do jogo. (em um menu vs. iniciar um novo jogo vs. jogar um jogo salvo)

interface State
Cada classe State contém dois loops: um loop para atualizar a lógica e um loop para renderização. Eles também contêm código para chamar a Gameclasse e solicitar uma alteração em um estado diferente.

class ResourceManager
Um singleton que é inicializado pela Gameclasse que carrega todos os recursos necessários e permite acesso a eles. Não gosto desse design, pois torna difícil carregar / descarregar recursos em diferentes níveis, por exemplo. Eu provavelmente projetaria isso de maneira diferente se estivesse começando de novo.

class Map
Um mapa contém uma matriz de peças e uma lista de todas as criaturas e itens no mapa. É uma aula bem básica.

class Creature
As criaturas contêm informações sobre si mesmas, incluindo cálculos de movimento (exigindo que eles saibam em que mapa estão e que sejam capazes de consultá-las para descobrir obstáculos). Decidir fazer isso ou ter algum tipo de gerente de classe para cuidar de todas as criaturas é algo com o qual luto.

interface AITask
As criaturas podem ter uma lista de tarefas AIT, que são executadas toda vez que o loop lógico da criatura é executado. A AITask tem seu próprio loop lógico que emite comandos para a criatura e uma condição de término que determina se a tarefa foi concluída com êxito ou não.

interface UIElement
Eu implementei minha própria interface para este mecanismo. Cada UIElement possui um loop de renderização e um loop lógico. Eles também têm um loop para processar a entrada do teclado / mouse. Todos os elementos podem ter vários elementos filhos, que são renderizados após os pais, e assumir a entrada do teclado / mouse. Isso permite que você tenha menus com submenus, por exemplo.

O primeiro ponto importante a destacar é que não há uma resposta 'boa' para essa pergunta.

A coisa mais próxima de uma resposta certa seria algo como: Depende muito do tipo de jogo, plataforma de destino, restrições (tempo) etc.

Dito isto, existem alguns artigos realmente bons por aí que mostrarão como outras pessoas tentaram responder a esse problema (como eu tentei encontrar informações sobre isso no passado).
Como o pato comunista mencionou, o artigo de enginuity no game dev me ajudou a entender algumas partes da arquitetura de jogos.

Meu design atual é um híbrido do Quake3 / Doom3 e um pouco da biblioteca de classes .NET :)

Eu tenho duas bibliotecas (estáticas ou dinâmicas depende de como você deseja criar / entregar) o Frameworke o Library.

A Biblioteca contém todas as classes auxiliares que existem para ajudar na produção de software de jogos, mas não estão limitadas a esse tipo de produto. isto é, implementa uma lista vinculada, otimizada para o código do jogo, mas que pode ser usada por qualquer coisa que precise do serviço de uma lista vinculada.

O Framework é a essência do 'mecanismo', se você quiser chamar assim. Muito disso segue as filosofias de design do Quake3 (apenas de uma maneira mais orientada a objetos). Ele contém a CLI , o gerenciamento de tempo, o código específico do SO e, eventualmente, as camadas de rede etc.

Esses dois são vinculados ao aplicativo real que está sendo produzido. O Gamese você gosta, que contém o código específico do jogo. Da mesma forma, o Quake3 carrega DLLs, dependendo de qual 'mod' estiver sendo reproduzido.

Para lhe dar uma idéia da estrutura, aqui está uma rápida decomposição de pastas e conteúdos para cada lib:

• Estrutura
  • IO (classes de gerenciamento de arquivos especializadas, classes de impressão de texto (por exemplo, para a CLI) e registro etc.)
  • Rede
    • Cliente (classes que representam o que o Framework considera uma 'pessoa jogando / conectada ao jogo')
    • Servidor (classes para gerenciar a conexão na estrutura e gerenciar os players)
  • Plataforma (teclado / mouse / controladores manipulando classes, rotinas específicas do SO, como getTime ())
  • Sistema (classes de nível muito baixo, como uma classe de erro, para ajudar na impressão de mensagens de erro, classes de tempo e a própria CLI.)
  • Renderizador (auto-explicativo)
  • etc.

• Biblioteca
  
  • Coleções (classes que representam coleções de dados, listas / hashtables vinculadas etc.)
  • Matemática (classes auxiliares básicas de matemática como vetores e matrizes)
  • etc.

HTH! Deve dar algumas dicas ...

Coisas a considerar

• Linguagens orientadas a objetos têm problemas porque geralmente não possuem funções de primeira classe ou nem todos os dados são objetos (como número inteiro ou flutuante em Java). Os padrões de design solucionam esses problemas com vários padrões. Geralmente é mais rápido codificar e mais fácil manter o uso da linguagem que pode ser usada (objetos de primeira classe); por exemplo, Python (que também permite design orientado a objetos), você terá velocidade mais lenta.
• Cálculo de evento, para AI pelo menos
• Lógica Hoare, use pré-condições e pós-condições para pelo menos testar seu código
• Agentes, olhe para as entidades do Quake
• Bancos de dados relacionais, maneira poderosa de armazenar dados

Bom design

• fazer diagrama de ER
• faça correto
• crie seu banco de dados, objetos ou estruturas de dados a partir dele

Os dados são essenciais para a programação. Se você deseja bons dados, o algoritmo geralmente surge deles (se você não contar alguns algoritmos numéricos, como determinante da computação).