Lomax_Iced

August 9, 2019

Grazie Guardian :D
Spero che possa essere da spunto per qualcuno.

August 6, 2019

Salve gente del forum sono il vostro solito e incorregibile Lomax_iced di quartiere. Come vi va la vita?!

Oggi ho appena caricato un video tutorial sul mio canale in cui spiego come ho realizzato un Pianeta che mi è stato commissionato e per quanto io ci veda una caramellata di errori da correggere. Il cliente è rimasto soddisfatto. Sono sicuro che voi sapreste fare di meglio!

Cosa? Non sapete come si disegna un Pianeta?

E che problema c'è ecco qui il tutorial:
https://youtu.be/liQS3EoijLo

Potreste seguire le mie personalissime tecniche mooolto rustiche e casarecce per giungere all'obbiettivo e una volta compreso l'insieme sono sicuro che saprete come migliorare sempre più.

mi scuso per la qualità audio pessima ma il mio fedele Venti l'attore (questa è brutta) non me ne separo mai
rende la qualità audio pessima ma,,in compenso vivo. Se il video vi piace interagite con il canale come meglio vi pare.

E se avete dei consigli costruttivi da darmi. io sono qui :)
Buona serata

April 8, 2019

Ciao Gente!! Il vostro buon Lomax di Quartiere è passato per farvi un saluto e non potevo certo presentarmi a mani vuote :)
Si avvicina l'estate e con le belle giornate fate entrare più luce pertantoo occorrono sempre più finestre !!

In sostanza questo "Script tutorial" è rivolto a tutti coloro che desiderano aggiungere delle finestre nelle proprie scene.
Per chi non lo sapesse e vorrebbe imparare a crearle ecco il procedimento base.
:force_spoiler_open:
+- Alla fine ho scelto di creare un plug completo in modo che vi sarà estremamente più facile collocare

+- la vostra finestra in qualsiasi scena voi vogliate e per farlo basterà cambiare una sola parola.

:force_spoiler_close:

::Ecco a voi la risorsa completa::

/*:
 * @plugindesc Aggiunge una Finestra in qualsiasi scena voi vogliate
 * @author Lomax_iced
 * @help
 */
 
 (function() {
	 
	var _Scene_Title_Start = Scene_Title.prototype.start
	Scene_Title.prototype.start = function() {
		_Scene_Title_Start.call(this);
		this._esempiowindow = new Esempio_Window(30, 100);
		this.addWindow(this._esempiowindow);
		
	};
	 
	 function Esempio_Window() {
		 this.initialize.apply(this, arguments);
	 }
	 
	 Esempio_Window.prototype = Object.create(Window_Base.prototype);
	 Esempio_Window.prototype.constructor = Esempio_Window;
	 
	 Esempio_Window.prototype.initialize = function(x, y) {
		 Window_Base.prototype.initialize.call(this, x, y, 100, 100);
	 }
	 
 })();

Com'è stato possibile? Ve lo spiego qui giù vv

1. Mi hanno commissionato un progetto in cui l'ideatore aveva in mente di inserire in uno scene title un'altra finestra oltre a

quella di base. Modifica che non avevo mai fatto in Javascript. Così mi son detto JS...Linguaggio ad oggetti...tutti sono

oggetti e allora anche questa nuova window!

::Pertanto il primo passo da fare è proprio quello di realizzare l'oggetto nuovo::

function Esempio_Window() {
		 this.initialize.apply(this, arguments);
	 }

Qualsiasi oggetto ha sempre sicuramente delle caratteristiche/delle proprietà/degli attributi. Sono tutti sinonimi dello stesso concetto che
in javascript viene inteso con il costrutto function . Per permetterci l'intesa possiamo tradurlo volgarmente con il termine Funzione .
Ma come ho già descritto si riferisce a quanto letto prima.

Ma che acciderbolina è un Oggetto, senza andare troppo per le lunghe, generalizziamo il tutto il più possibile e immaginiamo di voler creare una base musicale / una canzone. Quindi ecco noi siamo aspiranti cantanti e vogliamo creare una Canzone.

Quindi quello che vogliamo creare/realizzare è una Canzone || Quindi il nostro oggetto in questo caso è una canzone .
Ora abbiamo già pensato ad un titolo? Come vogliamo chiamarla questa canzone?
Il Definire un nome ad un oggetto equivale a conferirne un attributo/una proprietà/caratteristica/Funzione!
Esattamente uguale come ho fatto nella creazione della nostra finestra. Le ho dato un nome. Nel caso di questo tutorial l'ho chiamata

Esempio_Window

Il conferire un Nome (sott'inteso: l'attributo Nome) equivale ad identificare l'oggetto. Ma in realtà "Esempio_Window" ci da un'altra informazione aggiuntiva. In quanto il nostro nome di fantasia che abbiamo (ho) scelto di dare a questo oggetto è solo ed unicamente
il costrutto "Esempio". L'underscore serve per associare due costrutti che specificano due caratteristiche diverse. In questo caso:

L'attributo Nome _ L'attributo Classe

L'unione di questi due attributi permette di identificare il cosa sarà quest'oggetto ossia una finestra di esempio.
Quindi noi stiamo creando una Finestra di Esempio. Attenzione però! perché per il momento l'abbiamo soltanto idealizzata nella nostra testa. E' un po come quando programmiamo di voler fare un viaggio in Giappone o chissà dove magari una meta un po fuori dalla nostra portata perché ancora siamo a scuola o a lavoro e l'estate difatti ancora è lontana. Intanto però con la mente / con la nostra testa immaginiamo e fantastichiamo sul nostro itinerario.

Ecco cosa stiamo facendo, giunti a scrivere questo.. Stiamo ancora fantasticando su ciò che dovrà essere il nostro oggetto.
Però conosciamo già la sua appartenenza. Ovvero lo abbiamo identificato come una Finestra. Non ha ancora associate le proprietà di una finestra ma sappiamo già che dovremmo conferirgliene alcune, come ad esempio la posizione spaziale all'interno del nostro diagramma cartesiano ossia difatti l'area che costituisce la scena. Un'altra caratteristica che sono solite avere le finestre è la dimenzione, ossia definirne una larghezza, un'altezza. E poi ne esistono tantissime altre. Queste che vi ho citato sono le essenziali e generiche proprie a tutte le finestre.

Quindi riepilogando:

function Esempio_Window() {
		 this.initialize.apply(this, arguments);
	 }

Il Primo Passo è stato quello di conferirgli un Nome e associarlo ad una Tipologia.
La tipologia non è altro che un oggetto più grosso che comprende dentro se stesso tanti piccoli oggettini che sono regolati dalle stesse caratteristiche e quindi il vantaggio di specificare a che tipo di tipologia appartiene quello specifico oggetto ne richiama le regole e la condivisione degli stessi costrutti e questa cosa semplifica molto il lavoro del programmatore.

Ad ogni modo possiamo confermare la nostra idea e battezzare /inizializzare nel concreto la nostra nuova finestra.
E per farlo si scrive quanto è scritto sopra. Ossia si apre e chiude una parentesi, atto ad indicare che questo oggetto difatti sarà un involucro come una scatola con dentro delle cose.

E allora aprendo una parentesi graffa e andando a capo si specifica che l'oggetto idealizzato dovrà essere initialize cioé letteralmente inizializzato /conferito /nato / ossia preso in considerazione. Ora non solo lui stesso / this ma anche le caratteristiche che allogerà al suo interno / arguments.

Adesso che abbiamo messo tutto in chiaro. Abbiamo definito che esiste qualcosa che ha la parvenza di appartenere al mondo delle finestre (ma ancora queste sono delle Rumors) ma intanto qualcosa di sicuro c'è!

2. Non sono più delle semplici notizie da corridoio le nostre. Adesso è venuto il momento di associare per davvero il nostro oggetto "Finestra di Esempio" alla categoria Finestre. Ed ecco il come..::

Esempio_Window.prototype = Object.create(Window_Base.prototype);

function così come prototype sono due costrutti essenziali in javascript poiché sono dei veri e propri comandi. Una volta citati essi innescheranno dei Metodi ossia delle modalità con cui si potranno concretizzare dei concetti. Come ad esempio lo è stato il costrutto
function che ci è servito per conferire all'idea degli attributi moniti a trasformare quell'idea in un oggetto.

prototype invece associato al nostro oggetto tramite quel '.' permette di specificare che esso apparterrà alla categoria (in questo caso) Window_ e nello specifico a "Window_Base" (tradotto Finestre di Default) Dove dentro questa macro-classe /oggetto più grande ci saranno tante altre funzioni e metodi che potranno essere associati anche al nostro nuovo oggetto Esempio_Window.

Volendo tradurre quella stringa di codice a livello molto letterale si ha che:

Il prototipo dell'oggetto Finestra di Esempio verrà associato ad un qualsiasi oggetto creato come prototipo di Window_Base .

Quindi..

Esempio_Window.prototype.constructor = Esempio_Window;

Si conferisce un Identificativo Concreto. Ovvero questa volta si concretizza in linea definitiva l'attributo Nome associato all'attributo categoria. Nel senso che con questa stringa di codice si comanda che il Nome completo scelto sia finalmente associato per davvero ad un oggetto /un prototipo che appartiene alla categoria delle Finestre.

Detto in modo semplice. Solo adesso Esempio_Window è per davvero una Finestra.

3. Però è vero ancora che è una finestra trasparente e non locata. E quindi il prossimo passo sarà proprio quello di darle una dimensione.

Esempio_Window.prototype.initialize = function(x, y) {
		 Window_Base.prototype.initialize.call(this, x, y, 100, 100);
	 }

Adesso non abbiamo più bisogno di specificare alcunché. Basterà prendere un metodo prefab nello script rpg_window.js se vogliamo essere pignoli nella sezione dedicata a Window_Base e lì basterà semplicemente copia e incollare quanto scritto lì di ciò che ci serve.

Io ad esempio come vi dicevo mi occorreva impostare la grandezza della finestra. E allora ho appioppato al nostro prototipo..
function(x, y) questo perché, prima di definirne una grandezza di norma è giusto dargli all'inizio una locazione di base. E pertanto le coordinate sono settate in maniera standard com'è di default. E così si lasciano (non è qui che potremmo sceglierne un valore).

Qui invece come vi dicevo occorrerà scalare la nostra finestra, modellandone la dimenzione tramite il settaggio dei parametri di larghezza e altezza. E quindi semplicissimo basterà richiamare con il costrutto .call il metodo in questione direttamente dalla macro-classe Window_Base. Dove vedete scritto 100, 100. Il primo parametro riguarderà il settaggio della Larghezza della finestra; il secondo parametro invece regolerà l'altezza. Qui potete sbizzarrirvi con la vostra fantasia, cambiandone i valori.

4. Quarto ed ultimo passaggio. Ora che abbiamo creato il nostro oggetto, bisognerà semplicemente scegliere in quale scena farlo apparire e dove collocarlo nella scena stessa, per quanto riguarda appunto la posizione.

volete un trucco?...............................................................
Recatevi in rpg_scene.js
scegliete una scena, ossia dove volete che appaia la vostra finestra.
io per commissione ad esempio ho dovuto selezionare Scene_Title. Ma può essere una scena qualsiasi.
Dentro la vostra scena scelta, cercate il metodo .start
Copiate e incollate tutto il metodo .start nel vostro script dove state creando la finestra.
Incollate il tutto qualche riga prima di aver idealizzato il nome del vostro oggetto. Quindi prima della prima funzione asseggata all'oggetto.
Ecco il mio esempio:

Scene_Title.prototype.start = function() {
    Scene_Base.prototype.start.call(this);
    SceneManager.clearStack();
    this.centerSprite(this._backSprite1);
    this.centerSprite(this._backSprite2);
    this.playTitleMusic();
    this.startFadeIn(this.fadeSpeed(), false);
};

Sottraggo da Scene_Title e lo colloco qui:

/*:
 * @plugindesc Aggiunge una Finestra in qualsiasi scena voi vogliate
 * @author Lomax_iced
 * @help
 */
 
 (function() {
	 
	Scene_Title.prototype.start = function() {
             Scene_Base.prototype.start.call(this);
             SceneManager.clearStack();
             this.centerSprite(this._backSprite1);
             this.centerSprite(this._backSprite2);
             this.playTitleMusic();
             this.startFadeIn(this.fadeSpeed(), false);
         };

	 function Esempio_Window() {
		 this.initialize.apply(this, arguments);
	 }
	 
	 Esempio_Window.prototype = Object.create(Window_Base.prototype);
	 Esempio_Window.prototype.constructor = Esempio_Window;
	 
	 Esempio_Window.prototype.initialize = function(x, y) {
		 Window_Base.prototype.initialize.call(this, x, y, 100, 100);
	 }
	 
 })();

Cancelliamo tutto quello di cui non ci interessa una cippa.

Scene_Title.prototype.start = function() {
		_Scene_Title_Start.call(this);
		this._esempiowindow = new Esempio_Window(30, 100);
		this.addWindow(this._esempiowindow);
		
	};

Questo è il metodo che permette a Scene_Title di avviarsi una volta avviato il gioco. Che sono quelle modifiche lì? Cosa ho implementato?

Intanto occorre che venga creata una variabile var utile per richiamare il metodo di Scene_Title attraverso appunto un .call di richiamo da qualsiasi punto si voglia del programma. possiamo attivarlo tramite un, una riga di comando, da qualsiasi punto.
Per farlo occorrerà inserire questa stringa poco prima:

(function() {
    
    var _Scene_Title_Start = Scene_Title.prototype.start
    Scene_Title.prototype.start = function() {
        _Scene_Title_Start.call(this);
        this._esempiowindow = new Esempio_Window(30, 100);
        this.addWindow(this._esempiowindow);
        
    };

var _Scene_Title_Start = Scene_Title.prototype.start

Azione vai col Title......partito!
Quindi la schermata iniziale si sta svolgendo e si svolgerà con tutte le imostazioni di default eccetto che viene specificata e verrà visualizzata la nostra nuova finestra e collocata nella posizione che decidereremo di impostare noi. tramite questa stringa:

this._esempiowindow = new Esempio_Window(30, 100);

Dove 30 corrisponde all'asse delle x e 100 all'asse delle y.

Quindi la si colloca ed infine le si da conferma:

this.addWindow(this._esempiowindow);

BANG! Aggiunta!

E questo è tutto quello che si fa per inserire una finestra dentro una qualsiasi scena si voglia. Sostituire allo script i costrutti Scene_Title con Scene_"ciò che si desidera" senza doppi apici e il gioco è fatto.

Ovvio che per conoscere cosa far visualizzare all'interno di questa finestra occorrerà andarsi a spulciare lo script rpg_window.js e vedere un po cosa desideriamo immetterle. Ma questo lo lascio a voi!

Sperimentate Sperimentate Sperimentate
Che gli script standard sono degli ottimi maestri
Io vi auguro un buon proseguo con le vostre realizzazioni
E arrileggerci alla prossima ;)

P.S: Ciao Guardian :)

August 26, 2018

Capisco, credevo che avevi del codice che non funzionava. Comunque sposto, spero passi qualche scripter da qui. Intanto prova a guardare menù come quello delle abilità dove premendo Q e W puoi cambiare le schede dei pg, il meccanismo dovrebbe essere simile.
^ ^

Ciao Gente come vi va la vita?! :D

P.S: Sono consapevole che il post è vecchiotto ma volevo comunque rispondere alla richiesta, magari qualcuno ha lo stesso problema e..capito?! Ok. :)

Dunque:

1.Per prima cosa capiamo come si costruisce una finestra in linea generale:

function Esempio_di_Finestra() {
    this.initialize.apply(this, arguments);
};

D: Cosa ho fatto?

R: Semplice, ho richiamato il costrutto 'function'; poi ho dato un nome qualsiasi alla cosa che voglio realizzare;

Ricordate che il Javascript è un linguaggio ad oggetti. Quindi quando noi conferiamo un nome ad un oggetto,

noi non lo idealizziamo solo, ma lo creiamo nel momento esatto in cui gli conferiamo il nome.

Poi.. siccome il nostro oggetto possiederà anche delle funzionalità al suo interno, allegate al nome gli diamo pure due parentesi tonde per il momento vuote. Avremo tempo di specificarle dopo.

(per specificarle intendo che avremo modo di conferire a questo oggetto i propri attributi (((BIG correggetemi se sbaglio!))))

In sintesi abbiamo spiegato sino a qui:

function Esempio_di_Finestra()

Adesso però solo così sappiamo che siamo in procinto di creare un oggetto nominato Esempio_di_Finestra che avrà delle caratteristiche. Ora bisogna finalizzare le sue caratteristiche e per farlo bisogna chiudere il processo di idealizzazione con le parentesi graffe susseguite da un punto e virgola, segno conclusivo dell'effettuazione dell'operazione. In sostanza così:

function Finestra_Esempio() {

};

Tra queste parentesi graffe conferiremo tutti gli ordini che vorremo imporre a quest'oggetto che stiamo appena creando.

Il Primo comando che occorre conferire sempre a tutti gli oggetti che si vorranno creare è il comando:

this.initialize.apply(this,arguments);

D: Cosa ho fatto?

R: Semplice ho comandato che Questo! Oggetto debba inizializzarsi

this.initialize

this = (Questo) costrutto riflessivo riferito all'oggetto

. = costrutto di concatenamento comando

initialize = comando 'initialize' (inizializza oggetto)

Non ho finito..

Ecco giunto il momento di specificare le caratteristiche generiche che avrà l'oggetto in questione, ovvero:

.apply(this,arguments);

. = altro costrutto di concatenamento comando

apply = comando 'apply' (applica all'oggetto)

( = inizio specifica caratteristiche...

this, = indica che le caratteristiche influenzeranno l'oggetto in questione.

arguments = possiederà delle caratteristiche (in questo momento ancora non definite)

) = chiusura specifica caratteristiche.

; = Conclusione comando.

Quindi ricapitoliamo:

function Esempio_di_Finestra() {
   this.initialize.apply(this,arguments);
};

Tutto questo periodo di codice corrisponde al metodo complessivo per costituire l'identificazione dell'oggetto in questione.

Nome e possibilità di inserire caratteristiche.

Adesso dobbiamo associare al nostro oggetto appena creato un'appartenenza.

Questo perché bisogna ricordare che tutti gli oggetti creati in Javascript sono 'figli' di oggetti più grossi definiti 'padri'. Nel nostro caso sappiamo che stiamo creando una Finestra. Quindi il nostro oggetto apparterrà alla categoria Finestra (la categoria Finestra è il suo Oggetto Padre).

Il metodo per permettere che il nostro oggetto venga associato a questa categoria è il seguente:

Esempio_di_Finestra.prototype = Object.create(Window_Selectable.prototype);

Esempio_di_Finestra = Il nostro oggetto (fino ad ora non definito)

. = costrutto di concatenamento

prototype = comando 'prototype' (unito al nome all'oggetto permettono il concatenamento

con i costrutti e i comandi che si utilizzeranno nei prossimi metodi.

= = costrutto associativo (lega l'oggetto alla categoria di appartenenza)

Object = E' l'oggetto Padre di tutte le altre categorie (le comprende tutte)

. = costrutto di concatenamento

create = comando 'create' (Estrapola la sezione specifica di Object che poi sarà la

categoria Padre dell'oggetto che abbiamo appena creato).

( = inizio specifica..

Window_Selectable = La categoria specifica di cui farà parte il nostro oggetto.

. = costrutto di concatenamento

prototype = comando 'prototype' (unito al nome all'oggetto permettono il concatenamento

con i costrutti e i comandi che si utilizzeranno nei prossimi metodi.

) = chiusura specifica.

; = Conclusione comando.

Con questa stringa di codice abbiamo finalmente specificato che Esempio_di_Finestra adesso è effettivamente una finestra. Perché diventando un oggetto Figlio di Window_Selectable assumerà tutti i metodi e tutte le caratteristiche che apparterranno al suo oggetto Padre. In sintesi Esempio_di_Finestra apparterrà da ora in poi alla categoria Window_Selectable. (Finestre Selezionabili)

Di sua volta Window_Selectable è figlia dell'oggetto Object che è padre di tutte le categorie presenti in RPGMV

E adesso possiamo iniziare a richiamare tutti i comandi che possono essere estratti dalla categoria di cui è figlio

il nostro oggetto (ossia la nostra finestra)

Esempio_di_Finestra.prototype.constructor = Esempio_di_Finestra;

Come il comando constructor che la identifica questa volta non come oggetto generico ma come finestra.

Esempio_di_Finestra.prototype.initialize = function(x, y, width, height) {
    Window_Selectable.prototype.initialize.call(this, x, y, width, height);
};

Il comando 'initialize' che questa volta però assume le proprietà utili per costruire una vera e propria finestra

con annessi attributi quali: 'this' inteso come un 'se stesso' riflessivo, ovvero le funzioni interesseranno l'oggetto in se; 'x' e 'y' che altri non sono che le coordinate che serviranno ad impostare una posizione della nostra oggetto/finestra; e per ultimo le grandezze 'width' e 'height'. E' intuibile che questi attributi appartengono a Selectable, c'è pure specificato, ma non solo questo così facendo anche le impostazioni, cioé le variabili ad esse associate saranno standard come in selectable. Questo è utile a livello di scripting per evitare di ripetersi sempre,

ma se si vuole avere maggior controllo di editing potremmo strutturare il tutto in questo modo:

Esempio_di_Finestra.prototype.initialize = function(x, y, width, height) {
    this.x = 0
    this.y = 0
    this.width = 640
    this.height = 480
};

E poi dopo come dice Guardian potremmo recarci alla riga 2116 dello script rpg_windows.js e valutare come strutturare questa finestra cosa inserire al suo interno. Potremmo strutturarla dall'esoscheletro identico a Window_SkillList e vedere un po cosa estrarre e cosa no. Oppure Window_Status che dovrebbe essere più semplice. Ad ogni modo mi sto interessando alla cosa e entro domani completerò questo post (ora ho sonno)

Qui di seguito vi sono le classi che si devono consultare per xhi volesse come me cimentarsi nell'impresa:

//-----------------------------------------------------------------------------
// Window_Selectable
//
// The window class with cursor movement and scroll functions.

function Window_Selectable() {
    this.initialize.apply(this, arguments);
}

Window_Selectable.prototype = Object.create(Window_Base.prototype);
Window_Selectable.prototype.constructor = Window_Selectable;

Window_Selectable.prototype.initialize = function(x, y, width, height) {
    Window_Base.prototype.initialize.call(this, x, y, width, height);
    this._index = -1;
    this._cursorFixed = false;
    this._cursorAll = false;
    this._stayCount = 0;
    this._helpWindow = null;
    this._handlers = {};
    this._touching = false;
    this._scrollX = 0;
    this._scrollY = 0;
    this.deactivate();
};

Window_Selectable.prototype.index = function() {
    return this._index;
};

Window_Selectable.prototype.cursorFixed = function() {
    return this._cursorFixed;
};

Window_Selectable.prototype.setCursorFixed = function(cursorFixed) {
    this._cursorFixed = cursorFixed;
};

Window_Selectable.prototype.cursorAll = function() {
    return this._cursorAll;
};

Window_Selectable.prototype.setCursorAll = function(cursorAll) {
    this._cursorAll = cursorAll;
};

Window_Selectable.prototype.maxCols = function() {
    return 1;
};

Window_Selectable.prototype.maxItems = function() {
    return 0;
};

Window_Selectable.prototype.spacing = function() {
    return 12;
};

Window_Selectable.prototype.itemWidth = function() {
    return Math.floor((this.width - this.padding * 2 +
                       this.spacing()) / this.maxCols() - this.spacing());
};

Window_Selectable.prototype.itemHeight = function() {
    return this.lineHeight();
};

Window_Selectable.prototype.maxRows = function() {
    return Math.max(Math.ceil(this.maxItems() / this.maxCols()), 1);
};

Window_Selectable.prototype.activate = function() {
    Window_Base.prototype.activate.call(this);
    this.reselect();
};

Window_Selectable.prototype.deactivate = function() {
    Window_Base.prototype.deactivate.call(this);
    this.reselect();
};

Window_Selectable.prototype.select = function(index) {
    this._index = index;
    this._stayCount = 0;
    this.ensureCursorVisible();
    this.updateCursor();
    this.callUpdateHelp();
};

Window_Selectable.prototype.deselect = function() {
    this.select(-1);
};

Window_Selectable.prototype.reselect = function() {
    this.select(this._index);
};

Window_Selectable.prototype.row = function() {
    return Math.floor(this.index() / this.maxCols());
};

Window_Selectable.prototype.topRow = function() {
    return Math.floor(this._scrollY / this.itemHeight());
};

Window_Selectable.prototype.maxTopRow = function() {
    return Math.max(0, this.maxRows() - this.maxPageRows());
};

Window_Selectable.prototype.setTopRow = function(row) {
    var scrollY = row.clamp(0, this.maxTopRow()) * this.itemHeight();
    if (this._scrollY !== scrollY) {
        this._scrollY = scrollY;
        this.refresh();
        this.updateCursor();
    }
};

Window_Selectable.prototype.resetScroll = function() {
    this.setTopRow(0);
};

Window_Selectable.prototype.maxPageRows = function() {
    var pageHeight = this.height - this.padding * 2;
    return Math.floor(pageHeight / this.itemHeight());
};

Window_Selectable.prototype.maxPageItems = function() {
    return this.maxPageRows() * this.maxCols();
};

Window_Selectable.prototype.isHorizontal = function() {
    return this.maxPageRows() === 1;
};

Window_Selectable.prototype.bottomRow = function() {
    return Math.max(0, this.topRow() + this.maxPageRows() - 1);
};

Window_Selectable.prototype.setBottomRow = function(row) {
    this.setTopRow(row - (this.maxPageRows() - 1));
};

Window_Selectable.prototype.topIndex = function() {
    return this.topRow() * this.maxCols();
};

Window_Selectable.prototype.itemRect = function(index) {
    var rect = new Rectangle();
    var maxCols = this.maxCols();
    rect.width = this.itemWidth();
    rect.height = this.itemHeight();
    rect.x = index % maxCols * (rect.width + this.spacing()) - this._scrollX;
    rect.y = Math.floor(index / maxCols) * rect.height - this._scrollY;
    return rect;
};

Window_Selectable.prototype.itemRectForText = function(index) {
    var rect = this.itemRect(index);
    rect.x += this.textPadding();
    rect.width -= this.textPadding() * 2;
    return rect;
};

Window_Selectable.prototype.setHelpWindow = function(helpWindow) {
    this._helpWindow = helpWindow;
    this.callUpdateHelp();
};

Window_Selectable.prototype.showHelpWindow = function() {
    if (this._helpWindow) {
        this._helpWindow.show();
    }
};

Window_Selectable.prototype.hideHelpWindow = function() {
    if (this._helpWindow) {
        this._helpWindow.hide();
    }
};

Window_Selectable.prototype.setHandler = function(symbol, method) {
    this._handlers[symbol] = method;
};

Window_Selectable.prototype.isHandled = function(symbol) {
    return !!this._handlers[symbol];
};

Window_Selectable.prototype.callHandler = function(symbol) {
    if (this.isHandled(symbol)) {
        this._handlers[symbol]();
    }
};

Window_Selectable.prototype.isOpenAndActive = function() {
    return this.isOpen() && this.active;
};

Window_Selectable.prototype.isCursorMovable = function() {
    return (this.isOpenAndActive() && !this._cursorFixed &&
            !this._cursorAll && this.maxItems() > 0);
};

Window_Selectable.prototype.cursorDown = function(wrap) {
    var index = this.index();
    var maxItems = this.maxItems();
    var maxCols = this.maxCols();
    if (index < maxItems - maxCols || (wrap && maxCols === 1)) {
        this.select((index + maxCols) % maxItems);
    }
};

Window_Selectable.prototype.cursorUp = function(wrap) {
    var index = this.index();
    var maxItems = this.maxItems();
    var maxCols = this.maxCols();
    if (index >= maxCols || (wrap && maxCols === 1)) {
        this.select((index - maxCols + maxItems) % maxItems);
    }
};

Window_Selectable.prototype.cursorRight = function(wrap) {
    var index = this.index();
    var maxItems = this.maxItems();
    var maxCols = this.maxCols();
    if (maxCols >= 2 && (index < maxItems - 1 || (wrap && this.isHorizontal()))) {
        this.select((index + 1) % maxItems);
    }
};

Window_Selectable.prototype.cursorLeft = function(wrap) {
    var index = this.index();
    var maxItems = this.maxItems();
    var maxCols = this.maxCols();
    if (maxCols >= 2 && (index > 0 || (wrap && this.isHorizontal()))) {
        this.select((index - 1 + maxItems) % maxItems);
    }
};

Window_Selectable.prototype.cursorPagedown = function() {
    var index = this.index();
    var maxItems = this.maxItems();
    if (this.topRow() + this.maxPageRows() < this.maxRows()) {
        this.setTopRow(this.topRow() + this.maxPageRows());
        this.select(Math.min(index + this.maxPageItems(), maxItems - 1));
    }
};

Window_Selectable.prototype.cursorPageup = function() {
    var index = this.index();
    if (this.topRow() > 0) {
        this.setTopRow(this.topRow() - this.maxPageRows());
        this.select(Math.max(index - this.maxPageItems(), 0));
    }
};

Window_Selectable.prototype.scrollDown = function() {
    if (this.topRow() + 1 < this.maxRows()) {
        this.setTopRow(this.topRow() + 1);
    }
};

Window_Selectable.prototype.scrollUp = function() {
    if (this.topRow() > 0) {
        this.setTopRow(this.topRow() - 1);
    }
};

Window_Selectable.prototype.update = function() {
    Window_Base.prototype.update.call(this);
    this.updateArrows();
    this.processCursorMove();
    this.processHandling();
    this.processWheel();
    this.processTouch();
    this._stayCount++;
};

Window_Selectable.prototype.updateArrows = function() {
    var topRow = this.topRow();
    var maxTopRow = this.maxTopRow();
    this.downArrowVisible = maxTopRow > 0 && topRow < maxTopRow;
    this.upArrowVisible = topRow > 0;
};

Window_Selectable.prototype.processCursorMove = function() {
    if (this.isCursorMovable()) {
        var lastIndex = this.index();
        if (Input.isRepeated('down')) {
            this.cursorDown(Input.isTriggered('down'));
        }
        if (Input.isRepeated('up')) {
            this.cursorUp(Input.isTriggered('up'));
        }
        if (Input.isRepeated('right')) {
            this.cursorRight(Input.isTriggered('right'));
        }
        if (Input.isRepeated('left')) {
            this.cursorLeft(Input.isTriggered('left'));
        }
        if (!this.isHandled('pagedown') && Input.isTriggered('pagedown')) {
            this.cursorPagedown();
        }
        if (!this.isHandled('pageup') && Input.isTriggered('pageup')) {
            this.cursorPageup();
        }
        if (this.index() !== lastIndex) {
            SoundManager.playCursor();
        }
    }
};

Window_Selectable.prototype.processHandling = function() {
    if (this.isOpenAndActive()) {
        if (this.isOkEnabled() && this.isOkTriggered()) {
            this.processOk();
        } else if (this.isCancelEnabled() && this.isCancelTriggered()) {
            this.processCancel();
        } else if (this.isHandled('pagedown') && Input.isTriggered('pagedown')) {
            this.processPagedown();
        } else if (this.isHandled('pageup') && Input.isTriggered('pageup')) {
            this.processPageup();
        }
    }
};

Window_Selectable.prototype.processWheel = function() {
    if (this.isOpenAndActive()) {
        var threshold = 20;
        if (TouchInput.wheelY >= threshold) {
            this.scrollDown();
        }
        if (TouchInput.wheelY <= -threshold) {
            this.scrollUp();
        }
    }
};

Window_Selectable.prototype.processTouch = function() {
    if (this.isOpenAndActive()) {
        if (TouchInput.isTriggered() && this.isTouchedInsideFrame()) {
            this._touching = true;
            this.onTouch(true);
        } else if (TouchInput.isCancelled()) {
            if (this.isCancelEnabled()) {
                this.processCancel();
            }
        }
        if (this._touching) {
            if (TouchInput.isPressed()) {
                this.onTouch(false);
            } else {
                this._touching = false;
            }
        }
    } else {
        this._touching = false;
    }
};

Window_Selectable.prototype.isTouchedInsideFrame = function() {
    var x = this.canvasToLocalX(TouchInput.x);
    var y = this.canvasToLocalY(TouchInput.y);
    return x >= 0 && y >= 0 && x < this.width && y < this.height;
};

Window_Selectable.prototype.onTouch = function(triggered) {
    var lastIndex = this.index();
    var x = this.canvasToLocalX(TouchInput.x);
    var y = this.canvasToLocalY(TouchInput.y);
    var hitIndex = this.hitTest(x, y);
    if (hitIndex >= 0) {
        if (hitIndex === this.index()) {
            if (triggered && this.isTouchOkEnabled()) {
                this.processOk();
            }
        } else if (this.isCursorMovable()) {
            this.select(hitIndex);
        }
    } else if (this._stayCount >= 10) {
        if (y < this.padding) {
            this.cursorUp();
        } else if (y >= this.height - this.padding) {
            this.cursorDown();
        }
    }
    if (this.index() !== lastIndex) {
        SoundManager.playCursor();
    }
};

Window_Selectable.prototype.hitTest = function(x, y) {
    if (this.isContentsArea(x, y)) {
        var cx = x - this.padding;
        var cy = y - this.padding;
        var topIndex = this.topIndex();
        for (var i = 0; i < this.maxPageItems(); i++) {
            var index = topIndex + i;
            if (index < this.maxItems()) {
                var rect = this.itemRect(index);
                var right = rect.x + rect.width;
                var bottom = rect.y + rect.height;
                if (cx >= rect.x && cy >= rect.y && cx < right && cy < bottom) {
                    return index;
                }
            }
        }
    }
    return -1;
};

Window_Selectable.prototype.isContentsArea = function(x, y) {
    var left = this.padding;
    var top = this.padding;
    var right = this.width - this.padding;
    var bottom = this.height - this.padding;
    return (x >= left && y >= top && x < right && y < bottom);
};

Window_Selectable.prototype.isTouchOkEnabled = function() {
    return this.isOkEnabled();
};

Window_Selectable.prototype.isOkEnabled = function() {
    return this.isHandled('ok');
};

Window_Selectable.prototype.isCancelEnabled = function() {
    return this.isHandled('cancel');
};

Window_Selectable.prototype.isOkTriggered = function() {
    return Input.isRepeated('ok');
};

Window_Selectable.prototype.isCancelTriggered = function() {
    return Input.isRepeated('cancel');
};

Window_Selectable.prototype.processOk = function() {
    if (this.isCurrentItemEnabled()) {
        this.playOkSound();
        this.updateInputData();
        this.deactivate();
        this.callOkHandler();
    } else {
        this.playBuzzerSound();
    }
};

Window_Selectable.prototype.playOkSound = function() {
    SoundManager.playOk();
};

Window_Selectable.prototype.playBuzzerSound = function() {
    SoundManager.playBuzzer();
};

Window_Selectable.prototype.callOkHandler = function() {
    this.callHandler('ok');
};

Window_Selectable.prototype.processCancel = function() {
    SoundManager.playCancel();
    this.updateInputData();
    this.deactivate();
    this.callCancelHandler();
};

Window_Selectable.prototype.callCancelHandler = function() {
    this.callHandler('cancel');
};

Window_Selectable.prototype.processPageup = function() {
    SoundManager.playCursor();
    this.updateInputData();
    this.deactivate();
    this.callHandler('pageup');
};

Window_Selectable.prototype.processPagedown = function() {
    SoundManager.playCursor();
    this.updateInputData();
    this.deactivate();
    this.callHandler('pagedown');
};

Window_Selectable.prototype.updateInputData = function() {
    Input.update();
    TouchInput.update();
};

Window_Selectable.prototype.updateCursor = function() {
    if (this._cursorAll) {
        var allRowsHeight = this.maxRows() * this.itemHeight();
        this.setCursorRect(0, 0, this.contents.width, allRowsHeight);
        this.setTopRow(0);
    } else if (this.isCursorVisible()) {
        var rect = this.itemRect(this.index());
        this.setCursorRect(rect.x, rect.y, rect.width, rect.height);
    } else {
        this.setCursorRect(0, 0, 0, 0);
    }
};

Window_Selectable.prototype.isCursorVisible = function() {
    var row = this.row();
    return row >= this.topRow() && row <= this.bottomRow();
};

Window_Selectable.prototype.ensureCursorVisible = function() {
    var row = this.row();
    if (row < this.topRow()) {
        this.setTopRow(row);
    } else if (row > this.bottomRow()) {
        this.setBottomRow(row);
    }
};

Window_Selectable.prototype.callUpdateHelp = function() {
    if (this.active && this._helpWindow) {
        this.updateHelp();
    }
};

Window_Selectable.prototype.updateHelp = function() {
    this._helpWindow.clear();
};

Window_Selectable.prototype.setHelpWindowItem = function(item) {
    if (this._helpWindow) {
        this._helpWindow.setItem(item);
    }
};

Window_Selectable.prototype.isCurrentItemEnabled = function() {
    return true;
};

Window_Selectable.prototype.drawAllItems = function() {
    var topIndex = this.topIndex();
    for (var i = 0; i < this.maxPageItems(); i++) {
        var index = topIndex + i;
        if (index < this.maxItems()) {
            this.drawItem(index);
        }
    }
};

Window_Selectable.prototype.drawItem = function(index) {
};

Window_Selectable.prototype.clearItem = function(index) {
    var rect = this.itemRect(index);
    this.contents.clearRect(rect.x, rect.y, rect.width, rect.height);
};

Window_Selectable.prototype.redrawItem = function(index) {
    if (index >= 0) {
        this.clearItem(index);
        this.drawItem(index);
    }
};

Window_Selectable.prototype.redrawCurrentItem = function() {
    this.redrawItem(this.index());
};

Window_Selectable.prototype.refresh = function() {
    if (this.contents) {
        this.contents.clear();
        this.drawAllItems();
    }
};

//-----------------------------------------------------------------------------
// Window_Status
//
// The window for displaying full status on the status screen.

function Window_Status() {
    this.initialize.apply(this, arguments);
}

Window_Status.prototype = Object.create(Window_Selectable.prototype);
Window_Status.prototype.constructor = Window_Status;

Window_Status.prototype.initialize = function() {
    var width = Graphics.boxWidth;
    var height = Graphics.boxHeight;
    Window_Selectable.prototype.initialize.call(this, 0, 0, width, height);
    this.refresh();
    this.activate();
};

Window_Status.prototype.setActor = function(actor) {
    if (this._actor !== actor) {
        this._actor = actor;
        this.refresh();
    }
};

Window_Status.prototype.refresh = function() {
    this.contents.clear();
    if (this._actor) {
        var lineHeight = this.lineHeight();
        this.drawBlock1(lineHeight * 0);
        this.drawHorzLine(lineHeight * 1);
        this.drawBlock2(lineHeight * 2);
        this.drawHorzLine(lineHeight * 6);
        this.drawBlock3(lineHeight * 7);
        this.drawHorzLine(lineHeight * 13);
        this.drawBlock4(lineHeight * 14);
    }
};

Window_Status.prototype.drawBlock1 = function(y) {
    this.drawActorName(this._actor, 6, y);
    this.drawActorClass(this._actor, 192, y);
    this.drawActorNickname(this._actor, 432, y);
};

Window_Status.prototype.drawBlock2 = function(y) {
    this.drawActorFace(this._actor, 12, y);
    this.drawBasicInfo(204, y);
    this.drawExpInfo(456, y);
};

Window_Status.prototype.drawBlock3 = function(y) {
    this.drawParameters(48, y);
    this.drawEquipments(432, y);
};

Window_Status.prototype.drawBlock4 = function(y) {
    this.drawProfile(6, y);
};

Window_Status.prototype.drawHorzLine = function(y) {
    var lineY = y + this.lineHeight() / 2 - 1;
    this.contents.paintOpacity = 48;
    this.contents.fillRect(0, lineY, this.contentsWidth(), 2, this.lineColor());
    this.contents.paintOpacity = 255;
};

Window_Status.prototype.lineColor = function() {
    return this.normalColor();
};

Window_Status.prototype.drawBasicInfo = function(x, y) {
    var lineHeight = this.lineHeight();
    this.drawActorLevel(this._actor, x, y + lineHeight * 0);
    this.drawActorIcons(this._actor, x, y + lineHeight * 1);
    this.drawActorHp(this._actor, x, y + lineHeight * 2);
    this.drawActorMp(this._actor, x, y + lineHeight * 3);
};

Window_Status.prototype.drawParameters = function(x, y) {
    var lineHeight = this.lineHeight();
    for (var i = 0; i < 6; i++) {
        var paramId = i + 2;
        var y2 = y + lineHeight * i;
        this.changeTextColor(this.systemColor());
        this.drawText(TextManager.param(paramId), x, y2, 160);
        this.resetTextColor();
        this.drawText(this._actor.param(paramId), x + 160, y2, 60, 'right');
    }
};

Window_Status.prototype.drawExpInfo = function(x, y) {
    var lineHeight = this.lineHeight();
    var expTotal = TextManager.expTotal.format(TextManager.exp);
    var expNext = TextManager.expNext.format(TextManager.level);
    var value1 = this._actor.currentExp();
    var value2 = this._actor.nextRequiredExp();
    if (this._actor.isMaxLevel()) {
        value1 = '-------';
        value2 = '-------';
    }
    this.changeTextColor(this.systemColor());
    this.drawText(expTotal, x, y + lineHeight * 0, 270);
    this.drawText(expNext, x, y + lineHeight * 2, 270);
    this.resetTextColor();
    this.drawText(value1, x, y + lineHeight * 1, 270, 'right');
    this.drawText(value2, x, y + lineHeight * 3, 270, 'right');
};

Window_Status.prototype.drawEquipments = function(x, y) {
    var equips = this._actor.equips();
    var count = Math.min(equips.length, this.maxEquipmentLines());
    for (var i = 0; i < count; i++) {
        this.drawItemName(equips[i], x, y + this.lineHeight() * i);
    }
};

Window_Status.prototype.drawProfile = function(x, y) {
    this.drawTextEx(this._actor.profile(), x, y);
};

Window_Status.prototype.maxEquipmentLines = function() {
    return 6;
};

//-----------------------------------------------------------------------------
// Scene_Status
//
// The scene class of the status screen.

function Scene_Status() {
    this.initialize.apply(this, arguments);
}

Scene_Status.prototype = Object.create(Scene_MenuBase.prototype);
Scene_Status.prototype.constructor = Scene_Status;

Scene_Status.prototype.initialize = function() {
    Scene_MenuBase.prototype.initialize.call(this);
};

Scene_Status.prototype.create = function() {
    Scene_MenuBase.prototype.create.call(this);
    this._statusWindow = new Window_Status();
    this._statusWindow.setHandler('cancel',   this.popScene.bind(this));
    this._statusWindow.setHandler('pagedown', this.nextActor.bind(this));
    this._statusWindow.setHandler('pageup',   this.previousActor.bind(this));
    this.addWindow(this._statusWindow);
    this.refreshActor();
};

Scene_Status.prototype.refreshActor = function() {
    var actor = this.actor();
    this._statusWindow.setActor(actor);
};

Scene_Status.prototype.onActorChange = function() {
    this.refreshActor();
    this._statusWindow.activate();
};

March 25, 2018

Grazie Guardian. :)

Ora me lo studio per bene.

March 25, 2018

Raga esiste qualcosa di simile per rpg maker mv?

March 9, 2018

Vero. Hai ragione. Ammetto di aver trascurato questa regola., nel background del title.
Paradossalmente invece in maniera del tutto istintiva, l'ho adottata nelle scene, facendola diventare un concetto cardine.

March 9, 2018

In vero le prime sono accennate. Non volevo che fossero pienamente evidenti. Questo perché quest'acqua cheta, rovescia la medaglia, nel senso.. okay 'calma' può essere intesa come sinonimo di 'tranquillità', 'serenità' etc. Ma questa chetezza dell'acqua ne conferisce un secondo significato, ovvero ti spinge inesorabilmente a porti una domanda, ovvero.. 'Chissà cosa mi aspetta dopo?'
A te non capita tipo, difronte ad un paeaggio bello e atmosferico, inizialmente godertelo in tutti i suoi colori ed elementi..?
Poi però ad un certo punto..subentra il pensiero che non durerà per sempre, e qui la domanda.. 'Chissà cosa accadrà dopo?'
Beh questa domanda muta l'emozione, la stravolge, genera una fievole ansia cheinfine sfocia e va via nel momento esatto che si
seleziona 'New_Game' ed inizia la storia vera e propria.

In RPG MAKER aimé ci si deve cozzare con questa mappatura concepita piatta. Ma l'idea, il tentativo e per certi versi l'insistenza è quella di
guidare la vista dello spettatore verso nuovi punti di angolazione. Ma come mi fai benissimo notare te, la battaglia è ardua ma non impossibile.

L'idea è di conferire spazialità della scena. Nota come ho lasciato più spazio all'orizzonte. Quella nuvola è frutto del conubio fra l'uso di Paint, strumento bomboletta spray massima grammatura e il tanto mio amato sfumino di gimp. Posso migliorare ancora, lo so. Ma quella nuvola per adesso
rappresenta il mio livello. A me personalmente mi infonde soddisfazione. Ma sicuramente saprò fare dell'altro.

Il mare che si fonde alla terra altri non è che terra.
Con ciò voglio dire che, l'idea di realizzazione era che io non avrei dovuto rappresentare dell'acqua, (di fatti non vi sono riflessi di luce)
Ma il fondale e le sue diverse graduazioni di profondità espresse in tonalità. Proprio per quel mio voler aiutare lo spettatore a cambiare cognizione visiva. Come quando sposti l'oggetto 'camera' di blander.

In questo caso da quella visuale lì è logico che si vedano le diverse profondità e le analoghe cangianze dell'acqua, fino a perdita d'occhio, fino all'orizzonte.. (per lo meno questo è l'intento)

Per quanto riguarda la scena, si. Adesso l'ho notato anche io.
Però che colpo d'occhio :) Mi era sfuggito..

March 9, 2018

Si è vero. :)
Quando vedi pixel, lì ho utilizzato paint.
Quando vedi sfumino, lì ho usato gimp.
Nello scene title i due stili si notano di più, ma ovviamente sono presenti anche nelle scene.
(è un lavoraccio mappare :) come si deve però è bello.

Una domanda.. come ti sembra il mare?
L'ultima volta in un vecchio screen l'avevo fatto piatto, adesso come ti sembra?
E' importante :)

P.s: non ti ho risposto :P
il title screen avevo pensato di lasciarlo semplice così come lo vedi..

con aggiunta la finestra del menu n_g, continue, ecc
questa apparente semplicità è voluta perché il resto del gioco è ricco di cosette. Quindi lascia intendere tipo la calma prima
dello 'scatenate l'infernoo'.

Qui non ho come, ma è accompagnato da una musichetta docile, un pizzicato di chitarra e rumori ambientali tipo cinguettio di uccelli.

Il tutto perché deve infondere calma tranquillità

per quanto riguarda la cornice del title è usata solo lì, in quell'immagine.
Non è altro che contorno nero dove ho applicato su di esso 'effetto mosaico' nulla di più minimale. :)
In origine l'effetto mi piaceva.

La A con il punto luce proprio su di se è pura simbologia commerciale :)

March 9, 2018

http://i65.tinypic.com/ab4hdx.png
Spero di essere migliorato rispetto al lontano 2007.. :)
Fatemi sapere che ne pensate

In alto immagine utilizzata per lo scene_title.
Qui sotto la rappresentazione dell'idea che avevo in testa per una scena del mio gioco:
http://i66.tinypic.com/23woghh.png
E per concludere il reso finale sempre della medesima scena:
http://i63.tinypic.com/2v1vssp.png

January 1, 2018

Ciao Username buon anno.
Dunque tempi fa scrissi un tutorial a riguardo:
http://www.rpg2s.net/forum/index.php/topic/19987-charaset-a-piu-frames-camminata-a-otto-direzioni/

e per i più pigri postai per sino lo script analogo

http://www.rpg2s.net/forum/index.php/topic/20876-controllo-charaset-rmxp-autore-lomax-iced/

Con queste nozioni si ottiene piena consapevolezza sulla modifica dei frames e delle pose
che compongono il charaset, permettendo al programma di accettare modelli di qualsivoglia natura.

December 25, 2017

internet è stato MOOLTO più utile di qualunque insegnante

E ti pare niente?!

Posso dire che anche io ho appreso molte cose da internet, ma adesso in età adulta, quindi tardi.

Invece è un bene che per voi non è così. Anche perché potete fin da subito iniziare a sperimentare (tornando in topic ad esempio) progetti di traduzione di giochi, ebook, video-tutorial e programmi in un periodo in cui comunque avete modo di organizzarvi meglio i tempi e il tempo libero.

Che credetemi fa molto. Per un trentenne (a patto che non lo faccia per lavoro) trovare il tempo di intraprendere la traduzione anche di un solo gioco, è nettamente complesso, perché deve fare i conti con le ore di lavoro e/o di studio (esami universitari ecc).

Per questo ritengo che voi siete molto più fortunati, perché avete avuto i mezzi per poter apprendere prima e bene. Da non sottovalutare quel 'prima'. E' molto importante.

Immaginate, fra qualche anno, se appassionati, potreste fare questo di mestiere..curare le traduzioni.

E avrete già un buon bagaglio di esperienza che potrete solo affinare.

Io non riesco manco a finire un tutorial e arranco cercando di ritagliarmi piccoli pezzettini di tempo libero, quando non mi sento particolarmente stanco. xD

Pertanto reputo la tua un'ottima iniziativa che serve principalmente alla tua esperienza e poi in secondo luogo a chi come me è un asino in inglese

December 25, 2017

credo che sia una cosa generazionale.
Nel senso che voi (intendo voi carne fresca xD) siete più avvantaggiati perché magari nelle vostre scuola esiste un programma migliore per favorire l'apprendimento della lingua inglese e poi siete ulteriormente avvantaggiati per l'uso di internet che comporta maggiore fruibilità di contenuti multimediali.
soprattutto stranieri.

Intendo che fin da piccoli siete stati abituati all'apprendimento delle varie lingue straniere o comunitarie.
Invece..

Noi trentenni o quasi o più quando avevamo la vostra età non avevamo l'ausilio dei vostri stessi canali e quindi basavamo tutto sull'insegnante oppure su qualche videogioco o traduzione dei testi delle canzoni che spesso o traducevamo noi tramite l'uso di dizionari (altro che google) oppure chiedevamo a chi sapeva.

E spesso chi sapeva masticare quel tipo di lingua aveva avuto senz'altro una brava insegnante che era riuscita a far appassionare i propri alunni alla propria materia, la maggior parte invece no perché in aula alla cattedra vi erano solo cani dell'insegnamento.

December 24, 2017

O.O si ti prego 1000 volte si.

December 17, 2017

ohi Ri.. mi è capitato di sentire sta canzone e pensare al tuo game. Immagina .. titoli di coda.. e in sottofondo questo stile underground: https://www.youtube.com/watch?v=DUvqhNU2kis Te l'ho postata solo perché è a tema con la storia di Eric.

December 13, 2017

Quando Eric è in sembianze femminili e va a dormire per la prima volta perché stanco di ricevere avance, sogna e si trova in un posto dove ci sono mostri. tra cui uno che lo segue. Ecco quel Chara del mostro aimé cambia aspetto perché evidentemente il suo template è sprovvisto delle pose apposite. Magari uno può giustificare la cosa come per dire "è un sogno e quindi ci può stare che un mostro cambia aspetto" però un conto è che lo fa mostrando la camminata corretta, sincronizzando movimento e direzione e un altro è che cammina pur continuando a mantenere la posa frontale.
E sta cosa stona un po. Ovvio che lo so che è perché manca la risorsa apposita. Se trovo tempo vedo se posso realizzarti il chara ma tu intanto se vuoi e non aspettare troppo a lungo me, prova a chiedere anche ad altri se sono disposti a realizzartelo oppure se sei brava a disegnare prova tu.

Fino a qui ho apprezzato tutte le modifiche e gli errori corretti. Ho notato che hai spostato il pub, modificato l'aspetto del protagonista, dato corpo a certi dialoghi e il tipo vicino al lago che dice cose no-sense xD. Se posso darti un consiglio, quando parte la ricreazione e ancora Eric deve incontrare la tipa, si presume che la ricreazione sia intorno alle 11? beh già a quell'ora le strade dovrebbero essere più popolate, altrimenti non si spiega l'assenza degli abitanti eccetto che sempre i soliti due.

Ad ogni modo ottima l'idea di lasciare il pub aperto (senza porta) ma fare dire ad Eric che deve recarsi a scuola.
Ottimo. Beh continuo a proseguire nella storia.

Ho una domanda che mi affligge.. anzi sono tre.
Quanti anni ha Eric?
Quanti anni ha Tom?
E quanti anni ha Sarah??
no perché.. beh..

December 10, 2017

Ora, non sono sicuro che questo sia il contesto giusto, però "erase_event" ha il problema che, se uno rientra nell'abitazione, l'evento è di nuovo lì. Quindi, anche se è meno immediato, penso sia più adatto un local switch.

Si esatto. In poche parole River1 quando si programma qualcosa occorre tenere in considerazione tutte le possibilità che si lasciano a disposizione all'utente,anche se si vuole sviluppare il tutto in un contesto lineare, anzi soprattutto.

Anche perché è il redattore che decide, in questo caso quale libertà può avere il giocatore e quale no. Se vuoi dare l'illusione ad esempio che impersonando Erik il giocatore ad un certo punto della storia può effettuare una scelta ma che in realtà a livello di programmazione non c'è differenza perché la storia è comunque lineare, allora è consono mascherare la cosa e quindi è molto utile che tu segua la demo di Alkasel per imparare bene l'uso dei local switch.

E ti si apre un mondo e poi ti fo vedere come ti divertirai letteralmente a creare incastri di elementi molto più articolati. :)

December 10, 2017

Ciaooooooo sabato sera concluso alla grandeeeeeeee e non ho sonno pertanto
un nuovo game in pasto. gnam! Cercherò di essere più betatester possibile in modo che tu possa imparare dai tuoi errori, che per la maggior parte delle volte sono dovuti alla distrazione, quindi non ti allarmare se ne troverò qualcuno, anzi prendilo come qualcosa di positivo. Così puoi correggerti e alla fine realizzare un prodotto ancora più bello. (non oso immaginare a quanti errori babbi avrò fatto io nel mio game, spero di ricevere lo stesso trattamento un giorno) Comunque bando alle bande e inizio subito dal primo!

Mi trovo schermata del titolo che benché semplice, la scelta della skin è molto bella e il background è fantastico, pertanto scene_title passato bello.
Schiaccio New_Game e mi catapulto a casa di Erik, cerco di uscire dalla stanzetta e si apre un evento che descrive la situazione del personaggio..
PERO' ATTENZIONE qui sta il primo errore di distrazione.

Se io non esco dalla stanza di Erik e decido di rimanere per controllare che in camera vi siano oggetti da utilizzare nell'inventario e quindi una volta accertatomi che non ce ne stanno, torno verso l'uscita della camera e riparte l'evento in loop tutte le volte che Erik passa sopra l'evento.

Dovresti mettere a conclusione del messaggio di scorrimento un erase_event così non ti ricapita il loop continuo e incessante ogni qualvolta passi da quel tile. oppure una seconda pagina evento in richiamo con uno switch in modo che se passi da lì non accade nulla. Ma fra i due suggerimenti l'erase_event penso sia la soluzione più immediata. Alkasel o altri correggetemi se sbaglio.

Bene dopo aver parlato con la tipa che mi esortava a correre a scuola perché appunto Erik era in netto ritardo (sembra la storia della mia adolescenza perennemente in ritardo e l'avevo sotto casa) comunque mi sono fatto un giro per la città. Ottime le passabilità, carina la mappa, un utilizzo delle risorse standard buone, però un piccolo accorgimento anche se a quanto pare voluto
Anche perché questa cosa viene spiegata dal più figo, però anche se giustificata se posso darti un consiglio essendo una città anche se è mattina presto cerca di popolarla un po di più.. un fattorino, un panettiere, qualche lavoratore.. oppure qualche animaletto.. popolala altrimenti sembra troppo desolata eccetto il bidello e il figo.

Poi un'altra cosuccia però credo che sia dovuta in base all'età (penso che tu sia giovane), cerca di diluire il concetto principale della storia o meglio cerca di spiegarlo ma non con le parole nelle descrizioni ma nelle azioni dei personaggi. Cioè fai in modo che sia il giocatore a rendersi conto che Erik è un ragazzino un po bullizzato poiché tanto si capisce.

Poi sempre stilisticamente parlando il face dell'unico compagno di scuola che si vede presente in aula, sembra troppo vecchio, a meno ché non sia un serale.

E poi la tipa all'ingresso. Abbiamo in quel caso lì un evento che si ripete in loop e quindi così si scopre che aldilà della scelta che si compie il risultato è sempre lo stesso. Quindi la soluzione è semplice e consiste nello scegliere uno dei due modi:

1. O sempre con un erase event una volta che si sceglie una delle quattro risposte e la tipa risponde tu ci appioppi sotto l'erase
e l'evento si conclude e non si ripete più all'infinito.

2. O dai un risultato diverso per ogni scelta effettuata articolando di più la condizione fork.

SONO UNA DONNA!!! xD
ahah ora mi tocco le t***e come Taki xD
No invece anche qui stesso discorso.. l'evento gira in loop continuo. correggi tutti questi tipi di eventi che si dovrebbero ripetere solitamente una volta sola e invece qui girano ad ogni passaggio sul tile corrispondente.

Bene il gioco tratta di un disagio esistenziale stra e stra e stra ripetuto come se i personaggi siano quasi mono tematici per intenderci come quelle persone che parlano solo di calcio oppure comunque solo di qualcosa, oggi giorno sempre. e tutti nella storia enfatizzano questo tipo di concetto. Che ripeto è monotematico e ripetuto troppo spesso.

Come se tutto è un'esortazione all'aspetto esteriore positivo e il ragazzino magari timido e introverso no.
no riesco ad immedesimarmici. Anche perché a quanto pare questa città è popolata da pervertiti, lumaconi, gente frivola e persino la madre dimostra una certa pochezza intellettuale, nel dare priorità all'aspetto esteriore della ragazza una volta che se la ritrova in casa, piuttosto che allarmarsi della scomparsa del figlio o comunque dell'apparizione di questa estranea in casa propria.

Una cosa che ho notato è che non si riesce a capire il contesto temporale. Quando è giorno quando è notte quando arriva il momento di andare a nanna e quando è mattina. Poi questa scuola è popolata da gente di tutte le età anche decrepita.

Ovviamente è uno stile quasi satirico e credo che mano a mano che io vada avanti nella storia questo lo diventi sempre più.
Quasi canzonatorio. Divertente ovvio. Però.. diciamo che l'idea è bella, va migliorata, sviluppata, corretta strutturalmente.
Ha del potenziale, anche perché anche se i dialoghi sono semplici, esprimono comunque le emozioni di chi si è trovato ad effettuare questi tipi di ragionamenti in base alle esperienze che ha vissuto.

Senza dilungarmi oltre penso che come base di partenza sia un bel progetto, ma va sviluppato e redatto adeguatamente.
Inserendo dei dialoghi corposi, dei contesti ricchi di elementi, dei personaggi ben caratterizzati e coerenti in rappresentazione grafica.

Responso Finito. Spero possa spronarti nel migliorare sempre di più.
Non esiste il tutto bello e il tutto brutto. Tutti siamo sia belli che brutti
pregi e difetti, capaci in qualcosa e un po meno in qualcos'altro.
Siamo tutti tutti tutti tutti fatti. no siamo tutti e dico tutti fatti così.
E non si scappa. Femmine, Maschi, Elfi Darw tutti
Spero che reputerai queste mie critiche poste nello spoiler costruttive.
E attendo con ansia che questo diventi un bel progetto. Buona domenica :)

December 9, 2017

m.. Bella correzione. chissà quale sarà il codice da usare per permettere al sistema di puntamento di calibrare i margini.
Al momento non posso cimentarmi e finita questa serata sono quasi certo che me ne dimenticherò.. maa comunque sia
faccio i miei complimenti ;)

November 19, 2017

Si l'idea che più mi ha fatto comprendere questi concetti è stato appunto capire come bisognava impostare lo schema partendo da uno stile realistico, quindi andando a spulciare qualche nozione di anatomia e poi pian piano capire come stilizzarlo ad un modello manga. Perché comunque i faces utilizzati nei giochi, per la maggiore hanno quei tratti lì.

Quello che ho postato sino ad ora altro non è che il "come realizzare i modelli degli schemi" che servono appunto a suddividere il viso in zone e poi successivamente andando nel dettaglio quindi andando a trattare quelle zone nello specifico (occhi,naso,orecchie,bocca,collo) poi li avverrà la diversificazione di stile.

Quindi farò vedere come realizzare ad esempio un occhio realistico mostrato da te in figura2, quindi che assume quella forma lì. Io intendo spiegare e illustrare lo schema proporzionale che aiuterà l'utente a disegnare correttamente e rapidamente quella forma, aiutandosi sempre con le diverse forme geometriche guida. E questo gli servirà finché non diventerà bravo, oppure semplicemente avrà (come me) un template con i modelli a portata di mano e poi li usa all'occorrenza copia/incollando (ma le sue stesse risorse). Poi finito il comparto realistico, passerò ad illustrare le varianti stilizzate utilizzate per la maggiore nei manga.

Siccome per esempio in RPGXP si usano molto, quello è l'obbiettivo. (almeno per me, perché voglio realizzare nel mio gioco personaggi che hanno quel tipo di grafica. Ma voglio che sia mia e non rip di qualcun'altro, cioé voglio imparare, c'avevo sto desiderio da tempo,in passato non avevo la forma mentis e ora mi son detto stop è arrivato il momento. vai.) E li sono andato giù di RichardHtt, MarionettaMatta, Altri di cui non mi ricordo il nome, Stranieri italiani, tizi che disegnavano in stile sexy a me serviva solo per capire le differenze fra corporatura femminile e maschile, ma quel tipo chissà che ** si faceva con quei disegni xD comunque.. Mi sono visto tizie tipo Kawaii che parlavano tutte con la vocina cartunesca stile maid che odio ma ho dovuto! per la volontà di apprendere! Però un tizio è riuscito con i suoi tutorial a farmi comprendere meglio. Credo il più serio anche perché è andato giù dritto di anatomia. E veramente se mi ricordo il suo nick di youtube, metto anche i suoi tutorial, Disegna in realistico però è bravo, nel senso che si fa capire.

E le mie spiegazioni seguono molto quell'impronta. Perché sono riuscito a capirlo io che sono un tordone in ste cose e penso che sia il metodo giusto.

Per la mascella neanche a me convince infatti credo che si per lo più un errore di mio tracciato. vedo un po focalizzando meglio la cosa.
Invece tornando al discorso del saper distinguere i due stili realistico e stilizzato (per chi ci sta seguendo) occorre capire come si disegnano correttamente gli occhi,naso,bocca,"orecchi"e vabbe il collo pure ma è per un altra questione.

Ad esempio tua figura2 per gli occhi, io già individuo subito questo schema:
http://i66.tinypic.com/2r7u3gw.png

Ormai mi sono abituato a vedere le cose tracciando schemi. Quindi mi riesce molto facile.
Infatti i miei errori lo vedo che sono stupidate che potrei evitarmi tipo che ne so.. ora lo vedrete con una posa più avanti che non mi riesce bene.

Da lì poi mi traccio la forma delle palpebre..
Ma sto anticipando robe.. e poi la gente interessata si perde. C'è tanta roba interessante pian piano pian piano

Boh ti faccio vedere soltanto un mio disegno che ti giuro lo fisso di continuo mi ci perdo e mi fa pensare che non non posso averlo realizzato io
mi sembra bello, poi non lo so.. non è niente di che ma a me piace. ed è "Lo sguardo della motociclista"
http://i65.tinypic.com/53qo8l.png
L'ho realizzato perché volevo esercitarmi nel mettere in pratica le regole (tratto realistico) dello schema per realizzare dei corretti occhi in visuale laterale (ci arriveremo, sto spoilerando, perché so gasato, ma ora reset..e torniamo a seguire il tutorial poco alla volta altrimenti si crea un pure di patate e non ci si capisce più) xD

Vado a vedere la mascella e do volume al tutorial della visuale frontale dal basso verso l'alto. :)

November 19, 2017

Intendevo più come visuale che come inclinazione, cioè ci possono essere 3/4 con testa inclinata, ecc... XD
Meglio, più varietà, nulla impedisce di usare diverse inclinazioni anche basandosi sul carattere dell'npc.
^ ^

Ah, quindi impari e riporti! Bene! XD

Se hai qualche testina finita puoi anche postarla come promozione in alto per dare un esempio di "come verranno a tutorial finiti" o per ricevere consigli/mostrare la tua arte...
^ ^

AGGIORNATO il TERZO STEP! :)

Ehm no. non sono un cane da riporto. Mi piace condividere perché ai tempi non cerano tutte ste guide e io non sapevo fare una cippa.

Nulla zero. Mi spulciavo le guide di qui le poche guide (anno 2007) e chiedevo qualche consiglio a voi e mano a mano piano piano ho imparato

anche usando molto acume e ingegno. Quindi adesso mi piace condividere. Perché penso che ai miei tempi non c'erano tutte questi tutorial, ai miei tempi c'erano gli sportelli aiuti veloci che dovevi pregare il santo e Neji rispondeva alla domandina rossa. Ai miei tempi si viveva peggio ma si stava meglio xD Ricambio il favore e poi mi va a tempo perso e ne approfitto per esercitarmi e ripassare cose.

La posterò in sezione Scarabocchi di lomax come mie realizzazioni finite. Ho intenzione di realizzare pose diverse di Aluxell di RPGXP per iniziare.

E poi mi dedicherò a rifare i personaggi del mio game e quelli non ve li posso ancora mostrare (sempre per quel discorso di auto critica e anche perché mi devono convincere al 100% prima di pubblicarli xD)

Quindi per adesso accontentatevi degli esempi che poi non sono altro che i miei tentativi di esercizio. Li mostro volutamente gli errori che commetto ancora o dei disegni che per me sono okay. Li posto perché così potete visionare e magari non cadere nei miei errori (anche di valutazione) e stup.

Invece dovrei postare anche la visione frontale del face visto dall'alto verso il basso. Ho tutto pronto, devo solo pubblicarlo e scrivere il tutorial.

Molto probabilmente riprenderò il tutorial "visione dal basso verso l'alto" perché devo aggiungere delle spiegazioni che al momento non posso aggiungere (due compleanni in famiglia e sono in ritardissimo xD) devo fare 30 km di autostrada! per essere lì a pranzo e... caz..è l'una e un quarto! O.O""""

November 19, 2017

Ciao Flame :D

Dunque @ Guardian si lo so lo so il 3/4 è sempre il 3/4 è rende molto ma fidati ho imparato a fare pose di faces troppo fighe.
Tipo inclinazione della testa in visuale dal basso/ stessa cosa ma in visuale dall'alto. Ovviamente non mancano i 3/4 che vedremo a breve e tutte le varianti annesse, cioè quelle pose particolari di inclinazione della testa che normalmente non si trovano ma che risulterebbero fighe da portare in un progetto. .

Adesso (dovrei fare la cucina che ho lasciato uno schifo sul lavello ma..), si perché no, proprio ora preparo testa rivolta in alto e testa rivolta in basso. così concludo con il comparto frontale. poi un'altra volta passerò alla visione profilo e tutte le varie varianti che ho imparato. aspetta fatemi consultare il mio mastodontico template da 474kb xD (dove ho raggruppato tutti gli schemi delle diciotto pose. Premetto non ne esistono solo diciotto, ce ne sono di più, ma io sono arrivato in 24 ore a disegnarne diciotto poi mi sono stancato e mi sono dedicato ad altro.

Finite le pose dei faces, voglio spiegare dettagliatamente come si disegnano gli occhi, il naso la bocca le orecchie in modo proporzionato e poi stilizzato.

Dopo ci sarà un altro periodo di silenzio, tempo di imparare a disegnare le pose del corpo per disegnare i battlers o Quelle pictures che ritraggono i personaggi a mezzo busto I(sono proprio fighe). E quando avrò appreso quel tipo di tecniche vedo di farci un altro tutorial a riguardo.

@Flame:
Cosa non ti torna? Se ho fatto qualche errore dimmi pure così miglioro.

Io comunque mi sono documentato tanto, mi sono seguito un casino di tutorial sul fumetto sia cose straniere che italiane stoppando e riavvolgendo i
-videi- un casino di volte perché cacchio si volevo imparare perché da sempre avevo sta cosa di volere sapere disegnare i faces fighi.

E sinceramente ho notato che alcune pose delle diciotto imparate le devo migliorare bene (quindi mi devo esercitare ancora tanto anche se ho capito la parte teorica) altre invece wow le guardo e mi viene da pensare "cavolo non è possibile che l'abbia disegnato io" cioé no veramente non mi interessa vantarmi anche perché sono molto critico delle mie opere. Però alcuni resi a me personalmente mi hanno lasciato a fissare quei disegni per ore. Ora nei giorni a seguire posterò un po tutto. Sia ciò che reputo wow e sia quei disegni di pose che secondo me devo ancora esercitarmi bene.

Però le tecniche sono quelle lì, quindi magari se per me una precisa posa non mi dovesse riuscire ancora, magari qualcun'altro tac gli riesce a primi tentativi. E ovviamente aperto a ricevere critiche in tutti i "disegni esempio" che condividerò, anche quelli che reputo wow. che magari lo sono per me, ma può essere che magari un occhio più esperto può darmi qualche dritta per migliorare.

Pertanto ribadisco la domanda: Fle. cosa non ti torna? :) Dì tutto

November 18, 2017

Si Guardian. Infatti ho già aggiunto nuove nozioni nel TERZO STEP ho implementato la Posa frontale con inclinazione della testa di lato, in entrambe le due direzioni.

Voglio precisare che i modelli sono schemi di input che fungono appunto da guida, seguendoli possiamo caratterizzare personaggi di qualsiasi tipo e stazza. o genere. per esempio una volta in fase di caratterizzazione se vogliamo fare un Naso esile o paffuto lo si può cambiare purché rimanga dentro la sua zona di collocazione, quella delineata dalle due assi viola (o fucsia non mi ricordo di che colore le ho fatte).

In tutto mi sono ricavato diciotto schemi con queste impostazioni, quindi significa diciotto pose diverse e intendo ovviamente illustrarle (si spera) tutte, tempo e impegni permettendo e connessione internet (ho sempre avuto un brutto rapporto con internet :( )

Una cosa che mi preme assolutamente fare è spiegare come si disegnano gli occhi, il naso, la bocca e le orecchie,, che esistono delle forme standard utilizzate sempre anche nei faces di rpg maker che già conosciamo. Ed è simpatico andare a rivederli e capire che non sono stati realizzati a muzzo ma hanno seguito un criterio preciso.

E lo smontare questo criterio mi permette e vi permetterà di smontare quella loro complessità che tanto destava l'individuo da destare nell'impresa di
disegnarne uno in stile rpg maker o semplicemente di ricavare altre pose dei faces che già esistono in circolazione. Intendo con la stessa qualità e stile. Oppure disegnarne uno proprio con uno stile diverso ma fatto bene.

(Inizio piccolo OT)
Spesso le mie pause lunghe sono dipese dagli impegni lavorativi incessanti oppure da una mancanza di internet o mancato servizio di linea che mi fa ripassare tutte le parolacce greche e turche in ordine alfabetico. Quindi quando manco per tanto tempo e dipeso da questo e se lascio dei progetti in sospeso non me ne vogliate, piano piano li completerò non li ho dimenticati (fine piccolo OT)

November 18, 2017

Benvenuto.

November 18, 2017

Fatto. Grazie Lusianl

Sign In

Lomax_Iced

Posts

Joined

Last visited

Content Type

Profiles

Forums

Calendar

Posts posted by Lomax_Iced

Come creare un pianeta o una luna

Come creare un pianeta o una luna

Mettere Finestre ovunque :)

Creazione di una scena

*GINO_CharaZoomingEffect XP

*GINO_CharaZoomingEffect XP

I vostri screen MV

I vostri screen MV

I vostri screen MV

I vostri screen MV

Modifica del movimento

Traduzioni italiane di giochi RPG Maker

Traduzioni italiane di giochi RPG Maker

Traduzioni italiane di giochi RPG Maker

__________

__________

__________

__________

Problema rendendo la risoluzione responsive...

Tutorial: Tecniche per disegnare da 0 Faces in qualsiasi visuale

Tutorial: Tecniche per disegnare da 0 Faces in qualsiasi visuale

Tutorial: Tecniche per disegnare da 0 Faces in qualsiasi visuale

Tutorial: Tecniche per disegnare da 0 Faces in qualsiasi visuale

Mi presento!

Nuovi Brushes & Patterns (Pennelli&Textures) per Gimp 2.8

Browse

Activity