Esta é uma pergunta de acompanhamento para esta outra .
Gostaria de saber se existe um padrão comum / típico / melhor para dimensionar minha representação do mundo (atualmente 160Kmx160Km) para ajustá-lo à área de desenho (atualmente 800x600 pixels).
Posso pensar em pelo menos quatro abordagens diferentes:
Um ingênuo (do jeito que eu fiz até agora). Eu implementei uma função global sc(vector)
que simplesmente retornará uma cópia reduzida do vetor passado. Isso obviamente funciona, mas me obriga a escrever código como:
drawCircle(sc(radius), sc(position))
Funções de quebra automática . Eu poderia definir várias funções, cada uma envolvendo o middleware original. Por exemplo, eu poderia definir myDrawCircle
que primeiro escalaria os argumentos que precisam de escala e depois chamasse drawCircle
com o último. Isso tornaria meu código talvez mais legível e mais fácil de manter, mas eu deveria escrever muitas funções de agrupamento, que parecem bobas.
Decorador de funções . Eu poderia simplesmente decorar as funções de middleware existentes, fornecendo escala automática para todos os parâmetros que são uma instanciação da classe Vector3D
, mas o problema é que essas funções também funcionam com os mesmos parâmetros, list
ou Vector2D
seja, e o decorador não teria como saber quais listas precisam ser redimensionadas (o raio, por exemplo) e quais não (os valores RGB).
Inicialização de superfície . Ao definir a superfície em que vou desenhar, eu poderia definir o fator de escala (para então usar metros e não pixels como parâmetros). Isso funcionaria de forma transparente para mim e seria minha solução preferida, mas é claro que deveria ser implementado no middleware, portanto não é uma opção real.
... de qualquer maneira: como esse é um problema muito comum, pergunto-me se existe um padrão estabelecido que resolva elegantemente esse problema que não consegui encontrar.
PS: Para este projeto, estou usando python (com pygame ), mas - embora uma resposta específica para python / pygame seja muito apreciada, estou mais interessado na descrição geral / de alto nível do padrão do que em sua implementação concreta.
Agradecemos antecipadamente pelo seu tempo e experiência.
fonte
Geralmente, as pessoas não tentam executar a escala de tempo de execução em jogos 2D. Não concordo que seja um problema comum. Se as pessoas desejam um mini-mapa ou algum outro redimensionamento fixo, geralmente há um novo conjunto de gráficos para esse fim. É raro que você precise de uma única rotina para executar em 2 níveis de zoom diferentes em um jogo 2D.
Se você usa uma API 3D, pode obter essa funcionalidade gratuitamente - basta alterar os parâmetros da câmera / porta de visualização.
PyGame é uma API muito antiga e, infelizmente, só é realmente adequada para 2D. Mesmo que você possa trabalhar com sistemas de dimensionamento adequados para os diferentes níveis de zoom, o desempenho não será bom o suficiente e a aparência provavelmente será inaceitavelmente ruim.
Eu recomendaria que, se você quiser aumentar e diminuir o zoom, mude para uma API 3D moderna o mais rápido possível. Eu recomendaria o pyglet, mas provavelmente também haverá outros.
fonte
pyglets
no passado para uma simulação 3D. É certamente mais capaz do quepygame
, mas o suporte ao 2D é de nível bastante inferior ao do Windowspygame
. A documentação / exemplos disponíveis também são menos detalhados, o que é uma chatice para mim, pois sou iniciante no desenvolvimento de jogos e preciso realmente entender a base das operações mais executadas. :) Quanto à "idade" do pygame: você está certo. Uma modernização está em andamento, no entanto! :)pygame.sprite.LayeredUpdates
por exemplo). Quanto à relação imutável: entendi o que você quer dizer. O comportamento que você descreve não é o que quero replicar, mas entendi o que você quer dizer, obrigado pelo esclarecimento! :)