Assegnare compiti

In un RTS in cui i lavoratori hanno il compito, ad esempio, di costruire un muro, come fanno i lavoratori a decidere quali muri costruire?

Il giocatore decide quali muri devono essere costruiti dove, ma non assegna singoli lavoratori ai singoli quadrati delle pareti. In molti giochi RTS, i lavoratori svolgono semplicemente compiti che sono vicini a loro, ma nel mio RTS voglio usare il fare strategico di compiti espliciti su quadrati specifici come strategia principale, quindi non voglio che i lavoratori stupidi si raggruppino da qualche parte e lascino ulteriori compiti via non fatto.

Uso l'esempio del muro dell'edificio; potrebbe essere estrarre pietra, fare una strada, raccogliere legna o altro. La cosa fondamentale è che l'utente sceglie dove, ma non chi.

I lavoratori possono lavorare solo su quadrati adiacenti a quadrati accessibili; i quadrati su cui lavorano possono essere impraticabili fino al completamento del lavoro.

Ai lavoratori 1 e 2 viene detto di estrarre i quadrati A, B, C e D.

Possono muovere di un quadrato per tick di gioco e il mining di un quadrato richiede 10 tick.

Come decidi quale lavoratore estrae quale quadrato?

Sembra evidente che 1 dovrebbe estrarre A e 2 dovrebbe estrarre C.

1 è a 4 quadrati da A, quindi avrà terminato l'estrazione in 14 tick. Dove dovrei andare dopo, e perché?

E se ci fosse un altro quadrato - E - da estrarre direttamente sopra B?

Qual è la logica che un lavoratore usa per decidere dove procedere?

Contrassegnare il nodo della risorsa come occupato o limitare il numero di lavoratori con cui un albero può essere utilizzato. Se un lavoro è assegnato per riunirsi ad un certo punto, quello che stai davvero dicendo loro è quello di raccogliere l'albero disponibile più vicino.

Due percorsi principali per questo: un approccio realistico sarebbe quello di valutare e contrassegnare i noccioli delle risorse prima che arrivino. Per evitare strani problemi di accodamento, fornire ai lavoratori un campo visivo per valutare gli alberi. Ciò consente al lavoratore di avvicinarsi a un particolare nodo di risorse mentre cammina verso la patch. Questo dà una limitazione dell'ottimizzazione.

Tuttavia, molti RTS (SC e SC2) non hanno lavoratori che valutano un nodo fino al loro arrivo. Questo guida i lavoratori a vagare finché non viene trovato un nodo di risorse. Ciò consente una maggiore ricompensa di abilità / ottimizzazione, (hai mai visto divisioni di lavoratori fantastiche?) Tuttavia, la maggior parte dei tuoi giocatori sta solo andando a boxare tutto, fare clic ed essere infastidito dal fatto che tutti vanno prima nella stessa posizione.

L'implementazione esatta varierà in base al modo in cui le risorse sono raggruppate. In AoE alberi e pesci sono distese continue, quindi i raccoglitori potrebbero finire molto lontano man mano che il gioco procede. Ma in giochi come SC e Red Alert le risorse si trovano in patch discrete. Quindi un lavoratore deve solo guardarsi attorno in quella particolare patch.

MODIFICA dopo la modifica: non dare troppa importanza alle inefficienze dei lavoratori. Qualsiasi RTS che mi viene in mente ha inefficienze dei lavoratori. Cose come le divisioni dei lavoratori derivano dal fatto che il giocatore è più bravo a gestire i propri lavoratori rispetto al gioco. Penso che potresti avere una prospettiva da programmatore e non un designer. La questione del segno di spunta singola può essere risolta semplicemente modificando i numeri e facendo in modo che i nodi possano essere raccolti in un numero discreto di viaggi. Le inefficienze dei lavoratori ti stanno abbagliando, perché conosci il sistema dietro di esso. Tuttavia, se i tester del gioco non se ne accorgono, non soffermarsi troppo a lungo.

Soluzione e un pensiero:

Soluzione: è possibile posizionare i nodi di raccolta in una coda quando si fa clic, quindi quando un lavoro sale all'inizio di una coda, trovare il valore della coda di attività ponderato per i lavoratori, quindi trovare il vicino più vicino con il valore della coda di attività più ponderato ( valore della coda).

Nel tuo esempio, potresti avere il valore della coda ottimale pari a 0 (senza implicare attività correnti). Aggiungi 1 al valore della coda per ogni quadrato che dovrebbero viaggiare (tempo di viaggio) e 10 per ogni attività (tempo di eseguire l'attività). Rimuovere 1 dal valore della coda di ciascun lavoratore per ogni unità di tempo che passa (se il valore della coda iniziale è 10, dopo 3 unità di tempo il valore della coda sarebbe 7). Quindi trovi il vicino più vicino (nel caso in cui più lavoratori abbiano valori di coda equivalenti) per trovare il lavoratore che dovrebbe svolgere tale attività.

Quindi, per il tuo esempio, supponendo che i nodi di raccolta vengano espulsi dalla coda delle attività in ordine alfabetico (AD) e che non venga eseguito alcun movimento mentre viene visualizzata la coda:

(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.

Unico inconveniente nel farlo in questo modo: altamente computazionale.

Pensato:

In che modo il tuo gioco gestirà il blocco delle risorse? cioè se esiste una griglia 4x4 in cui ogni nodo è una risorsa, i lavoratori possono ottenere i 4 nodi interni? In caso contrario, assicurati che gli operai non si limitino a oziare lì cercando di raggiungerli, ma magari assegna loro un compito diverso e assegna uno dei lavoratori che raccolgono uno dei nodi esterni a quelli interni una volta completato il nodo esterno (inserisci in una coda di attività per il lavoratore).

prova ad avere un sistema di pesi, che se l'albero viene raccolto, calcola una sorta di penalità di accatastamento e anche una sorta di bonus di distanza. (quanto tempo ci vuole per arrivare dal punto A-> B con il legno, e così via. Quindi puoi fare un algoritmo che controlla il legno più vicino e controllare il suo peso, quindi confrontando se è desiderabile e quindi utilizzare quello con il peso più basso.

ovviamente questo richiede una messa a punto. ma l'idea è semplice.

Ogni lavoro dovrebbe avere a) un'importanza b) stato dell'incarico (numero di lavoratori assegnati)

Un lavoratore potrebbe quindi decidere per il lavoro che gli dà il maggior "premio" per volta. La ricompensa è calcolata dall'importanza divisa per il numero di lavoratori assegnati diviso per il tempo che ha bisogno di investire (camminare e fare il lavoro). Se il tuo lavoratore può specializzarsi in lavori (ad es. Tagliare la legna) preferirà effettivamente i compiti che può svolgere in modo efficiente. Ovviamente i lavori dovrebbero essere assegnati solo se possono essere continuati al momento giusto (ad esempio, le risorse necessarie devono essere disponibili).

Per evitare che alcuni lavori vengano annullati per molto tempo (ad es. Perché sono lontani). L'importanza dovrebbe aumentare con il tempo. In caso di raccolta, l'importanza dovrebbe anche dipendere dalla quantità di risorse di quel tipo disponibili / necessarie al momento (ad es. Unità prodotte divise per unità richiesta in un determinato periodo).

Per evitare che i lavoratori cambino rapidamente il loro lavoro, lascia che cambino il loro lavoro attuale, solo se la ricompensa migliora significativamente (di una determinata soglia). Inoltre, è possibile applicare i costi raddoppiati per la camminata iniziale al lavoro, quando si calcolano i valori della ricompensa per volta. Inoltre, è necessario consentire di ricalcolare il lavoro ottimale dei lavoratori uno dopo l'altro, non tutti contemporaneamente.

Inoltre, aggiungi un po 'di casualità ai premi calcolati. Ciò causerà una migliore distribuzione dei lavoratori a diversi lavori (in questo modo non solo "tutti" vanno a fare lo stesso lavoro). Tuttavia, questo effetto è già ridotto ricalcolando in serie il prossimo lavoro ottimale per un lavoratore e adattando il numero di lavoratori già assegnati (più lavoratori nello stesso lavoro riducono il premio previsto).

Potrebbe essere necessario adattare un po 'l'algoritmo, se i tuoi lavori possono essere assegnati a un solo lavoratore. In questo caso, procedi come segue: un lavoratore sceglie il lavoro con la più alta ricompensa per volta (importanza divisa per il tempo individuale necessario). Se un altro lavoratore può fare lo stesso lavoro con una ricompensa prevista più alta alla volta, dà il via al lavoratore attualmente assegnato. Il nuovo lavoratore "disoccupato" cerca quindi di trovare un altro lavoro. Nel tuo esempio potrebbe essere così:

• "C" ha un'importanza molto elevata. E il lavoratore 1 si assegna a "C", anche se è più lontano.
• Il lavoratore 2 viene assegnato successivamente e ha una ricompensa più alta per volta per "C" (meno camminata). In questo modo il lavoratore 1 viene rimosso dal lavoro e assegnato a "C". Questo non è costato tempo, poiché siamo ancora nella stessa fascia oraria di simulazione. Quindi l'utente non vedrà questa riassegnazione del lavoro.
• Il lavoratore 1 è quindi alla ricerca di un altro lavoro. Il lavoratore 1 non dà il via al lavoratore 2 da "C", poiché la sua ricompensa per volta non è migliore. Quindi viene assegnato a "A" o "B" (a seconda dell'importanza). Ancora una volta, questo è ancora all'interno della stessa fascia oraria di simulazione.