Denzel: Come ti sei avvicinata al mondo del making?

MihaChan:
Per puro caso, un giorno insieme ad una conoscenza decidemmo di fare un gioco, e da allora (ormai penso 2 anni fa? non ne sono sicura) ho iniziato a muovermi in questo mondo.

Shiki:
Per puro caso…
Frequento da anni un forum di scrittura, in quanto mi piace molto leggere e scrivere, e in una discussione, nella sezione Off Topic, si parlava di creare un videogioco. Lì ho sentito parlare per la prima volta di RPG Maker. C’era anche linkato il primo video tutorial di Ghost Rider!
Questo è successo circa un anno fa.
Anche se mi ero interessata, ho incominciato a informarmi davvero molto più in là. Quell’estate pensavo ad altre cose, tra cui ad aprire il mio blog.
Presi a dedicarmi davvero al making quando mi sono iscritta a Makerando, quindi nel novembre del 2013.

Denzel: Quali sono state le prime difficoltà?

MihaChan:
Ah praticamente tutto è stato una difficoltà! Non sapevo assolutamente niente, e tanto meno capivo qualcosa!

Shiki:
Un po’ tutto, non conoscendo assolutamente nulla, ma soprattutto non capivo come funzionavano i chipset e il mapping; tutt’ora mi danno qualche problema, ma non so esattamente perché xD

Denzel: Come le hai superate?

MihaChan:
Ho avuto la fortuna di incontrare persone competenti che con molta pazienza, mi hanno aiutato a capire, rendendomi il lavoro più semplice e divertente.

Shiki:
Chiedendo e seguendo i tutorial trovati in giro, sia qui che in altri forum. Al momento ne frequento due attivamente, tra cui Makerando.

Denzel: Hai un ruolo definito? Come hai sviluppato la passione per il game making?

MihaChan:
Il mio ruolo definito è Grafica. La passione è venuta pian piano, con la voglia di realizzare qualcosa di completamente mio.

Shiki:
I ruoli in cui mi ritrovo di più sono Eventer e Storyboarder.
Ho sempre amato inventare storie, basta pensare a un’altra mia passione, cioè scrivere. Poi riesco a capire abbastanza bene la logica degli eventi, non so spiegare perché, ma mi diverto molto quando mi dedico a questa parte del making.
La passione per il game making l’ho sempre avuta, sepolta dentro di me xD.
Ho sempre desiderato creare qualcosa di mio, tra cui anche un videogioco, ma partendo dal presupposto che poteva essere troppo difficile, non mi sono mai informata, fino a ora.

Denzel: Hai trovato facilmente il tuo spazio in un ambiente in cui la maggiorparte dei makers sono
uomini?

MihaChan:
Sì. Non sono una che si fa mettere sotto da queste bazzecole!

Shiki:
Certo, per me non è assolutamente un problema!
Anzi, da piccola amavo di più giocare fuori o alla PlayStation con i maschi, piuttosto che con le femmine e le loro bambole.

Denzel: Che tipo di progetto stai sviluppando?

MihaChan:
Ne sto sviluppando tre, a dire il vero, uno in solitaria e due in collab. Il mio personale, è un Fantasy. I due in personale sono un Action/Survivor e un Fantasy.

Shiki:
Ho iniziato il mio primo progetto da pochissimo, circa un mese.
Questo è di genere sovrannaturale, forse un po’ horror. E’ più che altro un piccolo gioco, che non sarà molto lungo (forse 4 ore di gioco circa), che voglio completare prima d’imbarcarmi in un progetto vero e proprio.
Il progetto serio a cui vorrò dedicarmi più avanti sarà probabilmente un distopico-cyberpunk. Alcune cose della trama le ho già in mente.
Quando avrò finito di scrivere la storia del sovrannaturale, imposterò la storia del distopico.

Denzel: Che consigli vuoi dare a chi si affaccia in questo mondo per la prima volta?

MihaChan:
Che deve impegnarsi e fare molte, molte prove, pure senza un risultato completo finale! Perché l’unico modo per renderlo semplice e riuscire nel proprio progetto, è facendo mille tentativi finché non si capisce e si impara. Quindi sì, IMPEGNATEVI!

Shiki:
Non saprei, essendo comunque ancora alle prime armi…
I consigli che posso dare è di seguire i tutorial e i consigli di chi è più esperto. Non dovete subito mettervi a creare progetti difficili ed elaborati; iniziate dalle basi, pian piano prendeteci mano. Partite dalle cose semplici, imbarcarsi in un progetto difficile fin dall’inizio per me è controproducente.
Poi come tool consiglio il 2000 o il 2003, reperibili gratis in italiano per chi, come me, non è molto bravo con la grafica ma se la cava con gli eventi. Se invece accade il contrario (siete bravi con la grafica e gli eventi vi stanno un po’ più ostici) allora usate XP o l’ACE, però in questo caso è buona cosa impararsi un po’ di Ruby e RGSS, a modo di capire come funzionano gli Scripts, per evitare il copia e incolla passivo.
Ma soprattutto non arrendetevi alle prime difficoltà, in questo genere di cose ci vuole molta pazienza.

Denzel: Che sensazioni provi durante lo sviluppo del tuo progetto? Senti di essere supportata in modo adeguato?

MihaChan:
Beh, come posso dire… Mi sento bene, mi sento “importante”, come credo ci si senta chiunque si impegni s qualcosa seriamente, e molto spesso mi sento spossata e incavolata perché alcune cose non m riescono, ma di solito sono molto contenta! E sì, assolutamente sì!

Shiki:
Le stesse sensazioni che provo quando scrivo, sinceramente non come spiegarle a parole…
Però quando un lavoro poi viene come voglio mi sento realizzata, in caso contrario mi arrabbio o/e m’intristisco ma poi continuo a provare fino a quando risolvo il problema e dopo mi sento ancora più felice.

Denzel: Come sono i tuoi rapporti con gli altri membri delle community in cui partecipi in modo attivo?

MihaChan:
Ottimi! Sono tutti bravissimi, simpatici e disponibili! 

Shiki:
Buoni, ancora non ho avuto modo di approfondire le conoscenze con nessuno, quindi le miei discussioni con loro non vanno al di fuori dell’argomento principale. Ma io sono anche una persona che ama stare sulle sue e mi ci vuole tempo per fare amicizia. Comunque mi trovo sicuramente molto bene.

Denzel: Ti sei mai sentita svantaggiata?

MihaChan:
Nah.

Shiki:
Mai, solo mi rimprovero di non essermi avvicinata prima al making.

Denzel: Che tipo di studi hai fatto?

MihaChan:
Ho sempre avuto una passione per l’arte, quindi ho frequentato una scuola d’arte, che però mi ha molto delusa. Poi sono passata all’informatico, che è molto gradevole. Quindi direi entrambi!

Shiki:
Mi sono diplomata in un istituto tecnico biologico e adesso frequento la triennale d’ingegneria biomedica.

Denzel: Ti hanno aiutata nella tua passione?

MihaChan:
Beh, nella passione del disegno NO, in quella del making sì, e molto!

Shiki:
Se per passione ci riferiamo solo al making, forse solo un po’ l’università.

Denzel: Hai altri interessi?

MihaChan:
Sì, l’arte, il disegno.

Shiki:
Troppi, a dire il vero.
I principali sono leggere e scrivere, l’informatica in generale, Anime e Manga, arti marziali, robe come fisica, astronomia, ecc. Generalmente sono molto curiosa.

Denzel: Ti ispiri a qualche figura o a qualcosa per creare il tuo progetto?

MihaChan:
Beh mi ispiro a giochi Fantasy famosi; Final Fantasy, Kingdom Hearts, Chrono Trigger et simili… Quindi sì!

Shiki:
Generalmente ora prendo spunto da altri giochi fatti con RPG Maker e poi m’ispiro a videogiochi classici come Final Fantasy, Kingdom Hearts e Silent Hill.

Denzel: Hai parlato di questa tua passione con altre persone? Se si, cosa pensano del making?

MihaChan:
Nah, a parte le persone conosciute qui, non ne ho parlato con nessuno, anche perché sembra che il resto del mondo sia schifato da tali cose ò_ò

Shiki:
Sì, con il mio ragazzo e le poche persone fidate che posso considerare amici, che si contano sulle dita di una mano. Ho accennato qualcosa anche a mia madre, che però non ci capisce molto xD
Sono incuriositi e interessati e dicono che vogliono provare i giochi che farò, specialmente mia cugina e il mio ragazzo hanno detto che mi faranno da betatester; ma il realtà solo il mio ragazzo sembra davvero interessato a questo mondo.

Denzel: Hai degli obiettivi?

MihaChan:
Certo. Chi non ne ha? Ma se parliamo di making nello specifico, l’unico obiettivo e divertirmi e far divertire.

Shiki:
Per quanto riguarda il making il mio unico obbiettivo è creare qualcosa di mio, divertirmi e far divertire.
In generale di obbiettivi ne ho parecchi, come migliorare in alcune cose; ad esempio la conoscenza della lingua inglese, imparare davvero il giapponese, imparare seriamente a programmare e altre cose.

Denzel: Il making ha cambiato la tua vita? Se si, come?

MihaChan:
Oddio sì. Mi ha permesso di conoscere persone straordinarie, di affezionarmi specialmente ad una di queste, che mi sta regalando bellissimi momenti. Quindi sì, mi ha cambiato la vita.

Shiki:
Più o meno sì, perché mi ha permesso di dedicarmi a una passione che seppellisco fin da piccola.

Denzel: Quale è stato il primo videogame a cui hai giocato? E il primo sviluppato con RPG Maker?

MihaChan:
Il primo videogame della mia vita è stato Ninja Boy. Era stupendo! Invece di realizzati con RPG Maker… hmm… Non ricordo, mi spiace :/

Shiki:
Purtroppo ho iniziato a giocare ai videogame un po’ tardi. All’inizio mia madre non voleva comprarmi un gameboy perché pensava non fosse adatto a una bambina e io in quel periodo non insistetti più di tanto, quindi mi limitavo a giocare ogni tanto con quelli dei miei compagni, oppure andavo a casa di uno di loro che aveva la playstation, però aveva solo giochi di macchine.
Alla fine, quando avevo 10-11 anni i miei comprarono un pc e lì giocai davvero per la prima volta a un videogioco, cioè Harry Potter e la pietra Filosofale. Lo so, non è il nome di chissà quale gioco famoso e storico, ma è stato il primo videogioco a cui ho giocato davvero.
Mentre il primo gioco sviluppato con RPG Maker che ho giocato è stato Ib.

Denzel: Hai delle proposte per Makerando?

MihaChan:
Beh, forse di organizzare più contest? Sinceramente non so, per me personalmente va benissimo così com’è.

Shiki:
Sinceramente non saprei, da quando mi sono iscritta il forum si è evoluto velocemente. Spero vivamente che continui così e con questo ritmo.

Denzel: Vuoi dire qualcosa alla community?

MihaChan:
Ragazzuoli vi voglio bene! Siete tutti fantastici, continuate così mi raccomando! *-*

Shiki:
Di continuare così, che qui è stato il mio vero punto di partenza per il mondo del making, quindi ringrazio davvero chi mi ha aiutato ad iniziare questa esperienza.

Denzel: Vuoi dire qualcosa alle altre ragazze che vogliono sviluppare questa passione?

MihaChan:
Di impegnarsi, di chiedere aiuto, di non lasciarsi demoralizzare da questo mondo “maschilista”. Ah, sì, e di non fare le gatte morte per farsi realizzare il progetto da altri, perché non c’è alcuna soddisfazione alla fine! (lo dico perché ho conosciuto gente così, mio malgrado xD)

Shiki:
Prima di tutto di non arrendersi solo perché questo sembra un mondo solo per maschi; io questi problemi non me ne faccio, ma ci sono altre che potrebbero esserne intimorite. Di non avere paura a chiedere e d’impegnarsi. Come in qualunque altra passione, ciò che serve è sempre una buona dose di forza di volontà e umiltà.

Grazie a questa famosa piattaforma per il gaming, potrete comprare RPGMaker VX Ace ad un prezzo scontato del 50% fino al 30 Giugno.

Inoltre, sempre in offerta, troviamo un bundle che comprende RPGMaker VX Ace e 3 pack di risorse aggiuntive:

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…

Una importante rivoluzione nel videogaming è avvenuta nel mondo degli smartphone. Tutti noi ormai possediamo uno smartphone con un market da cui è possibile scaricare le applicazioni più disparate, giochi inclusi.

Oggi GamerLog porta alla vostra attenzione, un’applicazione per Android, davvero interessante. Sto parlando di Choco R2k Player creata da SweetChocolate e pubblicata sullo store a Gennaio 2014

Autore: SweetChocolate –  Data pubblicazione: 12 gennaio 2014

Questa app permette di emulare piuttosto bene i giochi realizzati con RPGMaker 2000 o 2003, e giocarli direttamente sul vostro smartphone.

L’applicazione è completamente gratuita e in caso di bug o nella eventualità che il vostro gioco possa riscontrare problemi, l’autore si è reso disponibile ad estendere il supporto del vostro gioco. Per fare ciò basta contattarlo all’indirizzo email: chocolatlsweet@gmail.com.

Per poter giocare i vostri giochi dovete semplicemente scaricarli sul vostro smartphone e posizionarli nella cartella: SdCard/RPGL/

E’ disponibile sul sito ufficiale dello sviluppatore, una lista di giochi supportati che potete controllare qui.
Se volete installare l’applicazione, dovete avere minimo la versione 2.3.3 di Android.
L’applicazione è disponibile sul Google Play Store

https://play.google.com/store/apps/details?id=com.sweetier.mrpg2kplayer

Vogliamo ispirarvi mentre create, vi forniremo nuovi spunti, analizzeremo insieme nuove prospettive, giocheremo e ci divertiremo come solo con Makerando potrete fare.

Se siete interessati a scrivere con noi, o volete pubblicità su GamerLog, potete contattarmi attraverso il forum oppure attraverso gamerlog.

Che dire Stay Tuned

Continuate a seguirci!