Fazendo um jogo em C++ usando processamento paralelo

Question

Eu queria "emular" um jogo flash popular, Chrontron, em C++ e precisava de ajuda para começar.(OBSERVAÇÃO:Não para liberação, apenas praticando por mim mesmo)

Basics:
Player has a time machine. On each iteration of using the time machine, a parallel state
is created, co-existing with a previous state. One of the states must complete all the
objectives of the level before ending the stage. In addition, all the stages must be able
to end the stage normally, without causing a state paradox (wherein they should have
been able to finish the stage normally but, due to the interactions of another state,
were not).

Então, isso explica como o jogo funciona.Você deve jogar um pouco para realmente entender qual é o meu problema.

Estou pensando que uma boa maneira de resolver isso seria usar listas vinculadas para armazenar cada estado, que provavelmente será um mapa de hash, com base no tempo ou em uma lista vinculada que itera com base no prazo.Ainda não tenho certeza.

PERGUNTA REAL:

Agora que tenho algumas especificações aproximadas, preciso de ajuda para decidir quais estruturas de dados usar para isso e por quê.Além disso, quero saber qual API/camada gráfica devo usar para fazer isso:SDL, OpenGL ou DirectX (minha escolha atual é SDL).E como eu implementaria estados paralelos?Com threads paralelos?

EDITAR (para esclarecer mais):
SO - Windows (já que este é um projeto de hobby, posso fazer isso no Linux mais tarde)
Gráficos - idioma 2D - C ++ (deve ser C ++ - Isso é prática para um curso no próximo semestre)

Q-Sem resposta:SDL:OpenGL:X direto
Q-Respondido:Evite processamento paralelo
Q-Respondido:Use STL para implementar ações de intervalo de tempo.

So far from what people have said, I should:
1. Use STL to store actions.
2. Iterate through actions based on time-step.
3. Forget parallel processing -- period. (But I'd still like some pointers as to how it
could be used and in what cases it should be used, since this is for practice).

Acrescentando à pergunta, já usei principalmente C#, PHP e Java antes, então não me descreveria como um programador famoso.Que conhecimento específico de C++ ajudaria a tornar este projeto mais fácil para mim?(ou seja.Vetores?)

Answer 1

O que você deve fazer é primeiro ler e entender o ciclo do jogo de "passo de tempo fixo" (aqui está uma boa explicação: http://www.gaffer.org/game-physics/fix-your-timestep).

Então o que você faz é manter uma lista de pares de contador de quadros e ação.Exemplo STL:

std::list<std::list<std::pair<unsigned long, Action> > > state;

Ou talvez um vetor de listas de pares.Para criar o estado, para cada ação (interação do jogador) você armazena o número do quadro e qual ação é executada, provavelmente você obteria os melhores resultados se a ação fosse simplesmente "tecla <X> pressionada" ou "tecla <X> liberada ":

state.back().push_back(std::make_pair(currentFrame, VK_LEFT | KEY_PRESSED));

Para reproduzir os estados anteriores, você teria que zerar o contador de quadros toda vez que o jogador ativasse a máquina do tempo e, em seguida, percorrer a lista de estados para cada estado anterior e ver se algum corresponde ao quadro atual.Se houver, execute a ação para esse estado.Para otimizar, você pode manter uma lista de iteradores onde você está em cada lista de estados anterior.Aqui estão alguns pseudo-código por isso:

typedef std::list<std::pair<unsigned long, Action> > StateList;
std::list<StateList::iterator> stateIteratorList;
//
foreach(it in stateIteratorList)
{
  if(it->first == currentFrame)
  {
    performAction(it->second);
    ++it;
  }
}

Espero que você tenha a idéia...

Threads separados simplesmente complicariam muito o assunto, dessa forma você obteria sempre o mesmo resultado, o que não pode ser garantido usando threads separados (não consigo ver como isso seria implementado) ou um loop de jogo com intervalo de tempo não fixo.

Quando se trata de API gráfica, eu escolheria SDL, pois é provavelmente a coisa mais fácil para você começar.Você sempre pode usar o OpenGL do SDL posteriormente se quiser usar o 3D.

Answer 2

Isso soa muito semelhante a Trança.Você realmente não quer processamento paralelo para isso - a programação paralela é duro, e para algo assim, o desempenho não deve ser um problema.

Como o vetor de estado do jogo crescerá muito rapidamente (provavelmente da ordem de vários kilobytes por segundo, dependendo da taxa de quadros e da quantidade de dados armazenados), você não quer uma lista vinculada, que tem muita sobrecarga em termos de espaço (e pode introduzir grandes penalidades de desempenho devido a falhas de cache se for mal organizado).Para cada linha do tempo paralela, você deseja uma estrutura de dados vetoriais.Você pode armazenar cada linha do tempo paralela em uma lista vinculada.Cada linha do tempo sabe a que horas começou.

Para executar o jogo, você percorre todas as linhas do tempo ativas e executa um quadro de ações de cada uma delas em sincronia.Não há necessidade de processamento paralelo.

Answer 3

Eu já joguei esse jogo antes.Não acho necessariamente que o processamento paralelo seja o caminho a seguir.Você compartilhou objetos no jogo (alavancas, caixas, elevadores, etc.) que precisarão ser compartilhados entre processos, possivelmente com cada delta, reduzindo assim a eficácia do paralelismo.

Pessoalmente, eu apenas manteria uma lista de ações e, para cada iteração subsequente, começaria a intercalá-las.Por exemplo, se a lista estiver no formato <[iteration.action]> então a terceira vez executaria as ações 1.1, 2.1, 3.1, 1.2, 2.2, 3.3, etc.

Answer 4

Depois de encobrir brevemente a descrição, acho que você tem a ideia certa, eu teria um objeto de estado que contém os dados do estado e colocaria isso em uma lista vinculada... Não acho que você precise de threads paralelos...

no que diz respeito à API gráfica, usei apenas opengl, e posso dizer que é bastante poderoso e tem uma boa API C/C++, opengl também seria mais multiplataforma, pois você pode usar a biblioteca messa em computadores *Nix.

Answer 5

Uma ideia de jogo muito interessante.Acho que você está certo ao dizer que a computação paralela seria benéfica para esse projeto, mas não mais do que qualquer outro programa de altos recursos.

A questão é um pouco ambígua.Vejo que você vai escrever isso em C++, mas para qual sistema operacional você está codificando?Você pretende que seja multiplataforma e que tipo de gráficos você gostaria, ou seja, 3D, 2D, de última geração, baseado na web.

Então, basicamente, precisamos de muito mais informações.

Answer 6

O processamento paralelo não é a resposta.Você deve simplesmente "gravar" as ações dos jogadores e depois reproduzi-las para as "ações anteriores"

Então você cria um vetor (lista vinculada individualmente) de vetores que contém as ações.Simplesmente armazene o número do quadro em que a ação foi realizada (ou o delta) e conclua essa ação no “bot fictício” que representa o jogador durante aquela instância específica.Você simplesmente percorre os estados e os aciona um após o outro.

Você obtém o efeito colateral de "quebrar" facilmente o jogo quando um paradoxo de estado acontece simplesmente porque a próxima ação falha.

Answer 7

A menos que você esteja desesperado para usar C++ em sua própria educação, você definitivamente deveria dar uma olhada XNA para sua estrutura de jogos e gráficos (usa C#).É totalmente gratuito, faz muitas coisas por você e em breve você poderá vender seu jogo no Xbox Live.

Para responder à sua pergunta principal, nada do que você já pode fazer no Flash precisaria usar mais de um thread.Basta armazenar uma lista de posições em uma matriz e fazer um loop com um deslocamento diferente para cada robô.