Inform, come ricompilare wingit per windows

Wingit (o "Windows Git") è un'implementazione di glulx per sistemi windows: in pratica è uno degli interpreti per glulx che è possibile utilizzare per eseguire avventure testuali in formato glulx (appunto).
In questo post vengono riportati i passaggi per ricompilare questo applicativo: nomalmente tale procedura non è affatto necessaria, ma potrebbe servire per:
  • Compilare wingit usando una versione più aggiornata dei sorgenti
  • Effettuare una modifica ai sorgenti per creare una versione "modificata"


Alla fine della procedura avremo ricompilato uno degli interpreti per avventure testuali più diffuso su piattaforma windows.
  1. scaricare e installare il compilatore mingw, scaricabile da qui http://tdm-gcc.tdragon.net/ versione a 32 bit
  2. creare una cartella "wingit"su FileSystem
  3. creare una nuova cartella "wingit/Git"
  4. creare una nuova cartella "wingit/Executables/Release/Git"
  5. creare una nuova cartella "wingit/GlkDll"
  6. scaricare e scompattare il file git-134.zip e copiare i sorgenti nella cartella "wingit/Git"
  7. scaricare e scompattare il file wingit-src-134.zip e copiare i sorgenti nella cartella "wingit/Git"
  8. scaricare e scompattare il file WindowsGlk-145.zip e copiare i sorgenti nella cartella "wingit/GlkDll"


L'alberatura finale è la seguente:

Alberatura sorgenti di Wingit


modificare il makefile "wingit/Git/Makefile.win" in questo modo:

# Makefile for Windows Git, compiled with MinGW GCC 2.95

CC = gcc -Wall -O3 -mwindows
OPTIONS = -DUSE_INLINE -DUSE_DIRECT_THREADING -DUSE_OWN_POWF
LIBS = -L. -lglk

OUTPUT = ../Executables/Release/Git

CFLAGS = $(OPTIONS) -I../Include -I../GlkDll/Include

OBJS =  git.o memory.o compiler.o opcodes.o operands.o peephole.o terp.o \
    glkop.o search.o git_windows.o savefile.o saveundo.o gestalt.o \
    accel.o heap.o glk.o res.o

#all: git chm
all: git

git: $(OBJS) libglk.a
    $(CC) -s -o $(OUTPUT) $(OBJS) $(LIBS)

glk.o: ../GlkDll/glk.c
    $(CC) $(CFLAGS) -c -o $@ $^

res.o: win/git.rc
    windres --preprocessor "gcc -E -xc-header -DRC_INVOKED" $^ $@

libglk.a:
    dlltool --dllname=Glk.dll --def=../GlkDll/Glk.def --output-lib=libglk.a

#chm:
#   -C:\\Program\ Files\ \(x86\)\\HTML\ Help\ Workshop\\hhc help\\Git.hhp
#   copy help\\Git.chm ..\\Executables\\Release

clean:
    @$(RM) *.o *.a


compilare wingit con i seguenti comandi da shell:

cd /wingit/Git
mingw32-make SHELL=cmd.exe -f Makefile.win



Al termine della compilazione dovreste avere il file wingit.exe all'interno della cartella Executables/Release/Git

Android e i KeyStore

Chi sviluppa su piattaforma Android ha sicuramente già avuto a che fare con un keystore.
Per coloro che non conoscono l'argomento, illustreremo alcuni consigli su come utilizzarli al meglio.

Durante il processo di sviluppo è sempre possibile produrre un file APK non firmato (normalmente viene utilizzato per creare apk in modalità di debug). Tale file si può installare su un device reale (a patto di abilitare le "Sorgenti/Origini sconosciute") anche manualmente.

Utilizzare un keystore per firmare la propria app
Per un rilascio ufficiale nello Store di Google è necessario però "firmare" il pacchetto APK prima di poterlo "deliverare" sulla Console degli Sviluppatori.
Il risultato di tale operazione (che si può attuare direttamente con Android Studio o Eclipse+ADT) è un file APK firmato con un keystore: è possibile successivamente deliverarlo direttamente dalla console di Google e procedere con la pubblicazione.

Questo keystore è un file che dev'essere utilizzato sempre per firmare l'app una volta pubblicata.

Cioè una volta utilizzato tale file per firmare un'app, va sempre utilizzato per aggiornamenti futuri dell'app stessa.
Può sembrare una banalità, ma se gli aggiornamenti dell'app non sono frequenti (magari viene aggiornata una volta all'anno...), ci si potrebbe trovare nella spiacevole situazione di non trovare più il keystore utilizzato in precedenza (basta cercare su un qualsiasi motore di ricerca la parole "android lost keystore" per rendersi conto che non è una cosa cosi impossibile da realizzarsi).
Potreste anche trovarvi nella situazione di aver effettuato i backup dei keystore utilizzati per rilasciare le vostre app, ma di non ricordarvi quale keystore avete utilizzato per firmare una certa app.
In questi casi è possibile calcolare l'hash di un keystore e l'hash di un file APK per verificare quale keystore è stato utilizzato per firmare l'apk.
La procedura è abbastanza semplice: si tratta si eseguire il comando "keytool" (presente nella distribuzione di Java) e ricavare l'hash SHA1 per il keystore e il file APK e controlare che siano uguali.

Come visualizzare l'hash di un keystore

keytool -list -keystore my_keystore.jks

 

Come visualizzare  l'hash di un file apk signed

keytool -list -printcert -jarfile my_app.apk


Se la sezione SHA1 è identica in entrambi i casi, si può assumere che il file "my_app.apk" è stato firmato utilizando il file "my_keystore.jks".
Ovviamente non è possibile recuperare la password utilizzata per creare il keystore stesso, quindi consiglio di seguire questo semplice accorgimento:

Per ogni nuova app che sviluppate, abbiate cura di salvare sia la password che il keystore che avete utilizzato per il primo rilascio in produzione, perchè senza questo file non potrete più rilasciare aggiornamenti per la/le vostre app.

Riferimenti

https://developer.android.com/training/articles/keystore.html

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