Atribuindo tarefas

Em um RTS em que os trabalhadores são encarregados, por exemplo, de construir paredes, como os trabalhadores decidem quais paredes construir?

O jogador decide quais paredes devem ser construídas onde, mas não atribuem trabalhadores individuais a quadrados de paredes individuais. Em muitos jogos de RTS, os trabalhadores simplesmente executam tarefas que estão próximas, mas no meu RTS eu quero usar a execução estratégica de tarefas explícitas em quadrados específicos como a estratégia principal, para que eu não queira que trabalhadores burros se agrupem em algum lugar e deixem as tarefas mais longe longe não feito.

Eu uso o exemplo de construção de muro; poderia ser pedra de mineração, fazendo uma estrada, coletando madeira ou o que seja. O principal é que o usuário escolha onde, mas não quem.

Os trabalhadores só podem trabalhar em quadrados adjacentes a quadrados acessíveis; os quadrados em que trabalham podem ficar intransitáveis ​​até que o trabalho esteja completo.

Os trabalhadores 1 e 2 são instruídos a extrair os quadrados A, B, C e D.

Eles podem mover um quadrado por jogo-tick, e a mineração de um quadrado leva 10 ticks.

Como você decide qual trabalhador extrai qual quadrado?

Parece óbvio que 1 deve minerar A e 2 minerar C.

1 fica a 4 quadrados de distância de A, então a mineração será concluída em 14 ticks. Para onde devo ir a seguir e por quê?

E se houvesse outro quadrado - E - a ser extraído diretamente acima de B?

Qual é a lógica que um trabalhador usa para decidir para onde prosseguir?

Marque o nó do recurso como ocupado ou limite o número de trabalhadores pelos quais uma árvore pode ser usada. Se um trabalho for designado para reunir em um determinado ponto, o que você realmente está dizendo a eles é colher a árvore disponível mais próxima.

Dois caminhos principais para isso: Uma abordagem realista seria avaliar e marcar o número de recursos antes que eles chegassem. Para evitar problemas estranhos nas filas, ofereça aos trabalhadores um campo de visão para avaliar as árvores. Isso permite que o trabalhador se aproxime de um nó de recurso específico enquanto caminha para o patch. Isso fornece um limite limitado de otimização.

No entanto, muitos RTSs (SC e SC2) não têm trabalhadores que avaliam um nó até chegarem. Isso leva os trabalhadores a passear até que um nó de recurso seja encontrado. Isso permite mais recompensas por habilidade / otimização (você já viu divisões impressionantes de trabalhadores?) No entanto, a maioria dos seus jogadores apenas encaixa tudo, clica e fica irritada por todos irem para o mesmo local primeiro.

A implementação exata variará com base em como os recursos são agrupados. No AoE, árvores e peixes são extensões contínuas, portanto os coletores podem acabar bem distantes à medida que o jogo avança. Mas em jogos como SC e Red Alert, os recursos estão localizados em patches discretos. Portanto, um trabalhador precisa apenas olhar em torno desse patch em particular.

EDITAR após a sua edição: não se preocupe demais com as ineficiências do trabalhador. Qualquer RTS em que consigo pensar tem ineficiências do trabalhador. Coisas como divisão de trabalhadores surgem porque o jogador é melhor em gerenciar seus trabalhadores do que no jogo. Eu acho que você pode ter uma perspectiva de programadores nisso e não de designers. A questão da esquerda com marcação simples pode ser contornada apenas ajustando números e tendo nós que podem ser colhidos em um número discreto de viagens. As ineficiências dos trabalhadores estão gritantes para você, porque você conhece o sistema por trás disso. No entanto, se seus testadores de jogo não perceberem, não demore muito.

Solução e um pensamento:

Solução: você pode colocar os nós de coleta em uma fila quando clicados e, à medida que um trabalho subir para o topo de uma fila, localize o valor da fila de tarefas ponderada dos trabalhadores e encontre o vizinho mais próximo com o melhor valor da fila de tarefas ponderada ( valor da fila).

No seu exemplo, você pode ter o valor ideal da fila como 0 (implicando em nenhuma tarefa atual). Adicione 1 ao valor da fila para cada quadrado que eles precisariam percorrer (tempo de viagem) e 10 para cada tarefa (tempo para executar a tarefa). Remova 1 do valor da fila de cada trabalhador para cada unidade de tempo que passa (se o valor inicial da fila for 10, após 3 unidades de tempo, o valor da fila será 7). Em seguida, você encontra o vizinho mais próximo (no caso de vários trabalhadores terem valores de fila equivalentes) para encontrar o trabalhador que deve executar essa tarefa.

Portanto, para o seu exemplo, supondo que os nós de coleta saiam da fila de tarefas em ordem alfabética (AD) e nenhum movimento seja feito enquanto a fila aparece:

(values in format [total] = [preexisting value] + [current task distance])
A Pops: 
    queue value of 1: 4 = 0 + 4 
    queue value of 2: 19 = 0 + 19
    Assigned to 1.
B Pops:
    queue value of 1: 24 = 14 + 10 (distance to B from A) 
    queue value of 2: 9 = 0 + 9
    Assigned to 2.
C Pops:
    queue value of 1: 25 = 14 + 11
    queue value of 2: 20 = 19 + 1 
    Assigned to 2.
D Pops:
    queue value of 1: 36 = 25 + 11
    queue value of 2: 41 = 20 + 21
    Assigned to 1.

Desvantagem de fazê-lo assim: altamente computacional.

Pensamento:

Como seu jogo vai lidar com o bloqueio de recursos? ou seja, se existe uma grade 4x4 em que cada nó é um recurso, os trabalhadores podem obter os 4 nós internos? Caso contrário, certifique-se de que os trabalhadores não fiquem ociosos lá tentando alcançá-los, mas talvez atribua a eles uma tarefa diferente e atribua um dos trabalhadores que reúne um dos nós externos aos internos quando o nó externo estiver completo (coloque em uma fila de tarefas para o trabalhador).

tente ter algum sistema de peso, que, se a árvore estiver sendo coletada, calcule algum tipo de penalidade de empilhamento e também algum tipo de bônus de distância. (quanto tempo leva para chegar do ponto A-> B com a madeira e assim por diante. você pode executar um algoritmo que verifique a madeira mais próxima, verifique o peso e compare se é desejável e, em seguida, use aquele com o menor peso.

é claro que isso requer algum ajuste fino. mas a ideia é simples.

Cada trabalho deve ter a) uma importância b) status de atribuição (número de trabalhadores designados)

Um trabalhador pode então decidir pelo trabalho que lhe dá mais "recompensa" por vez. A recompensa é calculada pela importância dividida pelo número de trabalhadores designados dividido pelo tempo que ele precisa investir (andando e fazendo o trabalho). Se o seu trabalhador puder se especializar em trabalhos (por exemplo, corte de madeira), ele realmente preferirá as tarefas que pode executar com eficiência. Obviamente, os trabalhos só devem ser atribuídos, se puderem ser continuados no momento certo (por exemplo, os recursos necessários devem estar disponíveis).

Para evitar que alguns trabalhos sejam desfeitos por muito tempo (por exemplo, porque estão longe). A importância deve aumentar com o tempo. No caso da colheita, a importância também deve depender de quantos recursos desse tipo estão disponíveis / necessários no momento (por exemplo, unidades produzidas divididas pela unidade solicitada em um determinado período).

Para evitar que os trabalhadores mudem seu trabalho rapidamente, deixe-os mudar apenas de emprego atual, se a recompensa melhorar significativamente (em um determinado limite). Além disso, você pode aplicar os custos dobrados para a caminhada inicial para o trabalho, ao calcular os valores da recompensa por tempo. Além disso, você deve permitir recalcular o trabalho ideal dos trabalhadores, um após o outro, não todos ao mesmo tempo.

Além disso, adicione alguma aleatoriedade às recompensas calculadas. Isso causará uma melhor distribuição dos trabalhadores para trabalhos diferentes (dessa forma, eles não apenas "todos" fazem o mesmo trabalho). Porém, esse efeito já é reduzido, recalculando em série o próximo trabalho ideal para um trabalhador e adaptando o número de trabalhadores já designados (mais trabalhadores no mesmo trabalho reduzem a recompensa esperada).

Talvez o algoritmo precise ser adaptado um pouco, se seus trabalhos puderem ser atribuídos apenas a um trabalhador. Se for esse o caso, faça o seguinte: Um trabalhador escolhe o trabalho com maior recompensa por tempo (importância dividida pelo tempo individual necessário). Se outro trabalhador puder fazer o mesmo trabalho com uma recompensa esperada mais alta por vez, ele inicia o trabalhador atualmente atribuído. O novo trabalhador "desempregado" tenta encontrar outro emprego. No seu exemplo, isso pode ser assim:

• "C" tem uma importância muito alta. E o trabalhador 1 se atribui a "C", mesmo que ele esteja mais longe.
• O trabalhador 2 é designado a seguir e tem uma recompensa mais alta por tempo para "C" (menos caminhada). Por isso, retira o trabalhador 1 do trabalho e se atribui a "C". Isso não custou tempo, pois ainda estamos no mesmo intervalo de simulação. Portanto, o usuário não verá essa reatribuição do trabalho.
• O trabalhador 1 está procurando outro emprego. O trabalhador 1 não inicia o trabalhador 2 de "C", pois sua recompensa por tempo não é melhor. Então ele é designado para "A" ou "B" (dependendo da importância). Novamente, isso ainda está no mesmo intervalo de tempo da simulação.