Un fungus per Unity !!!

Unity è uno dei motori più in auge in questi ultimi mesi (come già scritto in altri post di questo blog) soprattutto per la curva di apprendimento (molto rapida) e per la presenza di molti software di terze parti e librerie che consentono di velocizzare lo sviluppo di giochi.
In questo post, vedremo Fungus.
Il plugin Fungus per Unity3D

Fungus è un plugin per Unity 3D totalmente "free & open source" che consente anche chi non sa programmare di utilizzare le funzioni base di Unity in modo rapido e semplice. Per questo motivo è indicato soprattutto ai grafici, artisti e animatori (che non necessariamente conoscono Javascript o C sharp) e consente di creare la propria storia soprattutto se si tratta di narrativa interattiva (interactive fiction) o di visual novel.

Quali sono i punti di forza? Ecco un elenco:
  • Gratis e Open Source (con licenza MIT)
  • Indicato per creare Visual Novel, Inteactive Fiction, Role Playing Game, Avventure Punta e clicca (Point & Click), e applicazioni di tipo e-learning
  • indicato per persone che non necessariamente possiedono un'esperienza di programmazione
  • Facile da imparare e con un'interfaccia potente e semplice
  • funziona sia con la versione FREE di unity (la versione "personal") che con la versione PRO
Le caratteristiche principali sono:

Dialoghi dei personaggi

Ottimo supporto per Fungus per la gestione di dialoghi (utilizzabili in giochi di tipo visual novel e interactive fiction). Con Fungus è semplice creare complessi rami narrativi, utilizzando l'interfaccia UI dedicata ai dialoghi. Sempre in modo semplice è possibile aggiungere e gestire le immagini dei personaggi durante la visualizzazione dei dialoghi.

Telecamere

E' possibile utilizzare oggetti "viste" per gestire telecamere 2D: tali viste hanno un box di preview per visualizzare come il gioco verrà visualizzato a differenti risoluzioni (come ad esempio su smartphone o Tablet). Fungus fornisce comandi per visualizzare effetti come "pan" e "fade". In caso di un gioco in 3D basta controllare la telecamera normalmente utilizzando Mecanim o iTween e utilizzare Fungus per visualizzare i dialoghi dei personaggi.
Esempio di utilizzo di Fungus

Grafica

Fungus fornisce comandi per mostrare, nascondere e dissolvere oggetti di tipo Sprite.
Il plugin consente di creare con facilità hotspot dove il giocatore può interagire e creare azioni di tipo  "drag-and-drop". Queste funzionalità sono perfette per creare un gioco punta e clicca.

Audio

Il reparto di Fungus dedicato all'audio annovera molti comandi per gestire e riprodurre suoni, effetti e musica. Esiste anche l'integrazione con la libreria Usfxr, quindi è anche possibile creare suoni in modo procedurale.

Script

Fungus fornisce un sistema visuale per la gestione di script molto potente che consente di creare gameplay anche complessi senza scrivere codice ma utilizzando un'interfaccia con azioni "drag and drop". Tale sistema si basa sul concetto di "diagramma di flusso", quindi è abbastanza semplice visualizzare il flusso del gioco mentre lo si sviluppa.
Con pochi click lo sviluppatore può creare variabili, rami nel flusso della storia, eventi, oggetti e loops.

Per i programmatori Fungus può essere utilizzato in modo produttivo in quanto disegnato per essere personalizzato ed esteso facilmente. Si possono aggiungere comandi personalizzati, gestori di eventi, variabili semplicemente scrivendo una sola classe C# e i nuovi componenti saranno disponibili direttamente all'interno dell'editor di Fungus.


Ecco il video principale di riferimento per capire le potenzialità di questo tool.



Riferimenti:
Fungus Home
Lireria audio Usfxr

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.

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;
}

Unity e VS Code ottima partenza!

Chi ha utilizzato Unity negli ultimi anni avrà notato alcuni cambiamenti sull'editor di riferimento per C# e Unity Script. Le versioni iniziali utilizzavano MonoDevelop come editor di riferimento, un applicativo leggero e abbastanza veloce per poter editare i file di script.

A partire dalla release 5.2, il team di sviluppo di Unity ha introdotto un connettore per poter utilizzare Visual Studio al posto di MonoDevelop. La cosa interessante è che è possibile utilizzarlo anche con la versione Express (free) di Visual Studio: chi scrive ha testato l'installazione e la cosa funziona egregiamente, ed è molto comoda soprattutto se si lavora già con l'IDE di casa Microsoft.

Visual Studio Code

Come anticipato, la cosa interessante è che ora si è presentata una terza possibilità che (ad oggi) pare essere senza dubbio quella più utilizabile: ovvero l'integrazione di VSCode. VSCode è un editor open source targato Microsoft (si avete letto bene) con alcune intessanti caratteristiche:

  • editing intelligente
  • debugging molto versatile e potente
  • Supporto integrato a Git
  • centinaia di estensioni disponibili (extensions) che completano l'editor e lo rendono molto versatile
  • possibilità di utilizzarlo al posto di MonoDevelop con Unity
  • distribuito con licenza Open Source

L'installazione e la configurazione di Visual Studio Code viene realizzata attraverso tre semplici passaggi: installazione VSCode, installazione del plugin per l'utilizzo con Unity e infine lla configurazione di Unity per utilizzare l'editor come editor predefinito.

Sessione di lavoro con Visual Studio Code e Unity 5


Installazione di Visual Studio Code

  • Download e installazione di VSCode dal sito ufficiale https://code.visualstudio.com/ 
  • Installazione dell'estensione omnisharp: aprire Visual Studio Code, Quick Open (Ctrl+P) e digitare il comando "ext install omnisharp" (enter per eseguirlo)

Installazione del Plugin di VSCode per Unity

  • Scaricare il plugin via GIT (o scaricando lo zip dalla home page su GitHub)  
  • Se si vuole utilizzare git per prelevare direttamente i sorgenti utilizzare il seguente comando:
    git clone https://github.com/dotBunny/VSCode.git

Integrazione e configurazione del plugin su Unity

  • Aprire Unity 3D
  • Creare un nuovo progetto (oppure aprirne uno già esistente)
  • Dala cartella del plugin (scompattata se si è scaricato il file ZIP) copiare la cartella Plugins\Editor\dotBunny all'interno del progetto stesso
  • per abilitare il plugin, cliccare su Unity->Preferences e selezionare il nuovo tab di VisualStudioCode
  • impostare VSCode come editor predefinito
  • a questo punto aprendo un file .csharp dall'editor Unity verrà aperto direttamente con VSCode (e non con Monodevelop)

Note:

Dopo aver installato il plugin, è possibile personalizzare l'elenco delle estensioni dei file che verranno "ignorati" da VSCode (ad esempio i file teporanei o i metadati)


  • creare un file settings.json nella cartella %APPDATA%\Code\User\settings.json con il seguente contenuto (e riavviare Visual Studio Code)

{
    "files.exclude":
    {
        "**/.DS_Store":true,
        "**/.git":true,
        "**/.gitignore":true,
        "**/.gitattributes":true,
        "**/.gitmodules":true,
        "**/.svn":true,
        "**/*.booproj":true,
        "**/*.pidb":true,
        "**/*.suo":true,
        "**/*.user":true,
        "**/*.userprefs":true,
        "**/*.unityproj":true,
        "**/*.dll":true,
        "**/*.exe":true,
        "**/*.pdf":true,
        "**/*.mid":true,
        "**/*.midi":true,
        "**/*.wav":true,
        "**/*.gif":true,
        "**/*.ico":true,
        "**/*.jpg":true,
        "**/*.jpeg":true,
        "**/*.png":true,
        "**/*.psd":true,
        "**/*.tga":true,
        "**/*.tif":true,
        "**/*.tiff":true,
        "**/*.3ds":true,
        "**/*.3DS":true,
        "**/*.fbx":true,
        "**/*.FBX":true,
        "**/*.lxo":true,
        "**/*.LXO":true,
        "**/*.ma":true,
        "**/*.MA":true,
        "**/*.obj":true,
        "**/*.OBJ":true,
        "**/*.asset":true,
        "**/*.cubemap":true,
        "**/*.flare":true,
        "**/*.mat":true,
        "**/*.meta":true,
        "**/*.prefab":true,
        "**/*.unity":true,
        "build/":true,
        "Build/":true,
        "Library/":true,
        "library/":true,
        "obj/":true,
        "Obj/":true,
        "ProjectSettings/":true,
        "temp/":true,
        "Temp/":true
    }
} 

Per tutti i riferimenti consultare i seguenti collegamenti:
Visual Code Studio Home
VSCode Github


Unity - condividere uno screenshot di gioco su Android

Molti giochi su piattaforme mobile (Android o iOS) presentano una caratteristica molto interessante dal punto di vista "social": la possibilità non solo di condividere un link del gioco inviandolo ad esempio tramite app di instant messaging, ma anche di "scattare" (per cosi dire) una foto del gameplay ed inviarla come allegato via email o utilizzando le solite app social (twitter, facebook, hangout, ecc...).

In questo post vedremo come implementare questa funzionalità con Unity e Android.

Rispetto ad una versione dedicata a piattaforme desktop, in questo caso dovremo necessariamente utilizzare codice nativo Java che implementerà la chiamata all'intent che avrà come "azione" la condivisione di un messaggio tramite un'app.
Per semplicità possiamo creare un nuovo metodo che si occuperà della creazione di uno screenshot e della sua condivisione: al termine della sua esecuzione il dispositivo chiederà all'utente quale app utilizzare per effettuare tale condivisione. In questa selezione potremo liberamente scegliere l'applicativo da usare, a partire ovviamente dalle app installate (ovviamente non verrà proposta una "condivisione" con Facebook se tale app non è installata fisicamente sul device....)


I passi sono:
  • Salvare lo rappresentazione attuale dello schermo in un oggetto di tipo Texture2D 
  • Salvare la texture su file (utilizzando il filesystem nativo di Android)
  • Creare un nuovo oggetto di tipo Intent con action valorizzata a ACTION_SEND 
  • Esecuzione di questo intent dalla Activity principale del progetto

L'unica accortezza è quella di utilizzare una funzione di tipo IEnumerator, dato che dovremo attendere il disegno completo del frame attuale per evitare distorsioni nell'immagine salvata. Tutto questo si riduce ad utilizzare la keyword IEnumerator per la nostra funzione.

La nostra funzione (in c#) è la seguente:

public IEnumerator ShareScreenshot() {
 
   // wait for graphics to render
   yield return new WaitForEndOfFrame();
 
   // prepare texture with Screen and save it
   Texture2D texture = new Texture2D(Screen.width, Screen.height,TextureFormat.RGB24,true);
   texture.ReadPixels(new Rect(0f, 0f, Screen.width, Screen.height),0,0);
   texture.Apply();
 
   // save to persistentDataPath File
   byte[] data = texture.EncodeToPNG();        
   string destination = Path.Combine(Application.persistentDataPath, 
           System.DateTime.Now.ToString("yyyy-MM-dd-HHmmss") + ".png");        
   File.WriteAllBytes(destination, data);
 
   if(!Application.isEditor)
   {
    #if UNITY_ANDROID
    string body = "Body of message to be shared";
    string subject = "Subject of message";

    AndroidJavaClass intentClass = new AndroidJavaClass("android.content.Intent");
    AndroidJavaObject intentObject = new AndroidJavaObject("android.content.Intent");
    intentObject.Call<AndroidJavaObject>("setAction", intentClass.GetStatic<string>("ACTION_SEND"));
    AndroidJavaClass uriClass = new AndroidJavaClass("android.net.Uri");
    AndroidJavaObject uriObject = uriClass.CallStatic<AndroidJavaObject>("parse","file://" + destination);
    intentObject.Call<AndroidJavaObject>("putExtra", intentClass.GetStatic<string>("EXTRA_STREAM"), uriObject);
    intentObject.Call<AndroidJavaObject>("putExtra", intentClass.GetStatic<string>("EXTRA_TEXT"), body );
    intentObject.Call<AndroidJavaObject>("putExtra", intentClass.GetStatic<string>("EXTRA_SUBJECT"), subject);
    intentObject.Call<AndroidJavaObject>("setType", "image/jpeg");
    AndroidJavaClass unity = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
    AndroidJavaObject currentActivity = unity.GetStatic<AndroidJavaObject>("currentActivity");
  
    // run intent from the current Activity
    currentActivity.Call("startActivity", intentObject);
    #endif
   }
}
NOTA: Per poter "scrivere" file sul FileSystem di Android è necessario abilitare tale permesso (normalmente sul file manifest). Nel caso di Unity basta impostare a TRUE il campo "writeaccess" nella finestra "Edit" -> "Project" -> "Player" -> "Android Settings"



Un esempio completo

Vediamo un semplice esempio ma completo che mostra il funzionamento del metodo appena descritto.
Creeremo una nuova scena vuota con Unity e un "empty object" (cioè un oggetto vuoto) al quale applicheremo uno script che si occuperà del disegno dell'interfaccia utente e delle funzionalità minime per poter condividere uno screenshot.

Ricapitolando:
  1. Create una scena nuova in Unity
  2. Create un "Emply Object"
  3. Agganciate all'oggetto il seguente script C#

using UnityEngine;
using System.Collections;
using System.IO;

/**
 *  Share a Screenshot on Android (on Unity 5.3.4)
 * 
 *  Last update 2016-05-04
 * 
 */
public class Screenshot : MonoBehaviour {

    void OnGUI () {
        GUI.Box (new Rect (0,Screen.height - 100,220,70), "Action Menu");
        if(GUI.Button(new Rect(20,Screen.height-60,180,20), "Share Screenshot")) {
            StartCoroutine(ShareScreenshot());
        }
    }

    public IEnumerator ShareScreenshot() {
        
        // wait for graphics to render
        yield return new WaitForEndOfFrame();
        
        // prepare texture with Screen and save it
        Texture2D texture = new Texture2D(Screen.width, Screen.height,TextureFormat.RGB24,true);
        texture.ReadPixels(new Rect(0f, 0f, Screen.width, Screen.height),0,0);
        texture.Apply();
        
        // save to persistentDataPath File
        byte[] data = texture.EncodeToPNG();        
        string destination = Path.Combine(Application.persistentDataPath, 
                                          System.DateTime.Now.ToString("yyyy-MM-dd-HHmmss") + ".png");        
        File.WriteAllBytes(destination, data);
        
        if(!Application.isEditor)
        {
            #if UNITY_ANDROID
            string body = "Body of message to be shared";
            string subject = "Subject of message";

            AndroidJavaClass intentClass = new AndroidJavaClass("android.content.Intent");
            AndroidJavaObject intentObject = new AndroidJavaObject("android.content.Intent");
            intentObject.Call<AndroidJavaObject>("setAction", intentClass.GetStatic<string>("ACTION_SEND"));
            AndroidJavaClass uriClass = new AndroidJavaClass("android.net.Uri");
            AndroidJavaObject uriObject = uriClass.CallStatic<AndroidJavaObject>("parse","file://" + destination);
            intentObject.Call<AndroidJavaObject>("putExtra", intentClass.GetStatic<string>("EXTRA_STREAM"), uriObject);
            intentObject.Call<AndroidJavaObject>("putExtra", intentClass.GetStatic<string>("EXTRA_TEXT"), body );
            intentObject.Call<AndroidJavaObject>("putExtra", intentClass.GetStatic<string>("EXTRA_SUBJECT"), subject);
            intentObject.Call<AndroidJavaObject>("setType", "image/jpeg");
            AndroidJavaClass unity = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
            AndroidJavaObject currentActivity = unity.GetStatic<AndroidJavaObject>("currentActivity");
            
            // run intent from the current Activity
            currentActivity.Call("startActivity", intentObject);
            #endif
        }
    }
}