Trama e meccanica di gioco

Dopo lunghe ricerche, l’equipaggio della nave spaziale Elyon 5 trova un pianeta ricco d’oro. La squadra Keruva, pilotata da Kay in compagnia della dottoressa Evelyn, la bionda protagonista del gioco, va in ricognizione verso il nuovo mondo; il primo obiettivo da raggiungere è quello di segnalare le coordinate alla nave per l’estrazione di minerali. Verificati i parametri ambientali, quali: la presenza di acqua e l’atmosfera, ricca a sua volta di ossigeno, azoto e idrogeno, Kay decide di atterrare sull’invitante corpo celeste. Si rivelano forme di vita, ma nessun segno di civiltà. Ad atterraggio effettuato, Evelyn e la fredda Kay, si ritrovano immerse in una sorta di paradiso verde, ricco di vegetazione e di copiosi corsi d’acqua. Ha a questo punto inizio l’avventura. La missione introduttiva, come poc’anzi detto, prevede che il giocatore, nelle vesti della dottoressa, si cimenti nell’installazione dei segnalatori, utili per la destinazione della nave estrattrice di minerali. Per interagire con l’ambiente circostante e per usare l’oggetto di turno, “ickh” propone un menù a croce di immediato utilizzo, composto dalle seguenti quattro voci: esamina, raccogli, usa e azione. Vediamo quest’ultime nel dettaglio:

Esamina: fornisce maggiori informazioni sull’oggetto con cui si interagisce;

Raccogli: raccoglie l’oggetto e lo mette nell’inventario;

Usa…: apre l’inventario per scegliere un oggetto da utilizzare con quello selezionato;

Aziona: attiva/avvia l’oggetto selezionato.

Ogni mappa del titolo richiederà il raggiungimento di un determinato obiettivo, perseguibile analizzando l’area, raccogliendo gli oggetti di rito e utilizzando quest’ultimi laddove serve. Le ambientazioni sono sostanzialmente due: la foresta del pianeta e l’interno della Elyon 5. La difficoltà del gioco si mantiene sulla media. Capire come procedere non è scontato ma neanche arduo. Tuttavia, la mappa finale richiederà qualche neurone in più per il suo completamento, grande perspicacia a parte.

Comparto tecnico e audio

Rpg maker 2003 ha un fascino retrò indescrivibile e questo credo metta tutti d’accordo; quando a questo viene aggiunta la sapiente scelta delle risorse e l’ottima capacità relativa alla loro distribuzione, ecco che la piccola perla è pronta. L’ambiente risulta particolarmente dettagliato; ogni elemento è posto nel punto giusto e nel modo giusto. Particolarmente azzeccata è la colonna sonora. Ogni musica di sottofondo è associata in maniera certosina alla specifica mappa, garantendo un ottimo grado di coinvolgimento nella missione di riferimento.

Conclusioni

 Elyon 5 è un prodotto che mostra carattere, capace di rispecchiare fedelmente sia le meccaniche delle gloriose avventure grafiche che le atmosfere ad essere relative. Si tratta di un titolo breve, ma intenso. Ne consiglio il completamento anche solo per il finale, davvero ben pensato e originale. Dunque cos’altro aspettare, il prodotto è pronto per colmare piacevolmente un piccolo spicchio della vostra giornata.

Benvenuti nell’umile dimora di Evil Lord

Le terre esterne sono minacciate, ed un losco figuro, Evil Lord, ne sa qualcosa. Quest’ultimo, colto da manie di conquista, vuole appropriarsi di tutto ciò che circonda la torre. Il nostro protagonista, un impavido giovane desideroso di avventura, farà ciò che è nelle sue facoltà per impedire che le cattive intenzioni di Evil Lord si concretizzino. La storia ha dunque inizio con l’arrivo dell’eroe alle porte dell’antagonista, il quale, senza troppi problemi, non farà che ridergli in faccia.

La sfida dunque ha inizio. Il duello finale potrà avere luogo solo dopo il raggiungimento della cima. La trama, nella sua estrema semplicità, è solo un pretesto per proporvi le venti sfide prima citate. Quest’ultime, nella loro progressione, non saranno tuttavia caratterizzate da una difficoltà sempre crescente, ma la complessità dell’ostacolo sarà intrinseca del piano corrente oltre che soggettiva per il giocatore. Fin da subito sarà possibile imbattersi in eventi ostici, mentre verso le ultime stanze alcuni tranelli potrebbero rivelarsi più misericordiosi nei vostri confronti. L’esperienza di gioco è piuttosto varia. Si alterneranno: inseguimenti, combattimenti in tempo reale, prove di abilità ed enigmi. Non tutte le prove sono ispirate, ma alcune risultano davvero ben congegnate. Sebbene infatti possa risultare riuscita una stanza che propone la versione alternativa del celebre gioco “Campo minato”, tipico dei sistemi operativi Windows, potrebbe comportare più di una imprecazione una sfida in cui trovare l’uscita richiederà il superamento di pareti praticamente invisibili. Peggio ancora, sarete chiamati in causa qualora ci sarà bisogno di intraprendere un labirinto con il protagonista non più visibile all’occhio del giocatore. Molto ben fatti sono invece a mio avviso gli enigmi e le prove di abilità. Sui primi vi cito il “piano musicale”, ma senza entrare nel merito; sulle seconde invece, vi ritroverete spesso e volentieri a dover intraprendere un percorso tentando di scansare fuochi fatui et simili. I combattimenti in tempo reale, nominati qualche rigo fa, consisteranno nel colpire i nemici con delle bolle di energia. I mostriciattoli in cui vi imbatterete vi accoglieranno o rispondendo in maniera analoga al vostro attacco o venendovi semplicemente addosso con velocità variabili. Alcuni mostri saranno più lenti, altri più celeri. Ora, indipendentemente dalla stanza, il vostro scopo sarà sempre lo stesso: partire da un punto A e raggiungere il punto B. Per stuzzicare maggiormente il giocatore, Nerghray ha pensato di inserire in ogni livello una sfera da trovare. Scovare questa in ogni stanza vi consentirà di sbloccare il finale “reale” del gioco; un epilogo che rasenta praticamente la genialità. Al termine dell’avventura, verrete infine giudicati con un voto, la media di ogni valutazione associata ad un determinato livello. Sarà vostro interesse quindi superare gli ostacoli nel minor tempo, errori e danni subiti possibili. Il gioco, per quanto possa risultare frustrante in alcuni punti, non è assolutamente proibitivo, ma alla portata di tutti. Nonostante questo sa essere coinvolgente al punto giusto. Un passatempo davvero gradevole che consiglio a chi vuole godere di una partita rapida o anche di un’oretta sana, senza troppi fronzoli per la testa. Una nota la spendiamo infine sulla grafica. Ogni mappa di The Tower si presenta minimale allo stremo e questo potrebbe far storcere il naso a chi predilige ambientazioni particolarmente dettagliate.

Tuttavia, una mappa nuda e cruda ha il vantaggio di negare al giocatore delle distrazioni inutili, suggerendo a quest’ultimo, passivamente, ciò che di concreto deve fare. Le ambientazioni sono piuttosto variegate. Zone laviche, lande di ghiaccio e prati verdi vi attendono all’interno di quello che sembra, visto da fuori, un ammasso di fredde rocce. Insomma, Evil Lord si tratta abbastanza bene.

Conclusioni

The Tower è un giochino. Come poc’anzi detto, è un passatempo capace di farvi divertire per una manciata di minuti. Con una maggiore cura poteva forse spingersi oltre, ma la carriera di Nerghray è ancora lunga, e ci auspichiamo che un eventuale sequel possa colmare le lacune che questo suo primo lavoro ripone al momento dentro di se. Non si esclude tuttavia che le prossime versioni del titolo possano comunque migliorarlo.

Mak Man

Il titolo sviluppato dal buon Ghost Rider è un giochino di tutto rispetto, un arcade volendo usare un termine tecnico, che propone in una veste alternativa il classico Pac Man. A detta dell’autore, Mak Man è stato concepito per scherzo; giusto per colmare una mezzoretta altrimenti noiosa. Sorpreso del risultato, Ghost Rider decide di migliorarlo, sia graficamente che nei contenuti. Senza volerlo, ha dimostrato in piccolo la potenza di Rpg Maker. Come lascia intendere il nome, il prodotto della Enterbrain è lo strumento utile per creare un gioco di ruolo, tuttavia, c’è stato appena dimostrato che lo stesso, se solo lo si volesse, può dar vita a platform e perchè no, anche a ben altri generi. Mak Man è un clone del più celebre titolo Namco, ma nonostante questo ha una sua identità; nel suo piccolo, scopre carisma e creatività. Allo stato attuale il giocatore potrà scegliere solo due dei personaggi disponibili, nonchè gli alter ego degli amministratori di Makerando.com, Denzel e lo stesso Ghost Rider. A secondo di quale personaggio sceglierete cambieranno i nemici ma non il livello di difficoltà.

Scegliendo Ghost Rider, vi vedrete alle prese con un “NEMESIS?!!!“ ed i suoi agguerriti animaletti domestici. L‘unico stage attualmente disponibile, composto da ben 10 livelli, si presenta come un’allegra landa verde in cui le pozzanghere/buche con acqua andranno a formare tortuosi labirinti.

Sulla meccanica di gioco credo ci sia ben poco da dire. Il vostro scopo sarà quello di prendere tutte le stelline prima che i nemici facciano uso delle vostre luccicanti viscere. In caso di sconfitta il gioco saprà tuttavia come consolarvi:

Emh… grazie!!!

Gorn il barbaro.

Ragazzi, qui è scesa la lacrimuccia. Chi come me ha avuto la fortuna di nascere negli anni 80, ma soprattutto, è cresciuto a forza di Nes (Nintendo Entertainment System) e pane con la Nutella, saprà comprendere l’impatto che ho avuto a partire dalla schermata di gioco. “Corbezzoli!!!“, mi son detto. “Ma questo è Megaman in formato Golden Axe!“. Per chi non lo sapesse, Megaman è un platform, un‘icona dei videogames, nato da mamma Capcom e cresciuto nel pixelloso mondo degli 8 bit. Stefano Zucca ha saputo con grande inventiva riprodurre gli stessi elementi caratterizzanti le produzione dei bei tempi che furono, quali: musiche e grafica. Una ventata di nostalgia avvolgerà noi veterani, ma non lascerà indifferente chi ama la grande arte dei videogiochi. Il gioco apre ad un villaggio devastato e in fiamme, in cui, senza perderci in chiacchiere, verremo catapultati nella mischia. La giocabilità è molto macchinosa. A colpi di fendenti dovremo farci strada attraverso un orda di nemici che si fionderanno contro di noi senza troppi convenevoli. Non potremo saltare e guai a voi se le asce da lanciare dovessero giungere al termine. Il titolo è spietato e brutalmente complicato. Per quanto frustrante possa essere, Gorn il barbaro è un’idea geniale. Stiamo parlando di un gioco unico come pochi. Non è un capolavoro, ma è un concentrato di citazioni. Sembra essere un documento storico che riassume in breve l’era che va dall’Atari alla prima console Nintendo. Signori miei, qui stiamo parlando di un progetto che vuole distinguersi dalla massa. Un titolo che vuole evadere dal comune gdr trito e ritrito. Meditate gente, meditate. Non servono grandi trame per venire alla luce tra tanti, ma basta avere passione per partorire un qualcosa di unico. Questo progetto non passerà probabilmente alla storia, ma ha voluto dire la sua e nel farlo credo abbia colpito forte e deciso.

Conclusioni.

Credo ci sia una bella differenza tra lo sviluppo con passione e lo sviluppo per sentito dire. Spesso si vive nell’illusione che una manciata di script, risorse e sfondi creati da Picasso e Michelangelo possano fare la differenza. Per me si vince col cuore e non con l’apparenza. Volete essere ricordati per le vostre idee? Prendete esempio da Mak Man e Gorn il barbaro. Quest’ultimi nella loro estrema semplicità hanno poco da offrire, ma quel poco sono sicuro che sfami a sufficienza.

Trama(?).

Yume Nikki, il “Diario dei sogni” nella lingua nostrana, è un prodotto atipico all’interno del quale impersoneremo l’inespressiva Madotsuki, una bambina di cui non si avrà alcuna informazione. Il gioco ha inizio all’interno della stanza della protagonista, adibita di televisione, console, scrivania, libreria e letto. Non avremo alcuna introduzione alla trama, ma spetterà al giocatore la sua interpretazione. Qualora decideste di avvicinarvi alla porta e di interagire con essa, riceverete un cenno di dissenso da parte di Madotsuki, come segno di repulsione nei confronti del mondo esterno. Questa caratteristica ha dato il via alle teorie più disparate. Si è ipotizzata una ambientazione post apocalittica ove Madotsuki sia l’unica sopravvissuta, rifiutandosi di seguito di abbandonare la propria camera. Questa ipotesi sembrerebbe suggerita dal tetro cielo notturno che si mostra al giocatore uscendo fuori al balcone e dal fatto che il suo sembra essere l’unico palazzo rimasto in piedi. Inoltre la TV non riceve alcun canale. Il Nintendo Famicon sarà l’unico motivo per il quale il televisore avrà un senso. Interagendo con la console sarà possibile accedere ad un minigioco, “NASU”, un semplice arcade che vede come protagonista un personaggio rosso col naso a punta, il cui scopo è quello di raccogliere delle melanzane cadenti dal cielo.

Altra ipotesi, partorita dagli appassionati, è quella per la quale Madotsuki sia rimasta vittima di uno stupro, trovando come conseguenza rifugio nella sua camera da letto. Il tema dell’essere costantemente osservati è frequente nei sogni della giovane. Molte creature che fanno da sfondo scrutano fino all’ultimo i passi della protagonista. Nel gioco sono inoltre presenti elementi che lasciano trapelare ad allusioni sessuali; le mani sono molto presenti nelle lande oniriche, e queste nel  loro movimento sembrano simulare l’atto del palpeggiamento. Altre immagini, sembrano perfino rappresentare una fellatio o un canale uterino.

Ora, tralasciando le interpretazioni, la bellezza del titolo sta proprio nel minimalismo puro, tale da lasciar scrivere all’interlocutore la trama che egli meglio crede o percepisce. Yume Nikki è la dimostrazione che la bellezza di una qualsivoglia storia non sta necessariamente dietro ad una narrazione, ma può essere al contrario arricchita da affascinanti supposizioni. Madotsuki riesce ad evadere dal suo rifugio solo all’interno dei suoi sogni. La sua unica via di uscita è infilarsi nel letto, chiudere gli occhi, e ritrovarsi libera a vagare in un ampio mondo psichedelico.

Benvenuti nel Nexus!

Coricata nel letto, parte il conto alla rovescia. Madotsuki si risveglia nella sua stanza, ma non appartiene più alla realtà. Adesso può uscire dalla porta. La dimensione che la attende non le fa paura. Il primo luogo raggiungibile del mondo dei sogni è il Nexus, una sorta di sala centrale che accoglie 12 porte disposte in cerchio. Ogni porta consente l’accesso ad un particolare luogo. Non mancheranno ambienti innevati, zone costituite da neon, livelli lugubri “abbelliti” da bulbi oculari e arti mozzati in movimento e così via. Il vostro scopo sarà quello di esplorare nel dettaglio ogni singola dimensione in modo da trovare gli “effetti”. Si tratta di 24 oggetti nascosti o posti nei punti più impensabili, e solo dopo il loro completo ritrovamento potrete terminare il gioco. Ogni effetto regala a Madotsuki una modifica del proprio aspetto. La protagonista potrà ad esempio assumere le sembianze di una strega, diventare un semaforo con le gambe, trasformarsi in una testa mozzata, o semplicemente cambiare acconciatura (qualcuno ha parlato di “capelli di cacca”?). Alcuni effetti saranno indispensabili per il continuo del gioco, mentre altri avranno un ruolo solo marginale. Le ambientazioni, nella loro varietà, hanno in comune degli elementi oscuri. Figure grottesche ornano i vari ambienti o si materializzano come innocue creature amorfe. In Yume Nikki non ci sono nemici. Le uniche presenze che assumano in qualche modo il ruolo di antagonisti sono i Toriningen, in italiano “uomini uccello”. Quest’ultimi sono esseri simili a persone, snelli e col naso appuntito (simile ad un becco). Il contatto con i Toriningen non vi condurrà alla morte, ma verrete teletrasportati in una zona in cui la protagonista non potrà liberarsi se non pizzicandosi la guancia, col conseguente ritorno alla realtà. Infine, una parola va spesa per le musiche del progetto di Kikiyama. Queste contribuiscono a rendere oscura l’atmosfera del titolo. Si tratta di un loop continuo di suoni disturbanti seppur semplici. I toni sono penetranti, entrano nel cervello e nei timpani come se fossero aghi.

Conclusioni

Yume Nikki è un’opera d’arte nel senso vero del termine. Ogni mappa o luogo che sia è un quadro, una tela dipinta da una pittura dalle cupe tinte. Definire il progetto di Kikiyama con la parola “gioco” potrebbe perfino trarre in inganno. Le azioni che sarete portati ad intraprendere si limiteranno principalmente nel trovare i 24 effetti, esplorando nel dettaglio ogni singolo pixel, e nell’usufruire delle peculiarità degli stessi per avanzare nell’avventura. Ciò che a mio parere giustifica il download del gioco sta nel godere delle visioni della piccola Madotsuki. Ogni personaggio, per quanto strambo e informe possa essere, sembra nascondere un significato subliminale. Questo titolo è un prodotto di nicchia che va compreso, percepito, assorbito. Va vissuto. E’ un prodotto che richiede molta pazienza perché sarà inevitabile vagare nel vuoto anche per ore. Se siete pronti ad affrontare Yume Nikki con l’idea di trascorrere del tempo in una galleria d’arte, allora entrerà facilmente nei vostri cuori. Se vi aspettate invece un normale videogioco utile a colmare qualche spazio vuoto della vostra giornata, non credo risulterà compatibile con le vostre esigenze.

]]> https://www.makerando.com/gamerlog/recensione-yume-nikki/feed/ 0 https://www.makerando.com/gamerlog/rpgmaker-vx-online-game-parte-i/ https://www.makerando.com/gamerlog/rpgmaker-vx-online-game-parte-i/#comments Wed, 18 Jun 2014 16:12:55 +0000 http://www.makerando.com/gamerlog/?p=119 Con l’introduzione dello scripting in RGSS in RPGMaker XP, si sono aperte molte frontiere sulla personalizzazione dei nostri giochi. Col tempo sono apparsi molti script per rendere i propri giochi più interessanti e sempre più stupefacenti. La semplicità con la quale si può creare un gioco con RPGMaker ha fatto in modo di avvicinare sia principianti che utenti avanzati nella programmazione a creare nuove esperienze di gioco.

Gli MMORPG, ovvero Massive(ly) Multiplayer Online Role-Playing Game, sono l’esperienza di gioco più coinvolgente di questo secolo, giocare online ti permette di abbattere i limiti fisici, giocare con altre persone ed entrare e vivere nel mondo fantastico del titolo online a cui stiamo giocando.

Anche su RPGMaker molti hanno tentato di realizzare un’esperienza di gioco online, sono tanti gli scripts che sono stati realizzati. In principio per RPGMaker XP vi fu Netplay e Netplayplus, seguiti da tanti altri, compresi alcuni tentativi italiani.

Oggi vi propongo la traduzione di un articolo inglese, di sorlokreaves che utilizzando le sue conoscenze di JAVA e Ruby, ha creato un semplicissimo sistema client/server per RPGMaker VX utilizzando i socket del protocollo TCP.

L’articolo si rivolge a chi ha già alcuni rudimenti di programmazione e vuole realizzare un sistema online nel proprio gioco.

Step 1 : Casi d’uso

Cominciamo col creare un progetto nuovo su RPGMaker VX. Create una mappa iniziale, mettete qualche tile di “terra”. Dopo aggiungete un NPC (evento) con questi comandi:

• Messaggio: “Apertura Socket”
• Script

  s = TCPSocket.open('127.0.0.1', 7689)
  s.close()

• Messaggio: “Successo”

Adesso, provate il gioco e parlate con l’evento, dovreste vedere questo messaggio di errore e il gioco crasherà.

No “sockets” library significa che non esiste nessuna classe TCPSocket, il che farà crashare il nostro script da due linee

Cos’è appena successo? Bene, prima abbiamo provato a creare un socket. Questo socket assumeva che noi avessimo un server che stava girando su 127.0.0.1 (indirizzo di localhost, vuol dire che il server girava su questo computer) e che era collegato alla porta 7689. Siccome nessun server è stato lanciato, ci si aspetta un crash. -comunque abbiamo ottenuto un diverso messaggio di errore. Se guardate il messaggio d’errore, vedrete che RPGMaker VX non è riuscito a trovare l’oggetto “TCPSocket”. In altre parole RPGMaker VX non da supporto nativo alle librerie Ruby che gestiscono il networking (comunicazione online).-
Nemmeno RPGMaker XP offriva questo supporto nativamente, e l’autore si interroga come RMX-OS (script per RPGMaker XP, che permette di creare giochi online) lo abbia potuto ottenere.
Se avete già esperienza con i linguaggi di programmazione, sapete che di solito la parte di networking è collegata direttamente al sistema operativo. Se siete curiosi di vedere come Ruby si connetta attraverso i socket, potete scaricare il sorgente di Ruby 1.8 e analizzare il file thread.rb
Scarica Ruby qui: http://ftp.de.debian.org/debian/pool/main/r/ruby1.8/ruby1.8_1.8.7.249.orig.tar.gz

Step 2 : Prendendo in prestito la Libreria di Codice

Se avete familiarità con l’ambiente di scripting di RGSS, avrete notato che non supporta la primitiva “require”. Questo ha senso dal momento che “require” cerca il percorso alla libreria standard, potresti avviare delle librerie di Ruby che i videogiocatori non hanno. C’è da dire però che RPGMaker è in grado di eseguire codice nativo dalle DLLs. Per esempio questa funzionerà bene:

Win32API.new(DLL, 'connect', 'ppl', 'l').call(1, 2, 3)

Potremmo considerare di combinare insieme le DLL per creare insieme una “finta” libreria per il networking. Eventualmente potremmo migrare ad una cosiddetta libreria nativa, così potremmo guadagnare i benefici di primitive di basso livello. Un esempio è dato dalla libreria:
http://rubyforge.org/projects/win32utils/

Se la estraete e l’analizzate noterete che il codice sorgente ha molti require tag. Se volete utilizzarla dovrete essenzialmente sostituire queste con funzionalità compatibili.

Comunque per questo tutorial utilizzeremo la libreria Win32 API utilizzata da Blizzard in RMX-OS, che dice di aver preso da Ruby 1.8.1. Questo non creerà problemi di licenza, poichè Ruby permette l’utilizzo di copie di librerie modificate e ridistribuite.

Il codice di networking di RMX-OS è costruito con chiamate a DLL, questo è il codice da copiare:

#==============================================================================
# ** Module Win32 - Handles numerical based data.
#------------------------------------------------------------------------------
# Author    Ruby
# Version   1.8.1
#==============================================================================

module Win32

  #----------------------------------------------------------------------------
  # ● Retrieves data from a pointer.
  #----------------------------------------------------------------------------
  def copymem(len)
    buf = "\0" * len
    Win32API.new('kernel32', 'RtlMoveMemory', 'ppl', '').call(buf, self, len)
    buf
  end
  
end

# Extends the numeric class.
class Numeric
  include Win32
end

# Extends the string class.
class String
  include Win32
end

#==============================================================================
# ** Module Winsock - Maps out the functions held in the Winsock DLL.
#------------------------------------------------------------------------------
# Author    Ruby
# Version   1.8.1
#==============================================================================

module Winsock

  DLL = 'ws2_32'

  #----------------------------------------------------------------------------
  # * Accept Connection
  #----------------------------------------------------------------------------
  def self.accept(*args)
    Win32API.new(DLL, 'accept', 'ppl', 'l').call(*args)
  end
  #----------------------------------------------------------------------------
  # * Bind
  #----------------------------------------------------------------------------
  def self.bind(*args)
    Win32API.new(DLL, 'bind', 'ppl', 'l').call(*args)
  end
  #----------------------------------------------------------------------------
  # * Close Socket
  #----------------------------------------------------------------------------
  def self.closesocket(*args)
    Win32API.new(DLL, 'closesocket', 'p', 'l').call(*args)
  end  
  #----------------------------------------------------------------------------
  # * Connect
  #----------------------------------------------------------------------------
  def self.connect(*args)
    Win32API.new(DLL, 'connect', 'ppl', 'l').call(*args)
  end    
  #----------------------------------------------------------------------------
  # * Get host (Using Adress)
  #----------------------------------------------------------------------------
  def self.gethostbyaddr(*args)
    Win32API.new(DLL, 'gethostbyaddr', 'pll', 'l').call(*args)
  end
  #----------------------------------------------------------------------------
  # * Get host (Using Name)
  #---------------------------------------------------------------------------- 
  def self.gethostbyname(*args)
    Win32API.new(DLL, 'gethostbyname', 'p', 'l').call(*args)
  end
  #----------------------------------------------------------------------------
  # * Get host's Name
  #----------------------------------------------------------------------------
  def self.gethostname(*args)
    Win32API.new(DLL, 'gethostname', 'pl', '').call(*args)
  end
  #----------------------------------------------------------------------------
  # * Get Server (Using Name)
  #----------------------------------------------------------------------------
  def self.getservbyname(*args)
    Win32API.new(DLL, 'getservbyname', 'pp', 'p').call(*args)
  end
  #----------------------------------------------------------------------------
  # * HT OnL
  #----------------------------------------------------------------------------
  def self.htonl(*args)
    Win32API.new(DLL, 'htonl', 'l', 'l').call(*args)
  end
  #----------------------------------------------------------------------------
  # * HT OnS
  #----------------------------------------------------------------------------
  def self.htons(*args)
    Win32API.new(DLL, 'htons', 'l', 'l').call(*args)
  end
  #----------------------------------------------------------------------------
  # * Inet Adress
  #----------------------------------------------------------------------------
  def self.inet_addr(*args)
    Win32API.new(DLL, 'inet_addr', 'p', 'l').call(*args)
  end
  #----------------------------------------------------------------------------
  # * Inet NtOA
  #----------------------------------------------------------------------------
  def self.inet_ntoa(*args)
    Win32API.new(DLL, 'inet_ntoa', 'l', 'p').call(*args)
  end  
  #----------------------------------------------------------------------------
  # * Listen
  #----------------------------------------------------------------------------
  def self.listen(*args)
    Win32API.new(DLL, 'listen', 'pl', 'l').call(*args)
  end
  #----------------------------------------------------------------------------
  # * Recieve
  #----------------------------------------------------------------------------
  def self.recv(*args)
    Win32API.new(DLL, 'recv', 'ppll', 'l').call(*args)
  end
  #----------------------------------------------------------------------------
  # * Select
  #----------------------------------------------------------------------------
  def self.select(*args)
    Win32API.new(DLL, 'select', 'lpppp', 'l').call(*args)
  end
  #----------------------------------------------------------------------------
  # * Send
  #----------------------------------------------------------------------------
  def self.send(*args)
    Win32API.new(DLL, 'send', 'ppll', 'l').call(*args)
  end
  #----------------------------------------------------------------------------
  # * Set Socket Options
  #----------------------------------------------------------------------------
  def self.setsockopt(*args)
    Win32API.new(DLL, 'setsockopt', 'pllpl', 'l').call(*args)
  end  
  #----------------------------------------------------------------------------
  # * Shutdown
  #----------------------------------------------------------------------------
  def self.shutdown(*args)
    Win32API.new(DLL, 'shutdown', 'pl', 'l').call(*args)
  end
  #----------------------------------------------------------------------------
  # * Socket
  #----------------------------------------------------------------------------
  def self.socket(*args)
    Win32API.new(DLL, 'socket', 'lll', 'l').call(*args)  
  end
  #----------------------------------------------------------------------------
  # * Get Last Error
  #----------------------------------------------------------------------------
  def self.WSAGetLastError(*args)
    Win32API.new(DLL, 'WSAGetLastError', '', 'l').call(*args)
  end
 
end

#==============================================================================
# ** Socket - Creates and manages sockets.
#------------------------------------------------------------------------------
# Author    Ruby
# Version   1.8.1
#==============================================================================

class Socket

  #----------------------------------------------------------------------------
  # ● Constants
  #----------------------------------------------------------------------------
  AF_UNSPEC                 = 0  
  AF_UNIX                   = 1
  AF_INET                   = 2
  AF_IPX                    = 6
  AF_APPLETALK              = 16

  PF_UNSPEC                 = 0  
  PF_UNIX                   = 1
  PF_INET                   = 2
  PF_IPX                    = 6
  PF_APPLETALK              = 16

  SOCK_STREAM               = 1
  SOCK_DGRAM                = 2
  SOCK_RAW                  = 3
  SOCK_RDM                  = 4
  SOCK_SEQPACKET            = 5
  
  IPPROTO_IP                = 0
  IPPROTO_ICMP              = 1
  IPPROTO_IGMP              = 2
  IPPROTO_GGP               = 3
  IPPROTO_TCP               = 6
  IPPROTO_PUP               = 12
  IPPROTO_UDP               = 17
  IPPROTO_IDP               = 22
  IPPROTO_ND                = 77
  IPPROTO_RAW               = 255
  IPPROTO_MAX               = 256

  SOL_SOCKET                = 65535
  
  SO_DEBUG                  = 1
  SO_REUSEADDR              = 4
  SO_KEEPALIVE              = 8
  SO_DONTROUTE              = 16
  SO_BROADCAST              = 32
  SO_LINGER                 = 128
  SO_OOBINLINE              = 256
  SO_RCVLOWAT               = 4100
  SO_SNDTIMEO               = 4101
  SO_RCVTIMEO               = 4102
  SO_ERROR                  = 4103
  SO_TYPE                   = 4104
  SO_SNDBUF                 = 4097
  SO_RCVBUF                 = 4098
  SO_SNDLOWAT               = 4099
  
  TCP_NODELAY               = 1
  
  MSG_OOB                   = 1
  MSG_PEEK                  = 2
  MSG_DONTROUTE             = 4
  
  IP_OPTIONS                = 1
  IP_DEFAULT_MULTICAST_LOOP = 1
  IP_DEFAULT_MULTICAST_TTL  = 1
  IP_MULTICAST_IF           = 2
  IP_MULTICAST_TTL          = 3
  IP_MULTICAST_LOOP         = 4
  IP_ADD_MEMBERSHIP         = 5
  IP_DROP_MEMBERSHIP        = 6
  IP_TTL                    = 7
  IP_TOS                    = 8
  IP_MAX_MEMBERSHIPS        = 20

  EAI_ADDRFAMILY            = 1
  EAI_AGAIN                 = 2
  EAI_BADFLAGS              = 3
  EAI_FAIL                  = 4
  EAI_FAMILY                = 5
  EAI_MEMORY                = 6
  EAI_NODATA                = 7
  EAI_NONAME                = 8
  EAI_SERVICE               = 9
  EAI_SOCKTYPE              = 10
  EAI_SYSTEM                = 11
  EAI_BADHINTS              = 12
  EAI_PROTOCOL              = 13
  EAI_MAX                   = 14

  AI_PASSIVE                = 1
  AI_CANONNAME              = 2
  AI_NUMERICHOST            = 4
  AI_MASK                   = 7
  AI_ALL                    = 256
  AI_V4MAPPED_CFG           = 512
  AI_ADDRCONFIG             = 1024
  AI_DEFAULT                = 1536
  AI_V4MAPPED               = 2048
  
  #----------------------------------------------------------------------------
  # ● Returns the associated IP address for the given hostname.
  #----------------------------------------------------------------------------  
  def self.getaddress(host)
    gethostbyname(host)[3].unpack('C4').join('.')
  end
  #----------------------------------------------------------------------------
  # ● Returns the associated IP address for the given hostname.
  #----------------------------------------------------------------------------  
  def self.getservice(serv)
    case serv
    when Numeric
      return serv
    when String
      return getservbyname(serv)
    else
      raise 'Please us an interger or string for services.'
    end
  end
  #----------------------------------------------------------------------------
  # ● Returns information about the given hostname.
  #----------------------------------------------------------------------------
  def self.gethostbyname(name)
    raise SocketError::ENOASSOCHOST if (ptr = Winsock.gethostbyname(name)) == 0
    host = ptr.copymem(16).unpack('iissi')
    [host[0].copymem(64).split("\0")[0], [], host[2], host[4].copymem(4).unpack('l')[0].copymem(4)]
  end
  #----------------------------------------------------------------------------
  # ● Returns the user's hostname.
  #----------------------------------------------------------------------------  
  def self.gethostname
    buf = "\0" * 256
    Winsock.gethostname(buf, 256)
    buf.strip
  end
  #----------------------------------------------------------------------------
  # ● Returns information about the given service.
  #----------------------------------------------------------------------------
  def self.getservbyname(name)
    case name
    when /echo/i
      return 7
    when /daytime/i
      return 13
    when /ftp/i
      return 21
    when /telnet/i
      return 23
    when /smtp/i
      return 25
    when /time/i
      return 37
    when /http/i
      return 80
    when /pop/i
      return 110
    else
      raise 'Service not recognized.'
    end
  end
  #----------------------------------------------------------------------------
  # ● Creates an INET-sockaddr struct.
  #----------------------------------------------------------------------------  
  def self.sockaddr_in(port, host)
    begin
      [AF_INET, getservice(port)].pack('sn') + gethostbyname(host)[3] + [].pack('x8')
    rescue
    end
  end
  #----------------------------------------------------------------------------
  # ● Creates a new socket and connects it to the given host and port.
  #----------------------------------------------------------------------------  
  def self.open(*args)
    socket = new(*args)
    if block_given?
      begin
        yield socket
      ensure
        socket.close
      end
    end
    nil
  end
  #----------------------------------------------------------------------------
  # ● Creates a new socket.
  #----------------------------------------------------------------------------  
  def initialize(domain, type, protocol)
    SocketError.check if (@fd = Winsock.socket(domain, type, protocol)) == -1
    @fd
  end
  #----------------------------------------------------------------------------
  # ● Accepts incoming connections.
  #----------------------------------------------------------------------------  
  def accept(flags = 0)
    buf = "\0" * 16
    SocketError.check if Winsock.accept(@fd, buf, flags) == -1
    buf
  end
  #----------------------------------------------------------------------------
  # ● Binds a socket to the given sockaddr.
  #----------------------------------------------------------------------------  
  def bind(sockaddr)
    SocketError.check if (ret = Winsock.bind(@fd, sockaddr, sockaddr.size)) == -1
    ret
  end
  #----------------------------------------------------------------------------
  # ● Closes a socket.
  #----------------------------------------------------------------------------  
  def close
    SocketError.check if (ret = Winsock.closesocket(@fd)) == -1
    ret
  end
  #----------------------------------------------------------------------------
  # ● Connects a socket to the given sockaddr.
  #----------------------------------------------------------------------------  
  def connect(sockaddr)
    SocketError.check if (ret = Winsock.connect(@fd, sockaddr, sockaddr.size)) == -1
    ret
  end
  #----------------------------------------------------------------------------
  # ● Listens for incoming connections.
  #----------------------------------------------------------------------------  
  def listen(backlog)
    SocketError.check if (ret = Winsock.listen(@fd, backlog)) == -1
    ret
  end
  #----------------------------------------------------------------------------
  # ● Checks waiting data's status.
  #----------------------------------------------------------------------------  
  def select(timeout)
    SocketError.check if (ret = Winsock.select(1, [1, @fd].pack('ll'), 0, 0, [timeout, timeout * 1000000].pack('ll'))) == -1
    ret
  end
  #----------------------------------------------------------------------------
  # ● Checks if data is waiting.
  #----------------------------------------------------------------------------  
  def ready?
    not select(0) == 0
  end  
  #----------------------------------------------------------------------------
  # ● Reads data from socket.
  #----------------------------------------------------------------------------  
  def read(len)
    buf = "\0" * len
    Win32API.new('msvcrt', '_read', 'lpl', 'l').call(@fd, buf, len)
    buf
  end
  #----------------------------------------------------------------------------
  # ● Returns recieved data.
  #----------------------------------------------------------------------------  
  def recv(len, flags = 0)
    buf = "\0" * len
    SocketError.check if Winsock.recv(@fd, buf, buf.size, flags) == -1
    buf
  end
  #----------------------------------------------------------------------------
  # ● Sends data to a host.
  #----------------------------------------------------------------------------  
  def send(data, flags = 0)
    SocketError.check if (ret = Winsock.send(@fd, data, data.size, flags)) == -1
    ret
  end
  #----------------------------------------------------------------------------
  # ● Writes data to socket.
  #----------------------------------------------------------------------------  
  def write(data)
    Win32API.new('msvcrt', '_write', 'lpl', 'l').call(@fd, data, 1)
  end

end

#==============================================================================
# ** TCPSocket - Creates and manages TCP sockets.
#------------------------------------------------------------------------------
# Author    Ruby
# Version   1.8.1
#==============================================================================

class TCPSocket < Socket

  #----------------------------------------------------------------------------
  # ● Creates a new socket and connects it to the given host and port.
  #----------------------------------------------------------------------------  
  def self.open(*args)
    socket = new(*args)
    if block_given?
      begin
        yield socket
      ensure
        socket.close
      end
    end
    nil
  end
  #----------------------------------------------------------------------------
  # ● Creates a new socket and connects it to the given host and port.
  #----------------------------------------------------------------------------  
  def initialize(host, port)
    super(AF_INET, SOCK_STREAM, IPPROTO_TCP)
    connect(Socket.sockaddr_in(port, host))
  end
  
end

#==============================================================================
# ** SocketError
#------------------------------------------------------------------------------
# Default exception class for sockets.
#==============================================================================

class SocketError < StandardError
  
  ENOASSOCHOST = 'getaddrinfo: no address associated with hostname.'
  
  def self.check
    errno = Winsock.WSAGetLastError
    raise Errno.const_get(Errno.constants.detect { |c| Errno.const_get(c).new.errno == errno })
  end
  
end

Nell’editor degli scripts (F11), fate tasto destro su “Main”, e scegliete “Inserisci”, scrivete “Ruby Library Code” nel nome e incollate il codice precedente. Scegliete OK e salvate il gioco.

Se provate il gioco adesso, finirete con l’avere un errore. Quindi cancellate l’evento che abbiamo creato in precedenza, e aggiungete il codice che segue direttamente nello script Main, esattamente dopo Graphics.freeze

s = TCPSocket.open('127.0.0.1', 7689)
s.close()

Adesso salva il gioco, e avvia il game testing. Otterrai il seguente messaggio d’errore:

Questo errore significa che la libreria di codice è stata caricata, ma non ha trovato il server. Stiamo facendo progressi!

Questo è il tipo d’errore che stavamo cercando! Congratulazioni, la struttura base del codice TCP che hai aggiunto era corretta.

 Step 3 : Inizializzare e Testare la Connessione con gli NPCs

Abbiamo bisogno di testare una connessione TCP -inoltre dovremmo sistemare il bug che non permette agli NPC di attivare il nostro codice. Questi sono i nostri prossimi compiti.

Se hai trovato nel codice l’origine dell’errore, sei arrivato a queste linee di codice:

  def self.check
    errno = Winsock.WSAGetLastError
    raise Errno.const_get(Errno.constants.detect { |c| Errno.const_get(c).new.errno== errno })
  end

L’errore è da riteneresi nello statement “raise”. Se non capisci la logica a blocchi di Ruby, questo ti sconforterà e non vorrai proseguire. Ma prova questa piccola astrazione :

 def self.check
    errno = Winsock.WSAGetLastError
    constName = Errno.constants.detect { |c| Errno.const_get(c).new.errno== errno }
    raise Errno.const_get(constName)
  end

Prova questo codice ancora e noterai che l’errore sta nuovamente sulla linea di “raise”. Il programmatore originale voleva trovare gli errori di Win32 attraverso il loro ID, ma non ha messo in conto che un socket inizializzato a null avrebbe potuto generare un errore senza codice ID. Per risolvere basta questo:

def self.check
      errno = Winsock.WSAGetLastError
      constName = Errno.constants.detect {|c| Errno.const_get(c).new.errno == errno }
      if constName
        raise Errno.const_get(constName)
      else
        raise "Unknown network error code: #{errno}"
      end
  end

Adesso se proverai ad avviare il codice dell’evento, vedrai l’errore “Unknown network error code”.
A questo punto dovremmo dire che TCPSocket.open() non è tecnicamente corretto, poichè si aspetta che noi passiamo alla funzione un blocco di codice da eseguire. Questo potrebbe andare bene per una procedura socket immediata come ricevere l’ora attuale, o le condizioni meteo da un server centrale, ma noi abbiamo bisogno di una connessione persistente con il server per il nostro engine. Come ti aspetterai il nostro codice supererà il limite del comando Script dell’Evento. Quindi, cambia il codice script dell’evento con:

tcptest()

…e aggiungi il codice seguente al modulo “Main”, direttamente prima dello statement “begin”

  def tcptest
    #Createa a socket
    s = TCPSocket.new('127.0.0.1', 7689)

    #Send a test message
    s.send("Testing...\n")
    #Receive a result from the server
    msg = ''
    while
      buffer = s.recv(1024)    #Read UP TO 1024 bytes
      buffer.gsub!(0.chr, '') #Remove null bytes
      msg += buffer            #Append received data
      break if buffer.count("\n")>0   #Stop if we've reached the newline
    end
    #Done; close the socket, print our message
    s.close()
    print "Received: #{msg}"
  end

Il nostro codice è molto semplice, abbiamo usato “new” invece di “open”, e abbiamo usato “send” e “recv” per mandare e ricevere i dati. Un problema di recv, è che non aspetterà che il server abbia finito di comunicare la risposta per intero, così abbiamo bisogno di memorizzare l’intero messaggio di bit non appena vengono ricevuti. D’altronde una delle garanzie di TCP è che non riceveremo messaggi disordinati, questo è un punto che ci risparmierà molti mal di testa.

Adesso quello che abbiamo bisogno è il server. Credo che Ruby non sia molto indicato come codice client\server, proveremo così a scriverne uno in Java. Un problema con Java è che compilare il codice ed eseguirlo potrebbe essere difficoltoso. Piuttosto che fornirvi un tutorial completo su Eclipse o javac, ti chiederò di scaricare e installare Textpad.

NB: Alcuni utenti hanno segnalato che è necessario anche scaricare JDK. Apri una finestra di comando, e scrivi javac -version. Se ottieni un messaggio d’errore, allora devi scaricare JDK.

Adesso crea un nuovo file, chiamalo esattamente “SimpleServer.java“, e dentro scrivi questo codice:

import java.io.*;
import java.net.*;

class SimpleServer {
  public static void main(String argv[]) throws Exception {
    String clientSentence;
    String capitalizedSentence;
    ServerSocket welcomeSocket = new ServerSocket(7689);

    for ( ; ; ) {
      System.out.println("Waiting for connection...");
      Socket connectionSocket = welcomeSocket.accept();
      System.out.println("  >Socket connected");

      BufferedReader inFromClient = new BufferedReader(new InputStreamReader(connectionSocket.getInputStream()));
      DataOutputStream outToClient = new DataOutputStream(connectionSocket.getOutputStream());
      clientSentence = inFromClient.readLine();

      System.out.println("  >Received: " + clientSentence);
      capitalizedSentence = clientSentence.toUpperCase() + '\n';
      outToClient.writeBytes(capitalizedSentence);
      System.out.println("  >Replied: " + capitalizedSentence);
    }
  }
}

Abbastanza semplice? Abbiamo ignorato la parte di controllo degli errori, sarà relativamente semplice far crashare il server. Ma per una demo veloce, ce la farà. Il server legge le frasi mandate dal client, e le riporta in maiuscolo. Poichè abbiamo mandato la stringa “Testing…” attraverso il client, il server restituirà “TESTING…”.

Per compilare il codice del server, in TextPad, clicca su “Tools-> External Tools-> Compile Java”.
Se il codice non contiene errori, vedrai il messaggio di avvenuta compilazione. Adesso per avviare il server, clicca su “Tools->External Tools->Run Java Application”, a questo punto apparirà una finestra di comando con su scritto “Waiting for connection…”.Questo significa che il server è pronto per accettare una connessione alla porta 7689. Adesso avvia il gioco, parla con l’evento NPC, e vedrai un messaggio con la risposta del server:

Il messaggio del server è arrivato al client

La finestra del server avrà ulteriori messaggi:

Log del Server

Dal momento che abbiamo chiuso la connessione, il server sta aspettando un’altra connessione in ingresso. Potremmo ri-parlare con l’evento, oppure chiudere e aprire il gioco di nuovo e parlare con l’evento. Avremo bisogno che il client tenga la connessione per altri messaggi, ma per adesso abbiamo provato che il networking di RPGMaker VX funziona. Premi CTRL+C per chiudere la finestra, premi Y se necessario per confermare la chiusura del server.

Step 4 : Un passo indietro

A questo punto è opportuno fermarsi un attimo e capire cosa abbiamo realizzato. C’è stato molto “codice incollato”, ma ecco cosa abbiamo fatto:

• Abbiamo creato un server che può “ricevere” connessioni sulla porta 7689, e un client che può richiedere una connessione a questa porta.
• Una volta connessi, client e server possono mandare e ricevere una sequenza di caratteri.

E questo è quanto. Aggiungendo altri clients, qualche tipo di sincronizzazione e partizionando i nostri dati in “messaggi” o “eventi di gioco”, sono solo dettagli di quello che il server TCP in realtà può fare. Per esempio possiamo mandare le coordinate di un evento, di un giocatore. In questo modo possiamo trattare i giocatori come eventi NPC in altri giochi del RPG che volete realizzare. Possiamo mandare tiles, per permettere ai giocatori di costruire le loro case, o personalizzare gli avatar di ogni giocatore, oppure coordinare un battle system. Tutte queste cose possono essere realizzate mandando stringhe al server TCP.

Step 5 : Una Prova leggermente più impressionante

Continua nella seconda parte…