Strategia in tempo reale in RPG maker

[Maxy]

Un saluto a tutti,

da tempo sto pensando di costruire un gioco di strategia in tempo reale. Siccome non ho esperienza con altri tool, pensavo proprio di crearlo con RPG maker xp, dato che sono abbastanza bravino nel modificare gli script.

Però mi rendo conto che rpg maker non sia il tool adeguato per questo genere di giochi.

I problemi principali sono tre (o meglio, tanti io ne vedo):

 

pathfinding

fog of war

IA dei giocatori

 

Eppure in questi mesi, le mie idee si sono raffinate sempre di più su come costruire i primi due script in maniera ottimale perchè funzionino in mappe grandi e senza laggare (se lagga si può comunque fare a turni...)

Rimane il problema del terzo punto (ma se non riuscirò a risolverlo farò una cosa della serie orde di nemici che arrivano da fuori mappa per farti tanto male, tipo strongold)

 

E ora penso, dato che il terzo punto, comunque sarebbe da risolvere anche usando un altro software, continuare con RPG maker può avere senso? Io credo di si, ma mi piacerebbe avere il vostro parere.

[Guardian of Irael]

Direi di sì, hai già fatto i tuoi primi bei punti, mi pare pure compessi ad occhio, quindi non dovresti avere problemi per il terzo, più che limite del tool si tratta di ragionarci per bene su e creare una buona IA, ce l'hanno fatta per BS tattici sul 2k, tu con gli script dovresti avere vita più facile! Su questi calcoli non dovrebbero esserci troppi limiti con l'RGSS! ^ ^

Poi comunque prova e vedi! XD

^ ^

[keroslifer]

Le difficoltà e i problemi vengono fuori con qualsiasi tool quindi, visto che hai già delle idee su come fare, ti consiglio di continuare con rpg maker ;)

[EaglEye]

poi a turni non è un problema.

Ho provato Age Of Empire sul Ds, anche se è a turni non è malaccio.

Certo, in tempo reale è tutto più bello ^^

Se riesci a non far laggare RPG maker va benissimo, secondo me.

[Maxy]

Risposte incoraggianti, che fa sempre piacere sentire...

 

@Guardian, è vero che hanno fatto dei BS tattici, ma sono del genere "avvicinati al personaggio del party più vicino e fagli del male fisico", qui si parla di una IA del tipo raccogli risorse - costruisci un esercito - metti a ferro e fuoco tutto.

La difficoltà è nettamente diversa: è quasi complesso come un gioco di scacchi, immaginati progettare un flowchart e poi immaginati che deve girare con tutti gli altri script senza laggare...

 

Comunque per la cronaca farò uno script che non farà girare tutto il flowchart ogni frame, ma che semmai ad ogni frame applicherà una delle scelte nella casella del flowchart in cui si trova, ovviamente.

Sono ben accetti suggerimenti, se qualcuno è anche lui interessato...

 

Appena ho completato i primi due script, magari posto il progetto e mi metto alla ricerca di qualche pixel artist

 

EDIT: scusate la connessione va a singhiozzo e per sbaglio ho risposto due volte. Cancellate pure l'ultimo messaggio, che io non riesco

Edited February 9, 2012 by Maxy

[Guardian of Irael]

Sì, avevo capito, era più un esempio del tipo i limiti di rpgmaker non è così difficile romperli. Per il lag sta a te vedere, grafica, le risorse che muovi è su questo che devi fare prove, perchè diversi script possono girare tranquillamente insieme.

Poi se intelligentemente fai così

Comunque per la cronaca farò uno script che non farà girare tutto il flowchart ogni frame, ma che semmai ad ogni frame applicherà una delle scelte nella casella del flowchart in cui si trova, ovviamente.

e già in quei due punti di sopra fatti hai visto che tutto funziona bene...

Almeno ci fai qualcosa di innovativo per il tool :D

^ ^

[mikb89]

Beh, ma con i soli calcoli mica rpg maker lagga, quindi su questo aspetto puoi andare tranquillo. Il problema sta nella grafica (e, nell'xp, nel numero di eventi) ma se riesci a sfruttare la fog of war a tuo vantaggio ridisegnando solo quelle zone in cui puoi vedere non dovresti avere problemi.

 

Per il pathfinding comunque gli script dovrebbero già esserci, tipo nel mouse system.

[Maxy]

Beh, ma con i soli calcoli mica rpg maker lagga, quindi su questo aspetto puoi andare tranquillo. Il problema sta nella grafica (e, nell'xp, nel numero di eventi) ma se riesci a sfruttare la fog of war a tuo vantaggio ridisegnando solo quelle zone in cui puoi vedere non dovresti avere problemi.

 

Per il pathfinding comunque gli script dovrebbero già esserci, tipo nel mouse system.

 

Giusto, la fog of war permette di fare un antilag sugli eventi non in vista.

 

Il pathfinding del mouse system è buono per piccole distanze, ma è estremamente dispersivo sulle grandi distanze: per andare da due punti a distanza d lui controlla pigreco d^2 quadretti!

E poi non riesce a decidere se due posti sono davvero raggiungibili, cioè se esiste un cammino fra di essi. Invece io pensavo di fare uno script che controlli se esiste un cammino dritto, e se non esiste provi ad aggirare l'ostacolo. In questo modo è più efficiente, dipende dalla distanza solo linearmente e dal numero e dalla forma degli ostacoli.

 

Intanto posto un primo tentativo di fog of war. Il risultato non lagga, per adesso

 

http://imageshack.us/photo/my-images/94/schermata1vy.png

Edited February 10, 2012 by Maxy

[Guardian of Irael]

Intanto posto un primo tentativo di fog of war. Il risultato non lagga, per adesso

Mmmh sono i miei occhietti speciali da coniglietto o si vedono sia eventi che mappe dietro la fog? XD Così credo sia ancora poco indicativo, almeno hai conferma che il codice non lagga, ma come dice mikb devi darci giù di grafica e vedere D:

^ ^

[Maxy]

Gli eventi si vedono anche dietro la fog perchè non ho ancora fatto l'antilag.

E comunque se non lagga senza l'antilag, non dovrebbe laggare con. (o no?)

Provato con una mappa 500x500 e con 170 eventi che camminano con bassa frequenza. Lagga pochinoinoino, non ci si accorge quasi (e comunque è anche colpa degli eventi) ora devo rendere meno cubettoso il risultato

[Guardian of Irael]

E comunque se non lagga senza l'antilag, non dovrebbe laggare con. (o no?)

Oh beh altrimenti buttalo direttamente nel cestino l'antilag! XD

 

Provato con una mappa 500x500 e con 170 eventi che camminano con bassa frequenza. Lagga pochinoinoino, non ci si accorge quasi (e comunque è anche colpa degli eventi) ora devo rendere meno cubettoso il risultato

Occhio anche al tipo di pc, se hai un 4444 core... XD

Comunque stavo pensando... è un tipo di fog che rimane per sempre? Oppure ci sono truppe od eventi speciali che la eliminano? Non conviene legare l'antilag alla schermata visibile da giocatore invece che alla nebbia di guerra?

^ ^

[Maxy]

L'antilag diventerà preziosissimo in futuro quando ci saranno altri script che dovranno girare assieme a questo

 

 

Occhio anche al tipo di pc, se hai un 4444 core... XD

Comunque stavo pensando... è un tipo di fog che rimane per sempre? Oppure ci sono truppe od eventi speciali che la eliminano? Non conviene legare l'antilag alla schermata visibile da giocatore invece che alla nebbia di guerra?

^ ^

 

si, conviene fare una cosa mista, del tipo NearFantastica con gli eventi/unità fuori visuale e poi, all'interno tolgo tutto quello che è fuori dalla regione di visibilità (ovviamente l'antilag riguarda solo la grafica dell'unità).

Tutte le truppe del giocatore eliminano la nebbia, quindi la fog è destinata a diminuire sempre di più quando uno esplora la mappa, non ho capito la domanda...

 

E comunque il mio pc fa cacare, il pifferaio di Hamelin ci lagga da morire, quindi se qualcosa gira sul mio, gira dappertutto

[Zio Sam]

Hai proprio segnalato i problemi principali, personalmente credo che per creare un rts sia meglio rivolgersi ad altri tools, questi sono venuti fuori da una rapida ricerca con google

http://www.rtsmaker.com/

http://stratagus.sou...net/index.shtml

http://glest.org/en/index.php

 

In passato c'è chi aveva aggirato parzialmente il problema realizzando qualcosa di più simile ad un gestionale a turni, il gioco si chiama Empires, è stato realizzato da Vegas46 con rpgmkr2000 e puoi scaricarlo da qui

[Maxy]

Fico, grazie, quando ho tempo provo Empires.

Io comunque provo lo stesso con rpg maker, che sono preso, prendetela come un esperimento.

 

Piuttosto, ho trovato questo Nebbia di guerra ovviamente c'era già e io non avevo cercato bene (ettepareva)

ma in ogni caso userò il mio script perchè è più bello e perchè il suo è un casino da modificare.

 

Domanda: posso usare la sua maschera della nebbia se poi lo credito?

Edited February 10, 2012 by Maxy

[Guardian of Irael]

si, conviene fare una cosa mista, del tipo NearFantastica con gli eventi/unità fuori visuale e poi, all'interno tolgo tutto quello che è fuori dalla regione di visibilità (ovviamente l'antilag riguarda solo la grafica dell'unità).

Tutte le truppe del giocatore eliminano la nebbia, quindi la fog è destinata a diminuire sempre di più quando uno esplora la mappa, non ho capito la domanda...

Erano tre di domande, ma mi pare che tu abbia capito da come hai risposto! XD

^ ^

 

E comunque il mio pc fa cacare, il pifferaio di Hamelin ci lagga da morire, quindi se qualcosa gira sul mio, gira dappertutto

Perfetto allora! XD Da me il piffero non lagga! XD

^ ^

 

Domanda: posso usare la sua maschera della nebbia se poi lo credito?

Mmmh usare la maschera con un altro script, non credo ci siano problemi dato che l'aveva donata, magari mandagli un MP anche se è da tempo che non connette potrebbe non rispondere D:

^ ^

[Keroro]

Creare un RTS è un'obiettivo molto interessante e non banale.

Il ruby in RGSS è COMPLETAMENTE in GRADO di realizzare un RTS con i fiocchi, la parte difficile è l'integrazione con il sistema sovrastante ed evitare di spendere troppi cicli in cose inutili.

Sviluppare anche un RTS che tenga incollato il giocatore è difficile, bisogna lavorare molto per automatizzare le attività ed incentivare il giocatore a potenziare la città.

Personalmente dopo anni spesi a giocare a Age of Empires 2 ho trovato solo in Age of Mithology uno stimolo.

 

Automatizzare le attività:

Sicuramente qualsiasi attività includa il movimento si deve basare su un algoritmo di pathfinding, il più famoso e usato in campo videoludico è l'A-Star, una variante dell'Algoritmo di Dijkstra, al giorno d'oggi implementato con una Priority Queue per avere una performance di O(n log n) dove n è il numero delle caselle della mappa.

 

L'algoritmo di pathfinding serve per trovare un percorso (formato da una lista di caselle da percorrere) efficiente per arrivare da un punto A ad un punto B.

Non si cerca una soluzione perfetta perché sarebbe computazionalmente lenta ma ci si accontenta di una soluzione sub-ottima.

Per capire se un percorso è migliore di un altro ci si affida ad una funziona che approssima la distanza (usare le radici quadrate è poco performante)

  #--------------------------------------------------------------------------
 # * Heuristic Distance
 #	u : node 1
 #	v : node 2
 #--------------------------------------------------------------------------
 def heuristic_dist(u,v)
dx = xNode(v)-xNode(u)
dy = yNode(v)-yNode(u)
# Manhattan distance heuristic
return (dx.abs+dy.abs)
 end

 

 

Per estrarre il percorso migliore si usa una Priority Queue.

La Priority Queue è una struttura di dati visualizzabile come un albero binario, implementabile sia come lista linkata ma più spesso da un array.

Selezionato un elemento a[k] questo ha due figli situati in a[2*k+1] e a[2*k+2]. L'implementazione garantisce che un padre contiene sempre un valore minore dei propri figli ( a[k] < a[2k+1] e a[k]< a[2k+2]),

Per induzione il k per cui si ha il valore minore è lo 0, la radice dell'albero.

 

Per non incollare litri di codice ho scelto di pubblicare un'implementazione per RpgMaker Xp qui: http://www.rpg2s.net...showtopic=14772

 

Quello che manca a questo script è del codice per utilizzarlo per altre azioni, ad esempio un Evento - omino che deve andare a tagliare la legna si potrebbe fare così:

 

def taglia_albero(albero_x,albero_y)
sx = @x - albero_x
sy = @y - albero_y
# Se è nelle caselle confinanti
if sx == 0 and sy == 0
  #controlli che ci sia davvero un albero
  #chiami la funzione che tagli e animi il taglio
  return
end
dir = $mgraph.AStar(@x,@y,albero.x,albero.y)
case dir
when 1
  move_down
when 2
  move_left
when 3
  move_right
when 4
  move_up
else  # If no path is found
  # Get absolute value of difference
  abs_sx = sx.abs
  abs_sy = sy.abs
  # If horizontal and vertical distances are equal
  if abs_sx == abs_sy
		# Increase one of them randomly by 1
		rand(2) == 0 ? abs_sx += 1 : abs_sy += 1
  end
  # If horizontal distance is longer
  if abs_sx > abs_sy
		# Move towards player, prioritize left and right directions
		sx > 0 ? move_left : move_right
		if not moving? and sy != 0
		  sy > 0 ? move_up : move_down
		end
  # If vertical distance is longer
  else
		# Move towards player, prioritize up and down directions
		sy > 0 ? move_up : move_down
		if not moving? and sx != 0
		  sx > 0 ? move_left : move_right
		end
  end
end
end

L'unico difetto di questa funzione è che finisce che l'evento si muove sopra l'albero mentre vorresti una casella adiacente, inoltre l'algoritmo non funziona se (albero_x, albero_y) non è passabile, quindi devi prima cercare la casella libera adiacente e poi chiamare la funzione su quelle coordinate.

C'è anche da implementare che una volta finito torni al campo base con le risorse, ma è molto facile una volta che hai definito tutte le variabili.

 

Macchina a stati finiti

Un aspetto che trovo affascinante è come gestire gruppi di persone, innanzi tutto come fai a trovare una persona che non fa nulla?

Crei un Enum con tutte le azioni possibili

 

class Lavoro
DISOCCUPATO = 0
FALEGNAME = 1
MINATORE = 2
end

 

Ad ogni evento assegni un attributo che cambi quando gli assegni un compito e resetti quando lo finisce.

@lavoro = Lavoro::DISOCCUPATO

 

In questo modo per trovare una persona che non fa nulla scorri tutti gli eventi della tua fazione in cerca del primo disoccupato.

Edited February 21, 2012 by Keroro

[Maxy]

Fantastico Keroro che mi da tanti consigli!

Io nel frattempo non sono stato con le mani in mano (be' in realtà un pochino) mi sono già informato sull'A* qui http://theory.stanfo...ming/index.html da dove mi pare sia stato tratto l'algoritmo che mi hai linkato, o comunque da cui si è ispirato.

 

In realtà pensavo di usare una combinazione di un pathfinding "dumb" e uno "smart". Lo "smart" sarebbe l'A* oppure il Dijkstra che volevo applicare però ad area, cioè a gruppi diciamo di 3x3 o 4x4 caselle, in modo da ridurre il lag anche in mappe grandi, ignora sassi, eventi e costruzioni per essere più veloce che mai.

Il "dumb" invece sarà il consueto muoviti verso l'eroe, è abbastanza primitivo, ma riesce ad aggirare almeno gli ostacoli convessi.

 

Pensavo di modificare lo script di Near Fantastica per l'algoritmo di Dijkstra, ma devo dire che hai postato una squisita interpretazione dell'A*, la modificherò per il movimento in diagonale quando avro tempo (se avrò tempo! sigh...)

 

 

Devo dire che per quanto riguarda la macchina a stati finiti non ho ben capito l'utilità di creare un enum apposta...

Edited February 21, 2012 by Maxy