Pergunta

Eu estava pensando mais cedo hoje sobre uma idéia para um jogo pequeno e tropeçou em como implementá-lo. A ideia é que o jogador pode fazer uma série de movimentos que causam um pouco efeito, mas se feito em uma seqüência específica causaria um efeito maior. Até aí tudo bem, isso eu sei como fazer. Obviamente, eu tinha que fazê-lo ser mais complicada (porque nós gostamos de torná-lo mais complicado), então eu pensei que poderia haver mais de um caminho possível para a sequência que ambos os efeitos causa maior, embora diferentes. Além disso, parte de algumas sequências poderia ser o início de outras seqüências, ou mesmo sequências inteiras poderiam ser combatido por outros sequências maiores. Agora eu não sei com certeza a melhor maneira de implementar isso. Eu tinha algumas idéias, no entanto.

1) eu poderia implementar uma lista ligada-n circular. Mas desde que a lista de movimentos nunca acabar, eu temo que poderia causar um estouro de pilha ™. A idéia é que cada nó teria n crianças e ao receber um comando, ele pode levar você a um de seus filhos ou, se nenhuma criança estava disponível para tal comando, levá-lo de volta para o início. Após a chegada em todas as crianças, um par de funções seria executado fazendo com que o efeito de pequenas e grandes. Este poder, no entanto, levar a um monte de nós duplicados na árvore para lidar com todas as possíveis seqüências que terminam nesta jogada específico com efeitos diferentes, o que pode ser uma dor de manter, mas não tenho a certeza. Eu nunca tentei algo este complexo no código, apenas teoricamente. Será que isso existe algoritmo e tem um nome? É uma boa idéia?

2) eu poderia implementar uma máquina de estado. Então, em vez de vaguear em torno de uma lista ligada, eu teria algum interruptor aninhado gigante que iria chamar funções e atualizar o estado da máquina em conformidade. Parece mais simples de implementar, mas ... bem ... não parece divertido ... nem ellegant. switchs gigantes parecem sempre feio para mim, mas isso funcionaria melhor?

3) Sugestões? Eu sou bom, mas eu sou muito inexperiente. A coisa boa do campo de codificação é que não importa o quão estranho é o seu problema, alguém resolveu no passado, mas você deve saber para onde olhar. Alguém pode ter uma idéia melhor do que aqueles que eu tive, e eu realmente queria ouvir sugestões.

Foi útil?

Solução

Eu não sou absolutamente completamente certo de que eu entendo exatamente o que você está dizendo, mas como uma situação análoga, digamos alguém de introduzir um fluxo interminável de números no teclado. '117' é uma sequência de mágica, '468' é um outro, '411799' é outro (que contém o primeiro).

Assim, se o usuário digitar:

55468411799

Você quer fogo 'eventos mágica' no * s:

55468 * 4117 * 99 *

ou algo parecido, certo? Se isso é análogo ao problema que você está falando, então o que dizer algo como (Java-like pseudocódigo): 

MagicSequence fireworks = new MagicSequence(new FireworksAction(), 1, 1, 7);
MagicSequence playMusic = new MagicSequence(new MusicAction(), 4, 6, 8);
MagicSequence fixUserADrink = new MagicSequence(new ManhattanAction(), 4, 1, 1, 7, 9, 9);

Collection<MagicSequence> sequences = ... all of the above ...;

while (true) {
  int num = readNumberFromUser();
  for (MagicSequence seq : sequences) {
    seq.handleNumber(num);
  }
}

enquanto MagicSequence tem algo como: 

Action action = ... populated from constructor ...;
int[] sequence = ... populated from constructor ...;
int position = 0;

public void handleNumber(int num) {
  if (num == sequence[position]) {
    // They've entered the next number in the sequence
    position++;
    if (position == sequence.length) {
       // They've got it all!
       action.fire();
       position = 0; // Or disable this Sequence from accepting more numbers if it's a once-off
    }
  } else {
    position = 0; // missed a number, start again!
  }
}

Outras dicas

Você pode querer implementar uma máquina de estado de qualquer maneira, mas você não tem que transições de estado hardcode.
Tente fazer um gráfico de estados, onde elo entre Estado A para o estado B significará A pode levar a B.
Então você pode atravessar o gráfico em tempo de execução para encontrar onde o jogador vai.

Edit: Você pode definir nó gráfico como:
-state-id
-list de links para outros estados, onde cada elo define:
-state-id
-precondition, uma lista de estados que deve ser visitado antes de ir para este estado

O que você está descrevendo soa muito semelhantes à árvore de tecnologia em uma Civilização jogo ao vivo.

Eu não sei como os autores Civ construído deles, mas eu estaria inclinado a usar um multigrafo para representar possíveis 'movimentos' - haverá alguns que você pode começar em sem 'experiência', e uma vez que você' re neles, haverá vários caminhos até o fim.

Desenhar-out que opções potencial que você pode ter em cada fase do jogo, e depois desenhar linhas que vão de algumas opções para os outros.

Isso deve dar-lhe um começo na implementação, como os gráficos são [relativamente] conceitos fáceis de implementar e utilizar.

soa como um neural network . Você poderia criar um e treiná-lo para reconhecer os padrões que causa os vários efeitos que você está procurando.

O que você está descrevendo soa um pouco semelhante a um gráfico de dependência ou um gráfico palavra. Você pode olhar para aqueles.

@Cowan, @Javier:? Boa idéia, a mente se eu adicionar a ele

Deixe os objetos MagicSequence ouvir o fluxo de entrada de entrada do usuário, que é notificá-los da entrada (broadcast) e deixar cada um deles adicionar a entrada para lá fluxo de entrada interna. Este fluxo é limpo quando a entrada não é a próxima entrada prevista para o padrão que teria o fogo MagicSequence sua ação. Assim que o padrão for concluída, disparar a ação e limpar o fluxo de entrada interno.

Otimizar este apenas por alimentação de entrada para os MagicSequences que estão esperando por ele. Isso pode ser feito de duas maneiras:

  1. Você tem um objeto que permite que todos os MagicSequences conectar com eventos que correspondem com os números em seus padrões. MagicSequence (1,1,7) gostaria de acrescentar-se a got1 e Got7, por exemplo:

    UserInput.got1 + = MagicSequnece [i] .SendMeInput;

  2. Você pode otimizar esse tal que, depois de cada entrada MagicSequences cancelar o registro de eventos inválidos e registrar com os válidos.

criar uma pequena máquina de estado para cada efeito que você deseja. em cada ação do usuário, 'transmissão' para todas as máquinas de estado. a maior parte, então, não vai se importar, mas alguns vão avançar, ou talvez ir para trás. quando um deles atinge a sua meta, produzir o efeito desejado.

para manter o código puro, não codificar as máquinas de estado, em vez construir uma estrutura de dados simples que codifica o gráfico estado: cada estado é um nó com uma lista de eventos interessantes, cada um aponta para o nó seguinte do estado. estado de cada máquina é simplesmente uma referência ao nó estado apropriado.

edit: Parece conselho de Cowan é equivalente a isso, mas ele otimiza suas máquinas de estado para expressar as sequências só simples. parece suficiente para o seu problema específico, mas as condições mais complexas poderia precisar de uma solução mais geral.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top