Come creare un videogioco? Quali tool e linguaggi utilizzare? Come impostare un nuovo progetto?
Ecco una panoramica e utilizzo dei motori più conosciuti per la creazione di videogiochi

Post in evidenza

Vendere il tuo videogioco, quali piattaforme usare?

Supponiamo abbiate sviluppato di giorno (ma soprattutto di notte) negli ultimi 12 mesi un gioco che vi sta particolarmente a cuore (vuoi per...

Visualizzazioni totali

Unity: uno sparatutto 2D per Android


Il mondo dedicato allo sviluppo di videogiochi è -fortunatamente- sempre in movimento. Anche il panorama italiano rispecchia questo andamento e nel post di oggi presentiamo un ottimo gioco creato con Unity e "made in Italy".
Starship Shooter la nostra navicella in azione

Parliamo di Starship Shooter, uno sparatutto 2D in classico stile fantascientifico per Android, pubblicato sul Play Store di Google dalla Laura Capone Editore e (cosa non da poco) totalmente gratuito.
Ideato e sviluppato in Italia utilizzando Unity, il gioco è compatibile con smartphone e tablet con un sistema operativo Android 2.3 o maggiore, così da garantire il più elevato numero di dispositivi su cui giocare.

Lo scopo del gioco è quello di sconfiggere le orde aliene di Alnitak che vogliono distruggere la razza umana, ma la vera sfida è sui comandi direzionali della propria nave spaziale, basati sull'inclinazione del dispositivo mobile.
Starship Shooter

Anche se è stato sviluppato con il motore Unity 3D, il gioco è totalmente realizzato in 2D (grazie alle librerie di Unity dedicate al mondo bidimensionale) e la resa è molto buona.
Per scoprire come è stato possibile realizzare questo tipo comando e per carpire qualche piccolo segreto implementativo, abbiamo intervistato l'autore, Mario Buonocore.

SV: Ciao Mario, complimenti per la pubblicazione del tuo gioco sullo Store di Google.
Abbiamo provato "
Starship Shooter". La navicella viene mossa utilizzando l'inclinazione del dispositivo mobile. Idea originale. Ma come l'hai implementata con Unity? Puoi svelarci qualche piccolo segreto?
MB: "Grazie a voi per il post e per i complimenti. Ho utilizzato il vettore tridimensionale Input.acceleration, che misura l'accelerazione lineare di un dispositivo mobile.
L'asse x e l'asse y del vettore mi sono servite per capire rispettivamente il movimento orizontale e verticale che si vuole far compiere alla nave spaziale, mentre l'asse z mi è servita per capire se il dispositivo è rivolto a faccia in su o a faccia in giù, ad esempio se gioco mentre sono disteso sul letto, poichè se il dispositivo è rivolto verso il basso bisogna negare la componente x."

Starship Shooter un livello in azione
Starship Shooter un livello in azione
Ecco un esempio con C# su Unity.
private Vector3 AdjustedAccelerometer ()
{
    Vector3 acceleration = Input.acceleration;

    //if device is face down, x acceleration is reverted
    if (Input.acceleration.z > 0)
        acceleration = new Vector3(-acceleration.x, acceleration.y, acceleration.z);

    return calibrationMatrix.MultiplyVector(acceleration);
}

SV: Nel codice parli di "matrice di calibrazione", ci puoi spiegare cosa intendi?
MB: "La matrice di calibrazione mi serve per impostare il punto di riposo dell'accelerometro, altrimenti se voglio che la mia nave spaziale stia ferma dovrei assumere una posizione poco comoda con il mio smartphone, ovvero come se fosse appoggiato su un tavolo: invece una posizione comoda prevede che lo schermo dello smartphone sia rivolto verso il mio viso, quindi leggermente inclinato, e quello deve essere il vero punto di riposo, che viene impostato ad inizio livello in questo modo:"

void Awake ()
{
    calibrationMatrix = Calibrate(Input.acceleration);
}

......

public static Matrix4x4 Calibrate (Vector3 acceleration)
{
    Quaternion rotate = Quaternion.FromToRotation(new Vector3(0.0f, 0.0f, -1.0f), acceleration);
    Matrix4x4 matrix = Matrix4x4.TRS(Vector3.zero, rotate, Vector3.one);
    return matrix.inverse;
}

MB: "A questo punto, il nuovo vettore tridimensionale creato dal metodo AdjustedAccelerometer() è quello che viene usato per modificare la proprietà Transform.position del game object che rappresenta la nave spaziale."

SV: Grazie e ancora in bocca al lupo!!
MB "Grazie a Sviluppare Videogiochi per l'articolo."

Vuoi provare a fermare l'invasione Alnitakiana e salvare la razza umana?
Scaricalo dallo Store di Google per scoprilo.
Buon divertimento con Starship Shooter.

Starship Shooterun 2D realizzato con Unity 3D

Riferimenti
- Laura Capone Editore: http://www.lauracaponeeditore.com
- Mario Buonocore: https://www.linkedin.com/in/mario-buonocore-55141b8
- Scaricalo da Google Play Store: https://play.google.com/store/apps/details?id=com.lauracaponeeditore.starshipshooter

Avventure testuali: iniziare con Inform 6 e Inform pack


Infom è un linguaggio di programmazione (vagamente simile al linguaggio C) dedicato alla creazione di avventure testuali (in realtà si può utilizzare anche per altri scopi, anche se ha a disposizione alcune sintassi che agevolano la scrittura di narrativa interattiva).

Interactive Fiction o narrativa interattiva


Cos'è un'avventura testuale

Avventura testuale (o narrativa interattiva) è un genere di gioco molto conosciuto a partire dalla fine degli anni '70 che prevede l'interazione con il giocatore tramite comandi inseriti da tastiera. Ad ogni comando viene mostrato l'esito e la situazione all'interno del gioco, dando al giocatore l'impressione di avere una libertà di azione quasi totale. Anche se il genere ha avuto la sua massima espansione dopo gli anni 80 ha poi avuto un periodo di stallo e di minor popolarità (dovuto soprattutto alla nascita dei primi videogiochi su console e su PC che potevano utilizzare grafica e suoni e aumentare l'impatto visivo del giocatore).


Little Falls: un mystery case di narrativa interattiva


Negli ultimi anni, però, si è registrato una sorta di "ritorno alle origini": molte avventure classiche sono state riproposte al giocatore degli anni 2000 e molti di questi giocatori hanno subito il fascino della narrativa.
Anche se non è un genere con vendite o interesse da capogiro, si è ricavata una nicchia nell'universo vidoludico, e riscuote ancora oggi una buona popolarità.

Cos'è Inform

Un linguaggio di programmazione ed un sistema di sviluppo di avventure testuali, creato nel 1993 da Graham Nelson. Ha subito varie modifiche fino ad arrivare alla verione 7.
Per gli scopi di questo post (e di altri che verranno) faremo riferimento alla versione di Inform 6 perchè è stata largamente testata e usata nel corso degli ultimi 10 anni dalla comunità di narrativa interattiva e perchè dispone di una libreria tradotta in italiano molto stabile. Libreria in italiano significa che è possibile creare giochi testuali completamente in italiano ed in grado di gestire comandi in lingua italiana digitati dal giocatore.
Principali comandi in una AT (Avventura Testuale)

Cos'è l'inform pack?

L'inform pack è una collezione di programmi e librerie per poter iniziare a programmare con Inform senza impazzire dietro a configurazioni o versioni particolari degli applicativi da utilizzare. E' un semplice file compresso (zip) che contiene tutto quello che serve. E' una distrubuzione non ufficiale, che permette di iniziare subito ad utilizzare questo linguaggio: vediamo come.

Come utilizzarlo
In questo post vedremo come scaricare l'inform pack, compilare un esempio di avventura e come eseguire l'avventura di esempio sul proprio pc. In questo caso si suppone che il sistema operativo sia Windows (anche se è possibile ovviamente avere gli stessi applicativi anche su Linux con un po' di lavoro sporco sulla shell).
Inform Pack per iniziare a sviluppare con Inform 6
All'interno del pacchetto sono stati predisposti e configurati i 2 editor per scrivere codice Inform: wide e JIF. Wide è un editor scritto in C++ mentre JIF è un'applicazione Java (quindi per eseguire quest'ultimo programma è necessario avere installato JAVA).
  1. scaricare e scompattare il file informpack_1.6.zip, scaricabile qui
  2. eseguire il file "wide.exe" all'interno della cartella bin 
  3. menu "Project -> Open Project" e aprire il file /esempio/esempio.wpf (file di testo in formato "wide project file")
  4. a questo punto wide dovrebbe aver aperto in automatico 3 file ("esempio.inf", "esempio_game.inf" e "esempio_menu.inf") che sono sorgenti scritti in linguaggio Inform. Li ha aperti perchè all'interno del file "esempio.wpf" abbiamo indicato quali sono i file sorgenti appartententi al progetto stesso.
  5. Cliccare sull'icona "compile in z-code" (alla fine del processo, nella console di LOG si dovrebbe vedere un messaggio tipo: "Compiled with 1 Warning, OK" che indica che la compilazione è andata a buon fine. Nella cartella dei sorgenti verrà creato un nuovo file "esempio.z5" che contiene il gioco in formato zcode.
  6. Il gioco esempio.z5 può essere aperto utilizzando un inteprete zcode qualsiasi. Per eseguirlo direttamente da wide (dato che l'inform pack contiene tutti gli strumenti di sviluppo Inform) è possibile eseguire l'icona "running zcode": verrà eseguito l'interprete configurato nel file wide.ini e verrà eseguita l'avventura testuale "esempio.z5" appena creata.
  7. Verrà aperto l'interprete predefinito che metterà in esecuzione l'avventura testuale appena compilata

Step 4: Wide e il primo progetto di "esempio"

Step 5: compiliamo il nostro progetto in ZCODE

Step 6: eseguire l'avventura appena creata

Step 7: Interprete zcode in esecuzione con la vostra prima avventura testuale

Nei prossimi post vedremo nel dettaglio come utilizzare questo tool per creare un'avventura testuale originale.
Nel frattempo consigliamo di leggere i documenti presenti all'interno dell'inform pack perchè sono presenti anche i manuali ufficiali di Inform 6 (tra cui "The Inform Designer’s Manual" di Graham Nelson e il manuale in italiano di Vincenzo Scarpa su Inform "Come scrivere (e giocare) delle avventure testuali in Inform e Glulx").

Non mi resta che salutarvi e se l'articolo vi è piaciuto condividetelo sui vostri social preferiti !!!!


Android, creare una EULA da accettare



In generale una EULA (o End-User License Agreement) è un accordo di licenza tra il fornitore di un programma software e l'utente finale. In senso lato può rappresentare una sorta di elenco di avvertenze o accettazioni che l'utente finale decide di validare prima di installare un software.

Anche in campo videoludico è possibile elencare delle avvertenze in modo che l'utente finale (in questo caso il giocatore che ha scaricato un'app) ne sia a conoscenza.

End User License Agreement


In questo post vedremo come integrare facilmente un documento di EULA in modo tale che l'utente finale se non accetta i termini elencati, non possa lanciare la nostra app.
Il nostro esempio si applica facilmente anche ad app o giochi già completati, non è necessario applicarlo ad un programma ancora da sviluppare.

Seguire i seguenti passi:

  1. Aprite il vostro progetto con Android Studio (oppure create un nuovo progetto)
  2. Create una nuova classe Eula.java all'interno del vostro package e incollate il sorgente che viene riportato in questo post
  3. All'interno del metodo onCreate() della Main Activity del progetto, aggiungere la chiamata al metodo Eula.show(this);

Sorgente


/*
 * Eula.java
 * Sviluppare Videogiochi
 * https://svilupparevideogiochi.blogspot.it
 *
 * Modalità:
 * Visualizza una EULA "End User License Agreement" che l'utente deve accettare prima di eseguire
 * per la prima volta l'applicazione associata.
 * Se l'utente accetta i termini, la eula non viene piu visualizzata nelle successive esecuzioni
 * Se l'utente non accetta i termini, l'app viene chiusa
 *
 * Utilizzo:
 * 1) creare una classe Eula.java con questo contenuto, mettendo a posto il package corretto
 * 2) all'interno del metodo "onCreate" dell'app principale, richiamare il metodo Eula.show(this);
 */

import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.SharedPreferences;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;

class Eula {

    private static final String EULA_APP_VERSION = "app.version";
    private static final String EULA_PREFERENCE_NAME = "eula";
    private static final String EULA_PREFERENCE_ACCEPTED = "eula.accepted";
    protected static PackageInfo packageinfo = null;

    private static String testo = "End-User License Agreement for this game for Android\n"
            + "\nThis End-User License Agreement (EULA) is a legal agreement between you (either an "
            + " individual or a single entity) and the author of this Software for the software product "
            + " identified above, which includes computer software and may include associated media, "
            + "printed materials, and 'online' or electronic documentation (“SOFTWARE PRODUCT”)."
            + "\nBy installing, copying, or otherwise using the SOFTWARE PRODUCT, you agree to be "
            + "bounded by the terms of this EULA."
            + "\n\nIf you do not agree to the terms of this EULA, do not install or use the SOFTWARE PRODUCT."
            + "\n\nLIMITED WARRANTY\n"
            + "\nNO WARRANTIES.\n"
            + "\nThe Author of this Software expressly disclaims any warranty for the SOFTWARE "
            + "PRODUCT. The SOFTWARE PRODUCT and any related documentation is provided 'as is' "
            + "without warranty of any kind, either express or implied, including, without limitation, "
            + "the implied warranties or merchantability, fitness for a particular purpose, or "
            + "noninfringement. The entire risk arising out of use or performance of the SOFTWARE "
            + "PRODUCT remains with you."
            + "\n\nNO LIABILITY FOR DAMAGES.\n"
            + "\nIn no event shall the author of this Software be liable for any special, "
            + "consequential, incidental or indirect damages whatsoever (including, without "
            + "limitation, damages for loss of business profits, business interruption, loss of "
            + "business information, or any other pecuniary loss) arising out of the use of or "
            + "inability to use this product, even if the Author of this Software is aware of the "
            + "possibility of such damages and known defects.";

    public Eula() {
    }

    static private void getPackageInfo(final Activity activity) {
        try {
            packageinfo = activity.getPackageManager().getPackageInfo(activity.getPackageName(), PackageManager.GET_ACTIVITIES);
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
    }

    static interface OnEulaAgreedTo {
        void onEulaAgreedTo();
    }

    static boolean show(final Activity activity) {
        getPackageInfo(activity);
        final SharedPreferences preferences = activity.getSharedPreferences(EULA_PREFERENCE_NAME, Activity.MODE_PRIVATE);

        // Scommentare le seguente riga per mostrare la EULA ad ogni esecuzione dell'app
        // serve per testare il funzionamento
        // preferences.edit().putBoolean(EULA_PREFERENCE_ACCEPTED, false).commit();

        if (!preferences.getBoolean(EULA_PREFERENCE_ACCEPTED, false) || (!packageinfo.versionName.equalsIgnoreCase(preferences.getString(EULA_APP_VERSION, "")))) {
            final AlertDialog.Builder builder = new AlertDialog.Builder(activity);
            builder.setTitle("Licenza");
            builder.setCancelable(true);
            builder.setPositiveButton("Accept", new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int which) {
                    accept(preferences);
                    if (activity instanceof OnEulaAgreedTo) {
                        ((OnEulaAgreedTo) activity).onEulaAgreedTo();
                    }
                }
            });

            builder.setNegativeButton("Refuse", new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int which) {
                    refuse(preferences, activity);
                }
            });

            builder.setOnCancelListener(new DialogInterface.OnCancelListener() {
                public void onCancel(DialogInterface dialog) {
                    refuse(preferences, activity);
                }
            });

            builder.setMessage(testo);
            builder.create().show();
            return false;
        }
        return true;
    }

    private static void accept(SharedPreferences preferences) {
        preferences.edit().putBoolean(EULA_PREFERENCE_ACCEPTED, true).commit();
        preferences.edit().putString(EULA_APP_VERSION, packageinfo.versionName).commit();
    }

    private static void refuse(SharedPreferences preferences, Activity activity) {
        preferences.edit().putBoolean(EULA_PREFERENCE_ACCEPTED, false).commit();
        activity.finish();
    }
}

Screenshot risultante

EULA in azione su Android

Ovviamente siete liberi di utilizzare questo sorgente in qualsiasi progetto, potete modificarlo (o modificare il testo) a vostro piacimento senza restrizioni.

Se vi è stato utile, potete condividere il blog sul vostro social preferito. Grazie!

Musica per i vostri giochi: quali strumenti utilizzare?


Una componente importantissima di un prodotto multimediale o videogioco è rappresentata dal comparto audio (che riguarda gli effetti sonori e -soprattutto- la colonna sonora).
Se non siete compositori questo articolo è per voi (ma potrebbe sicuramente interessare chi la musica la crea direttamente).

Deflemask in esecuzione


Esitono molti tool (con licenza free o open) che consentono di creare colonne sonore più o meno automaticamente: in questa sezione prendiamo in esame i migliori tool con licenza open o free. E credeteci, alcuni di questi sono a livello di tool più blasonati e professionali.

Deflemask

Home: http://www.deflemask.com/
Licenza: donationware
Autore: Leonardo Demartino
Piattaforme: Windows, Linux, OS X
Descrizione: il migliore tool free per creare musiche per i videogiochi e che riesce ad emulare alla perfezione i chi audio "old style". E' possibile utilizzare un'interfaccia MIDI (tastiera) oppure direttamente la tastiera del pc (anche se non è il massimo della comodità). E' possibile creare e salvare i proprio suoni personalizzati e la resa è davvero impressionante. Se cercate una resa old style, questa applicazione è per voi. Su you tube sono presenti molti video-tutorial su come utilizzare questo splendido programma.

Deflemask



Supporta i seguenti soundchip:
  • YAMAHA YM2612 FM Soundchip
  • Texas Instruments SN76489 PSG Soundchip
  • Z80 Variant used by the Nintendo Game Boy
  • Hudson Soft HuC6280
  • Ricoh 2A03 APU
  • MOS Technology SID
  • YAMAHA YM2151 FM Soundchip
  • SEGA PCM

Supporta i seguenti Sistemi:

  • SEGA Genesis (Soundchip 1 + Soundchip 2)
  • SEGA Master System (Soundchip 2)
  • Nintendo Game Boy (Soundchip 3)
  • NEC PC-Engine/TurboGrafx-16 (Soundchip 4)
  • Nintendo NES (Soundchip 5)
  • Commodore 64 (Soundchip 6)
  • Arcade Machine (SEGA X/Y Board, Soundchip 7 + Soundchip 8)

In questo video si può capire quale tipo di musica si può "comporre".



Famitracker

Home: http://famitracker.com/
Licenza:GNU GPL license
Autore: jsr@famitracker.com
Piattaforme: Windows Xp e superiori
Descrizione: FamiTracker è un tracker per sistemi windows pensato per la produzione di musica in stile NES/Famicom-systems. L'interfaccia è basata su MadTracker ed è assolutamente analoga ad altri sistemi di tipo "trackers" (cioè basati su pattern ripetibili).

Famitracker, un tracker NES/FAMICOM per Windows

In questo video si può capire quale tipo di musica si può "comporre".




CGMusic

Home: http://codeminion.com
Licenza: n.d.
Autore: Maciej Biedrzycki
Piattaforme: Windows Xp e superiori
Descrizione: Questo tool a differenza degli altri soundtracker, consente di generare in moto totalmente automatico alcune melodie e di variarne i parametri. E' affascinante immaginare di poter generare musica totalmente casuale. Da provare.

Applicativo CGMusic


Conoscete altri tool?
Fateci sapere: continueremo ad aggiornare il blog anche con le vostre segnalazioni !!!

Urho3D, un eroe per gli sviluppatori di videogiochi in 3D


Urho3D (finlandese per "eroe" o "coraggioso combattente")  è un motore per la creazione di videogiochi 2D e 3D cross-platform completamente realizzato in C ++ e rilasciato sotto la licenza MIT.
A detta dei suoi autori è "ispirato" ai due motori OGRE e Horde3D (il primo sicuramente ben conosciuto dagli addetti ai lavori).

Non si può paragonare a colossi quali Unity 3D e UDK perchè non dispone di un ambiente completo di sviluppo ma è composto da una serie di librerie e un editor (ancora poco user-frendly in verità).
Anche se è un motore poco conosciuto, ad un primo impatto si intuiscono i suoi enormi potenziali (spinti dalla licenza MIT che viene incontro a tutte le esigenze dei team di lavoro).
Rispetto a Irrlicht o altre librerie ha molti punti di vantaggio:

Urho3D (fonte http://urho3d.github.io/)

  • inclusione di librerie non solo grafiche (audio, rete..ecc)
  • possibilità "nativa" di utilizzare linguaggi di scripting (come poteva essere LUA integrato manualmente nel motore base)
  • un vasto elenco di librerie di terze parti incluse nel motore
  • il motore è disponibile per quasi tutte le piattaforme esistenti (Windows, Linux, MacOSX, Android, HTML5)
Urho3D in azione - editor integrato


L'elenco di librerie di terze parti incluse è davvero lungo e consente di avere a disposizione un ambiente organico e completo per lo sviluppo di un videogioco:

  • AngelScript 2.30.2 (http://www.angelcode.com/angelscript/)
  • Box2D 2.3.0 (http://box2d.org/)
  • Bullet 2.83.6 (http://www.bulletphysics.org/)
  • Civetweb (http://sourceforge.net/projects/civetweb/)
  • FreeType 2.5.0 (http://www.freetype.org/)
  • GLEW 1.9.0 (http://glew.sourceforge.net/)
  • jo_jpeg 1.52 (http://www.jonolick.com/uploads/7/9/2/1/7921194/jo_jpeg.cpp)
  • kNet (https://github.com/juj/kNet)
  • libcpuid 0.2.0 (http://libcpuid.sourceforge.net/)
  • Lua 5.1 (http://www.lua.org)
  • LuaJIT 2.1.0+ (http://www.luajit.org)
  • LZ4 (http://code.google.com/p/lz4/)
  • MojoShader (http://icculus.org/mojoshader/)
  • Mustache 1.0 (http://mustache.github.io/, https://github.com/kainjow/Mustache)
  • nanodbc 2.11.3+ (http://lexicalunit.github.io/nanodbc/)
  • Open Asset Import Library (http://assimp.sourceforge.net/)
  • pugixml 1.5 (http://pugixml.org/)
  • rapidjson 0.11 (https://code.google.com/p/rapidjson/)
  • Recast/Detour (https://github.com/memononen/recastnavigation/)
  • SDL 2.0.3 (http://www.libsdl.org/)
  • StanHull (http://codesuppository.blogspot.com/2006/03/ john-ratcliffs-code-suppository-blog.html)
  • stb_image 2.05 (http://nothings.org/)
  • stb_image_write 0.98 (http://nothings.org/)
  • stb_vorbis 1.05 (http://nothings.org/)
  • SQLite 3.8.10.2 (https://www.sqlite.org/)
  • tolua++ 1.0.93 (http://www.codenix.com/~tolua)


In questo video è possibile vedere gli esempi principali in esecuzione.


Pro:
  • licenza MIT
  • presenza di un editor (anche se non evoluto come quello di Unity) 
  • costantemente aggiornato dagli sviluppatori
  • si può partecipare al progetto, presente su github

Contro:
  • E' richiesta una buona conoscenza C++
  • La documentazione non è ancora ai livelli di Unity o di Unreal

Riferimenti

http://urho3d.github.io/

Vendere il tuo videogioco, quali piattaforme usare?


Supponiamo abbiate sviluppato di giorno (ma soprattutto di notte) negli ultimi 12 mesi un gioco che vi sta particolarmente a cuore (vuoi perchè avete la passione per i videogiochi, vuoi perchè è il vostro primo videogioco creato da zero...).

Sia che si tratti di un casual game o di un gioco di più ampio respiro, prima o poi, arriva il momento di chiedersi se è possibile anche "venderlo" sul mercato.

Piattaforme di vendita
In realtà 2 punti dovrebbero essere molto chiari
  1. La piattaforma di distribuzione (soprattutto per giochi INDIE) dev'essere eventualmente scelta "prima" della realizzazione del gioco stesso
  2. Non è tutto oro quello che luccica (come gentilmente ci fece notare Robert Plant dei Led Zeppelin). Pochi sviluppatori indipendenti riescono nell'impresa. 
Detto questo, abbiamo cercato di analizzare tutte le piattaforme che (ad oggi) si possono utilizzare per questo scopo.
I due principali distributori per il mondo mobile sono Google Play (Android) e Apple Store (iOS): sebbene esistono anche altri distributori alternativi, questo post sarà focalizzato a giochi non dedicati al mobile.

Ecco il nostro elenco (in ordine alfabetico) che contiene solo le realtà odierne:

Itch.io


  • https://itch.io/
  • Giochi totali disponibili: 34544
  • Piattaforme: tutte
  • Metodo di approvazione: nessuno (a parte i termini condizioni d'uso)
  • Prezzo di vendita: si può scegliere (anche zero), si imposta un prezzo minimo
  • Commissioni:varabile (si può scegliere)
  • Tipo di pagamento: Paypal, Carta Credito, Bitcoin
  • Pro: uno dei migliori
  • Contro: nessuno

 

GOG


  • https://www.gog.com/indie
  • Giochi totali disponibili: 1547
  • Piattaforme: tutte
  • Metodo di approvazione: qualità (valutata dall'editor), asset devono essere originali
  • Prezzo di vendita: non si evince dal portale
  • Commissioni: non si evince dal portale
  • Tipo di pagamento: non si evince dal portale
  • Pro: alcuni aspetti non si evincono dal portale, quindi è necessario iscriversi e inviare le informazioni del videogioco per avere approfondimenti
  • Contro: non si può pubblicare un F2F (free 2 play) o giochi con micropagamenti, asset devono essere originali (non si possono usare asset anche free)


Steam Greenlight


  • https://steamcommunity.com/greenlight
  • Giochi totali disponibili: 7800 approvati da Steam Greenlight
  • Piattaforme: PC, Linux, MaxOSX
  • Metodo di approvazione: qualità (valutata dall'editor), il gioco non deve contenere materiale offensivo e non deve violare il copyright o i diritti di proprietà intellettuale
  • Prezzo di vendita: libero, ma l'editor consiglierà qual è il prezzo corretto da usare
  • Commissioni: 100$ iniziali (serve per ridurre lo spam e tale cifra viene devoluta in beneficenza), le commissioni sono oggetto di trattativa privata con l'editor (steam)
  • Tipo di pagamento: n.d. trattativa privata con l'editor (steam)
  • Pro: la piattaforma più conosciuta al mondo
  • Contro: la selezione è molto difficile, serve un account di steam e il client desktop, il gioco viene pubblicato solo se interessa la community o se è particolarmente bello (a scelta dell'editor)

Conclusioni

Le liste iniziali di publisher per videgiochi indie erano molto piu corpose qualche mese fa. Molte nel frattempo sono chiuse o hanno avuto problemi economici: quindi la lista che abbiamo proposto è di sole 3 publisher. Sicuramente quella più nota e solida è "Steam Greenlight" (una delle piataforme di gaming più diffuse al mondo) ma per questo motivo secondo noi è più difficile riuscire nell'intento di farsi pubblicare il proprio videogioco (soprattutto se indie).
D'altro canto "gog" è abbastanza "fumosa" in termini di documentazione (sulla homepage non abbiamo trovato alcune informazioni essenziali che invece sono presenti nelle altre 2 piattaforme).
Quindi (per progetti amatoriali e indipendenti) per noi la soluzione migliore è rappresentata da ITCH.IO, che sembra essere assolutamente indirizzata a piccole realtà indie a partire dal numero ridotto di vincoli e dalla possibilità di scegliere sia il prezzo di uscita del gioco che le eventuali commissioni che verranno versate alla piattaforma.

Vi invitiamo a commentare il post o a segnalarci altre piattaforme che possono aiutare a pubblicare videogiochi da parte di realtà indie.


Riferimenti
http://www.pixelprospector.com/the-big-list-of-indie-game-marketing/


Unity: Come usare la classe Resources caricando asset dinamicamente senza impazzire


Anche se uso, sperimento e creo prototipi con Unity3d da più di un anno e mezzo, non ho mai avuto necessità di caricare degli asset dinamicamente a runtime.

Dal principio sono stato ingannato dalla semplicità dei metodi di System.IO che hanno funzionato da subito, perfettamente, nell'editor.

Metodi SYSTEM.IO usati:

// check if resource exists
System.IO.File.Exists(fileName)

// custom method to count png in a specified folder
int CountPNGinDirectoryPath(string dirPath){
   string[] totalFiles = System.IO.Directory.GetFiles(path);
   int counter = 0;
   foreach (string item in totalFiles){
      if (item.EndsWith(".png")){
         counter++;
      }
   }
   return counter;
}

 

Ottimo!
Ora esportiamo e compiliamo per iOS


ERROR



Resources classe e directory:

Dopo alcune ricerche ho trovato il pezzo mancante, che all'inizio avevo saltato perchè mi sembrava troppo complicato rispetto a SYSTEM.IO.

Dalla documentazione di Unity::
The Resources class allows you to find and access Objects including assets.
[...]
All assets in the "Resources" folders will be included in a build.


Quindi la classe Resources serve ad operare sulle risorse/asset presenti nella/nelle cartelle "Resources", e nelle build verranno inclusi tutti gli assets presenti nella cartella, indipendentemente dal fatto che siano o meno necessari per quella determinata build/piattaforma.

Per prima cosa bisogna creare una o più cartelle Resources (se sono piu` di una a Runtime verranno trattate come fossero una unica), e spostare gli asset su cui si ha necessità di accesso o manipolazione a runtime sotto quest'ultima o una sotto-directory.

In seconda istanza per accedere ai suddetti assets è necessario usare i metodi della classe Resources inserendo i path come se la cartella Resources fosse la "root" del percorso, ed usando solo "/" (slash) e non "\" (backslash).
L'estensione dei file deve essere esclusa e le lettere maiuscole e minuscole devono essere corrette, in quanto il percorso usato nei metodi è "case-sensitive".

Per esempio un asset chiamato image.png nella cartella Background sotto Resources, sarà chiamata nei metodi di Resources accedendo con "Background/image".


I metodi corrispettivi usando Resources invece di SYSTEM.IO:

 

myTexture = (Texture2D)Resources.Load(resourceString, typeof(Texture2D));
// check if file exists - Resource.Load is null if resource does not exists
if (!myTexture) {
   // create 2d texture to fill the sprite
   myTexture = new Texture2D(1,1);
}

int CountPNGinDirectoryPath(string dirPath){
   int counter = 0;
   Object[] maps = Resources.LoadAll(dirPath);
   counter = maps.Length;
   Resources.UnloadUnusedAssets();
   return counter;
}