[RGSS] Tutorial Scene base

[Sleeping Leonhart]

Creazione di una Scena

1.0

 

1. Introduzione

Per

: RPG Maker XP/VX.

Autore

: The Sleeping Leonhart;

Descrizione

: Questo tutorial descrive come creare una semplice scena in RGSS e fargli fare qualche azione.

Ultima modifica

: 8/6/2010;).

Download:

_RGSS__Tutorial_Scene.doc

 

2. Tutorial

Creazione di una scena base

Per prima cosa dobbiamo definire il nome della classe della scena che sarà poi il nome con la quale essa verrà richiamata

class NOMESCENA end

Generalmente le scene vengono chiamate con un nome del tipo

Scene_NOMESCENA

In Rpg Maker VX esiste la classe Scene_Base, che è un po’ come la classe Window_Base per le finestre, essa contiene infatti dei metodi comuni usati in quasi tutte le scene, per far ereditare questa classe basta anteporre < Scene_Base davanti al nome della scena, così:

Scene_NOMESCENA < Scene_Base

Nel tutorial non userò la classe Scene_Base, ometterla mi permette di spiegarvi la creazione delle scene sia per VX che per XP.

 

Ora che abbiamo definito la classe dobbiamo iniziare a definire il punto di ingresso di una scena.

Il primo metodo richiamato da una classe è il metodo initialize, noi però non utilizzeremo questo metodo ma bensì il metodo main. Perché ciò?

Andiamo un attimo a dare un sguardo allo script del main, l'ultimo dello script editor, troveremo il seguente codice

  while $scene != nil	$scene.main  end

in pratica Rpg Maker, parte ed inizia un ciclo infinito che termina solo se variabile globale $scene è vuota (e all'inizio non lo è in quanto sopra gli è assegnato il titolo)

all'interno del ciclo viene chiamato il metodo main della scena, ecco perché noi useremo questo metodo per iniziare a costruire la nostra scena.

In realtà non è obbligatorio usare il main per inizializzare le variabili della nostra scena, ma gli script standard e la maggior parte degli script sono strutturati cosi quindi noi li seguiamo a ruota.

Capisco che mi spiego da cani ma se avete domande o dubbi chiedete.

Quindi:

class NOMESCENA  def main 	CREAZIONEFINESTRE 	Graphics.transition	loop do	  Graphics.update	  Input.update	  update	  if $scene != self		break	  end	end	Graphics.freeze 	DISPOSEFINESTRE   endend

Si inizia per prima cosa ad inizializzare le finestre, ma questo ve lo spiego dopo.

Come potete vedere nel main ce un altro ciclo infinito, in questo ciclo vengono aggiornate Grafica (Graphics.update), Input dei tasti (Input.update) e viene chiamato il metodo update

il ciclo termina quando la scena è diversa da se stessa e il main prosegue generalmente effettuando la cancellazione delle finestre.

 

Piccola parentesi:

Nel VX una volta che si è ereditato da Scene_Base si può omettere il main in quanto è già definito, per inizializzare le finestre viene usato il metodo start mentre per effettuarne il dispose il metodo terminate

 

Ora per continuare nella spiegazione ho bisogno di almeno una finestra, nel nostro caso ne useremo 2 una selezionabile per le opzioni e una semplice per mostrare lo stato delle nostre azioni.

La finestra selezionabile sarà del tipo Window_Command

Cosa è una Window_Command, è una semplice finestra selezionabile con una lista di voci, un esempio è la finestra de selezione delle voci del titolo o del menu.

La nostra finestra che mostra lo stato delle azioni invece sarà questa:

class Window_Valori < Window_Base  def initialize	super(160, 0, 320, 192)	self.contents = Bitmap.new(width - 32, height - 32)	refresh  end   def refresh	self.contents.clear	self.contents.draw_text(0, 0, 256, 32, "Lo stato della Switch 1 è: #{$game_switches[1]}")	self.contents.draw_text(0, 48, 256, 32, "Lo variabile 1 ha valore: #{$game_variables[1]}")	self.contents.draw_text(0, 96, 256, 32, "Il party possiede #{$game_party.gold} oro")	draw_actor_graphic($game_party.actors[0], 256, 150)	self.contents.draw_text(0, 128, 256, 32, "#{$game_party.actors[0].name} è al livello #{$game_party.actors[0].level}")  endend

In Rpg Maker VX sostituite $game_party.actors con $game_party.members

 

La nostra scena si chiamerà Scene_Opzioni, ora inizializziamo le finestre nel main

class Scene_Opzioni  def main	#Nomi dei comandi	comandi = ["Switch 1", "Variabile 1 + 5", "Variabile 1 - 3", "Oro + 100", "#{$game_party.actors[0].name} + 1"]	#Inizializzo le finestre	@finestra_opzioni = Window_Command.new(160, comandi)	@finestra_valori = Window_Valori.new	#Ciclo Principale	Graphics.transition	loop do	  Graphics.update	  Input.update	  update	  if $scene != self		break	  end	end	Graphics.freeze	#Effettuo il dispose di tutte le finestre che ho inizializzato	@finestra_opzioni.dispose	@finestra_valori.dispose  end   def update   endend

Osservando lo script si nota la variabile comandi alla quale è assegnato una array di stringhe, questo array di stringhe non è altro che la lista dei comandi che la Window_Command mostrerà per noi

sotto assegniamo a delle variabili d'istanza le nostre 2 finestre, Window_Command richiede il passaggio di 2 argomenti, il primo è la larghezza della finestra, il secondo è la lista dei comandi (che noi abbiamo definito sopra)

Dopo il ciclo principale effettuiamo il dispose delle finestre chiamando il relativo metodo, ma che cos'è questo dispose?

Il dispose non è altro che la cancellazione della nostra finestra dallo schermo, se non lo effettuiamo le nostre finestre rimangono visibili anche dopo la chiusura della scena.

 

Ora andiamo a riempire il metodo update, questo metodo viene chiamato una volta per frame, dentro inseriremo l'update di @finestra_opzioni, necessario per il controllo attraverso i tasti (dell'altra non è necessario), e un controllo tasti:

  def update	#aggiornamento finestra di selezione	@finestra_opzioni.update	#Se il tasto B è premuto	if Input.trigger?(Input::B)	  #Suona il SE di annullamento	  $game_system.se_play($data_system.cancel_se)	  #ritorna alla mappa	  $scene = Scene_Map.new	elsif Input.trigger?(Input::C)	  #Suona il SE di conferma	  $game_system.se_play($data_system.decision_se)	  #Controlla l'indice della selezione	  case @finestra_opzioni.index	  when 0		#Inverte lo stato della switch 1		$game_switches[1] = !$game_switches[1]	  when 1		#Aumenta la variabile 1 di 5		$game_variables[1] += 5	  when 2		#Decrementa la variabile 1 di 3		$game_variables[1] -= 3	  	  when 3		#Il party ottiene 100 oro		$game_party.gain_gold(100)	  when 4		#Aumenta il livello del leader di 1		$game_party.actors[0].level += 1	  end	  @finestra_valori.refresh	end  end

Oltre al già citato metodo update di @finestra_opzioni si può notare

Input.trigger?(Input::B)

Questo metodo controlla se un tasto, in questo caso B (non la lettera il tasto di Rpg Maker), è stato premuto,

oltre a trigger? esistono altri due metodi, ve li elenco è spiego tutti e 3

• press?(TASTO): Determina se TASTO sta venendo premuto
  
• trigger?(TASTO): Determina se TASTO è stato premuto di nuovo, cioè dopo uno stato di premuto e non premuto.
  
• repeat?(TASTO): Determina se TASTO è stato premuto e continua ad esserlo.
  

I tasti possono essere:

DOWN, LEFT, RIGHT, UP, A, B, C, X, Y, Z, L, R, SHIFT, CTRL, ALT, F5, F6, F7, F8, F9.

e devono essere preceduti da Input. in quanto costanti di questo modulo.

Inoltre ci sono i metodi dir4 e dir8 che ritornano dei valori numerici in base al tasto direzionale premuto (per i numeri guardate il tastierino numerico), dir8 considera anche le direzioni oblique.

 

Proseguendo verso il basso troviamo select case la cui variabile di controllo è @finestra_opzioni.index, il metodo index, come è facile intuire, indica l'indice del comando selezionato partendo da 0

ora in base a questo indice ho fatto eseguire diverse azioni alla nostra scena, subito dopo aver eseguito una delle 5 azioni la finestra con i valori viene aggiornata attraverso il metodo refresh.

La nostra scena è conclusa, essa può essere richiamata attraverso

$scene = Scene_Opzioni.new

 

La scena Completa è questa

class Scene_Opzioni  def main	#Nomi dei comandi	comandi = ["Switch 1", "Variabile 1 + 5", "Variabile 1 - 3", "Oro + 100", "#{$game_party.actors[0].name} + 1"]	#Inizializzo le finestre	@finestra_opzioni = Window_Command.new(160, comandi)	@finestra_valori = Window_Valori.new	#Ciclo Principale	Graphics.transition	loop do	  Graphics.update	  Input.update	  update	  if $scene != self		break	  end	end	Graphics.freeze	#Effettuo il dispose di tutte le finestre che ho inizializzato	@finestra_opzioni.dispose	@finestra_valori.dispose  end   def update	#aggiornamento finestra di selezione	@finestra_opzioni.update	#Se il tasto B è premuto	if Input.trigger?(Input::B)	  #Suona il SE di annullamento	  $game_system.se_play($data_system.cancel_se)	  #ritorna alla mappa	  $scene = Scene_Map.new	elsif Input.trigger?(Input::C)	  #Suona il SE di conferma	  $game_system.se_play($data_system.decision_se)	  #Controlla l'indice della selezione	  case @finestra_opzioni.index	  when 0		#Inverte lo stato della switch 1		$game_switches[1] = !$game_switches[1]	  when 1		#Aumenta la variabile 1 di 5		$game_variables[1] += 5	  when 2		#Decrementa la variabile 1 di 3		$game_variables[1] -= 3	  	  when 3		#Il party ottiene 100 oro		$game_party.gain_gold(100)	  when 4		#Aumenta il livello del leader di 1		$game_party.actors[0].level += 1	  end	  @finestra_valori.refresh	end  endend

Ricordatevi di copiarvi anche la finestra che ho inserito sopra.

 

Mi rendo conto che non ho spiegato tutto e non ho spiegato molto chiaramente ma è più semplice di quello che sembra creare una scena.

Prossimamente posterò uno snocciolamento degli script che gestiscono il Menu cosi che possa spiegare un po’ meglio il funzionamento delle scene e perché no dare qualche dritta per personalizzarvi i vostri menu.

Se ci sono domande, dubbi, volete mostrarmi le vostre scene o chiedere consigli/suggerimenti non esitate a postare.

[Guardian of Irael]

Bel tutorial, Sleeping ^ ^

Per ora non ho tempo, ma in seguito lo studierò più approfonditamente.

Non ho ben capito questa parte

Inoltre ci sono i metodi dir4 e dir8 che ritornano dei valori numerici in base al tasto direzionale premuto (per i numeri guardate il tastierino numerico), dir8 considera anche le direzioni oblique.

soprattutto la parte dir8 che considera le oblique :D

 

E' l' inizio di una serie di tutorial sull' RGSS? :D

^ ^

[MasterSion]

Complimenti Sleeping! Spiegato veramente bene (sopratutto per me che so già fare queste cose xD)

Mi servirebbero tutorial più avanzati ci arriverai prima o poi?

[Sleeping Leonhart]

@Guardian:Grazie mille, provo a spiegarti megli fai conto di avere all'interno del metodo update

tasto = Input.dir8

Ora se premi uno qualsiasi dei tasti movimento (su, giu, destra o sinistra), la variabile tasto assume un valore numerico che identifica la direzione che hai premuto con le frecce. Con direzioni oblique intendevo semplicemente dire quelle direzioni come su/destra, giu/sinistra.

La corrispondenza direzione premuta numero dovrebbe essere questa:

1: Giu/Sinistra 4:Sinistra 7: Su/Sinistra2: Giu					 8: Su3: Giu/Destra   6:Destra   9: Su/Destra

Con dir4 solo Giu/Su/Destra/Sinistra, con dir8 tutte. Spero di essermi spiegato meglio

 

@Master: Grazie anche a te, per qualcosa di piu avanzato non so, volevo fare una sorta di esplorazione degli script di base e con la scusa continuare ad insegnare. Come ho gia scritto con il prossimo tutorial punto ad indagare sugli script riguardanti il menu, quindi Window_MenuStatus, Scene_Menu ecc..., poi chissa forse qualcosa sul sistema di battaglia, anche se prima voglio vedere come gli utenti rispondono a questi "base".

[Guardian of Irael]

Ah sì, tutto chiaro, avevo frainteso il termine dir8 :D, grazie per l' esaustiva spiegazione.

^ ^

In attesa di altri bei tutorial :D

^ ^

[Kingartur2]

Ripetere ogni tanto non fa male.

@Guardian : se guardi nei meandri delle sezione tutorial, sleeping aveva messo 2 tutorial che facevano parte di una serie e nel secondo disse che il prossimo era sulle scene e ora sta continuando il suo lavoro.

[Guardian of Irael]

@Guardian : se guardi nei meandri delle sezione tutorial, sleeping aveva messo 2 tutorial che facevano parte di una serie e nel secondo disse che il prossimo era sulle scene e ora sta continuando il suo lavoro.

Ah sì grazie, poi mi son ricordato, volevo andare a rileggerli in effetti.

^ ^

[OblivionGv]

Mi sono accorto solo adesso di questo tutorial, fenomenale!

[Behemoth]

Scusate io fin ora so programmare in python, html e css, con queste conoscenze ho possibilità di capire come si scrive in rgss? o è un mondo completamente nuovo?

[Guardian of Irael]

Html e css son piuttosto diversi, python è un linguaggio di programmazione diciamo più simile, potrebbe esserci qualche parolina in comune, ma di base è proprio il fatto che tu già sappia programmare e conoscere le basi che ti avvantaggia nello studio dell'RGSS ^ ^

[Kingartur2]

Behemot se ci è riuscita una capra come me che non sapeva nemmeno programmare direi che vai liscio come l'olio.

[Lomax_Iced]

Ciao ragazzi. So che il post è vecchiotto, ma penso che essendo un tutorial non vige la regola dei necropost. Se invece si, mi scuso in anticipo.
Nel caso in cui non fosse:

Ho un problema nella compilazione del mio Scene_Base.
Più precisamente alla riga:

@window_base1        = Window_Baze1.new(160, [s1,s2,s3])

In sostanza una volta che faccio partire il tester, mi avvisa che in Window_Baze1 ci sono 2 di 0 argomenti. Ovvero 2 argomenti di troppo.
Ho fatto in modo che questa finestra sia una selectable.

Mi spiego meglio ho creato una scena_template definendola Scene_Base al cui interno ho creato due Finestre:

    @window_base1        = Window_Baze1.new(300, [s1,s2,s3])#Identifica la finestra assegnatela
    @window_base1.x      = 83                               #La sposta orizzontalmente
    @window_base1.y      = 469                              #La sposta verticalmente
    @window_base1.height = 170                              #disegna l'altezza della finestra
    @window_base1.width  = 700                              #disegna la larghezza della finestra
    @window_base1.z      = 200                              #determina l'opacità
    
    
    #Si possono inserire anche più finestre
    @window_base2        = Window_Baze2.new             
    @window_base2.x      = 0              #
    @window_base2.y      = 0              #
    @window_base2.height = 170            #
    @window_base2.width  = 700            #
    @window_base2.z      = 200            #
    #Dipende da che volete fare nella scena

Permettendo alla prima di ospitare i comandi e alla seconda di ospitare i loro valori
Pertanto la prima sarà figlia di Window_Selectable e la seconda invece di Window_Base

Vi posto le loro strutture:

#===============================================================================
# ** WINDOW_BAZE1 
#-------------------------------------------------------------------------------
# Finestra destinata ad ospitare i comandi della scena
#===============================================================================
class Window_Baze1 < Window_Selectable
  def initialize
      super(0, 0, 100,379)
      self.windowskin = RPG::Cache.windowskin("20")
      @item_max   = 1
      @column_max = 2
      self.contents = Bitmap.new(width * 32, height - 32)
      refresh
      self.index = 0
  end
  def refresh
    for i in 0...@item_max
      x = i % @column_max
      y = i / @column_max
      self.contents.font.name = "Tahoma"
      self.contents.font.size = 18
      self.contents.font.color = text_color(0)
      self.contents.draw_text(0, 0, 33, 33, "01")
      self.contents.draw_text(610, 25, 33, 33, "02")
    end
  end
end
#===============================================================================
# ** WINDOW_BAZE2 
#-------------------------------------------------------------------------------
# Finestra destinata ad ospitare i valori dei comandi della scena
#===============================================================================
class Window_Baze2 < Window_Base
  def initialize
    super(160, 0, 320, 192)
    self.windowskin = RPG::Cache.windowskin("20") #20 è il nome della mia wskin.
    self.contents = Bitmap.new(width - 32, height - 32)
    refresh
  end
  def refresh
    self.contents.clear
    self.contents.draw_text(0,  0, 256, 32,  "OPZIONE1")
    self.contents.draw_text(0, 48, 256, 32,  "OPZIONE2")
    self.contents.draw_text(0, 96, 256, 32,  "OPZIONE3")
  end
end

Per adesso non ho testato le loro dimensioni o posizioni sul piano cartesiano, quindi quei parametri lì anche se sbagliati sono irrilevanti.
Comunque
Sicuramente avrò sbagliato qualcosa, è che momentaneamente non riesco a individuare l'errore. Sfugge al mio occhio xD
Vi posto lo script per intero, che più occhi sono meglio di 2. :)

#===============================================================================
# ** SCENE_BASE
#-------------------------------------------------------------------------------
class Scene_Base
  #Include le costanti appartenenti al modulo Rpg::Input_keyboard
  include Rpg::Input_keyboard
  #-----------------------------------------------------------------------------
  # *Metodo per creare le finestre che apparterranno alla scena in questione.
  #-----------------------------------------------------------------------------
  def main
    # Imposta un'immagine di Background 
    @sprite = Sprite.new
    #@sprite.bitmap = Cache::picture("") #gelata perché non c'è un immagine
    #--------------------------------------------
    # OPZIONE: Crea comandi da far eseguire
    #--------------------------------------------
    #comandi = ["OPZIONE1","OPZIONE2","OPZIONE3"]
    s1       = "OPZIONE1"
    s2       = "OPZIONE2"
    s3       = "OPZIONE3"
    
    @window_base1        = Window_Baze1.new(300, [s1,s2,s3])#Identifica la finestra assegnatale
    @window_base1.x      = 83                               #La sposta orizzontalmente
    @window_base1.y      = 469                              #La sposta verticalmente
    @window_base1.height = 170                              #disegna l'altezza della finestra
    @window_base1.width  = 700                              #disegna la larghezza della finestra
    @window_base1.z      = 200                              #determina l'opacità
    
    
    #Si possono inserire anche più finestre
    @window_base2        = Window_Baze2.new             
    @window_base2.x      = 0              #
    @window_base2.y      = 0              #
    @window_base2.height = 170            #
    @window_base2.width  = 700            #
    @window_base2.z      = 200            #
    #Dipende da che volete fare nella scena
    
    #---------------------------------------
    # Fa eseguire un effetto di transizione
    #---------------------------------------
    Graphics.transition(20) #Il valore posto
    loop do                 #entro parentesi
      Graphics.update       #determina il 
      Input.update          #numero di frame
      update                #che determinano
      if $scene != self     #la durata. 
        break
      end
    end
    #---------------------------------------
    # Fa eseguire la chiusura delle finestre
    #---------------------------------------
    Graphics.freeze
    @window_base1.dispose
    @window_baze2.dispose
  end
  #-----------------------------------------------------------------------------
  # *Metodo che permette di definire lo svolgimento delle azioni inscenate
  #-----------------------------------------------------------------------------
  def update
    #-------------------
    # Attivo le finestre
    #-------------------
    @window_base1.update
    @window_base2.update
    #-------------------
    
    #-------------------
    print = "a" if keyboard(R_Key_A) or 
    print = "A" if keyboard(R_Key_SHIFT) + (R_Key_A)
    
    
    
    
    
    #-------------------
    
    #----------------------------------------------------------------------------------------------------
    # Implico che se digito il tasto::B si sente un suono e si avvia la scene_Map
    #----------------------------------------------------------------------------------------------------
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.decision_se)  
      $scene = Scene_Map.new 
    elsif Input.trigger?(Input::C)
      $game_system.se_play($data_system.decision_se)
      case @window_base1.index
      # Imposto i ruoli ai corrispettivi comandi
      when 0 #OPZIONE1
        comando_opzione1
      when 1 #OPZIONE2
        comando_opzione2
      when 2 #OPZIONE3
        comando_opzione3
      end
      #-----------------------------------------------------------------------------------
      # Visualizza i risultati delle istruzioni immesse ai comandi nella seconda finestra
      #-----------------------------------------------------------------------------------
      @window_base2.refresh
    end
  end
  #-----------------------------------------------------------------------------
  # *Metodo Comando1 (definisce in dettaglio il ruolo di tale opzione)
  #-----------------------------------------------------------------------------
  def comando_opzione1
    #Imposto un suono di selezione oggetto
    $game_system.se_play($data_system.decision_se) #conferma pressione tasto
    # Fermo il BGM che veniva eseguito nella scena
    # Audio.bgm_stop # comando gelato perché non c'è un BGM nella scena
    print = "OPZIONE1"
  end
  #-----------------------------------------------------------------------------
  # *Metodo Comando2 (definisce in dettaglio il ruolo di tale opzione)
  #-----------------------------------------------------------------------------
  def comando_opzione2
    #Imposto un suono di selezione oggetto
    $game_system.se_play($data_system.decision_se) #conferma pressione tasto
    # Fermo il BGM che veniva eseguito nella scena
    # Audio.bgm_stop # comando gelato perché non c'è un BGM nella scena
    print = "OPZIONE2"
  end
  #-----------------------------------------------------------------------------
  # *Metodo Comando3 (definisce in dettaglio il ruolo di tale opzione)
  #-----------------------------------------------------------------------------
  def comando_opzione3
    #Imposto un suono di selezione oggetto
    $game_system.se_play($data_system.decision_se) #conferma pressione tasto
    # Fermo il BGM che veniva eseguito nella scena
    # Audio.bgm_stop # comando gelato perché non c'è un BGM nella scena
    print = "OPZIONE3"
  end
end
#===============================================================================
# ** WINDOW_BAZE1 
#-------------------------------------------------------------------------------
# Finestra destinata ad ospitare i comandi della scena
#===============================================================================
class Window_Baze1 < Window_Base
  def initialize
      super(0, 0, 100,379)
      self.windowskin = RPG::Cache.windowskin("20")
      @item_max   = 1
      @column_max = 2
      self.contents = Bitmap.new(width * 32, height - 32)
      refresh
      self.index = 0
  end
  def refresh
    for i in 0...@item_max
      x = i % @column_max
      y = i / @column_max
      self.contents.font.name = "Tahoma"
      self.contents.font.size = 18
      self.contents.font.color = text_color(0)
      self.contents.draw_text(0, 0, 33, 33, "01")
      self.contents.draw_text(610, 25, 33, 33, "02")
    end
  end
end
#===============================================================================
# ** WINDOW_BAZE2 
#-------------------------------------------------------------------------------
# Finestra destinata ad ospitare i valori dei comandi della scena
#===============================================================================
class Window_Baze2 < Window_Base
  def initialize
    super(160, 0, 320, 192)
    self.contents = Bitmap.new(width - 32, height - 32)
    refresh
  end
  def refresh
    self.contents.clear
    self.contents.draw_text(0, 0, 256, 32, "OPZIONE1")
    self.contents.draw_text(0, 48, 256, 32, "OPZIONE2")
    self.contents.draw_text(0, 96, 256, 32, "OPZIONE3")
  end
end
#======================================================================FINE=====

Se notate appena sotto class Scene_Base ho inserito un comando che non appartiene alle spiegazioni di sleep.
Quel comando include (lo dice la parola stessa "Include" in questo caso le costanti del modulo Rpg::Input_keyboard presente nel mio script editor.

Il modulo in questione (fatto da Clyde) è un improvement dello Scene_Input_keyboard in sostanza uno script che permette l'uso di tutti i tasti della tastiera
evocando l'API :

GetAsyncKeyState = Win32API.new("user32","GetAsyncKeyState",['i'],'i')

Se volete ve lo posto (su richiesta) ma se cercate bene lo troverete in questo link: http://www.rpg2s.net/forum/index.php/topic/386-complete-keyboard-input/?hl=input_keyboard. E' molto versatile ed utile. Secondo me un'opzione importante da inserire in qualsiasi scena.

Comunque aldilà di ciò..
Potreste risolvermi il problema.

Fino adesso il mio approccio con gli script è sempre stato quello di modificare le istruzioni già esistenti. Vorrei evolvermi nel creare scene completamente da zero.
Mi piacerebbe scovare tutte le regole.