anotherdevgamesblog

Ovviamente non potrà mancare lo store.. 

e come integrarlo se non nativamente sia per iOS che per Android?? Questi ragazzi di SOOMLA hanno già preparato quello che ci serve. 

Guardate la loro home page, il tutorial e il progetto su GitHub per cocos2d-x!

SOOMLA

Tutorial

nel post "Fin dall'inizio: i dati" abbiamo segnalato due servizi di analitycs per le applicazioni. 

Abbiamo integrato il servizio Flurry Analitycs nella nostra applicazione cocos2d-x grazie al wrapper AnalitycsX. 

Al momento per l'integrazione ci è bastato inserire nel nostro progetto Xcode: 

Flurry.h e libFlurry.a

AnalyticX.h e AnalyticX.mm

AnalyticXStringUtil.h eAnalyticXStringUtil.mm

come vedete questi file sono file Objective-C e, in quanto tali, opportuni solo per lo sviluppo su iOS. Per Android i passi che andremo a effettuare saranno quelli indicati nel Readme.md sul repository al link indicato. 

Per prevenire la necessità di eseguire il progetto su iOS e su Android abbiamo creato delle funzioni statiche in una classe di utilità (guardate qui) per recuperare che tipo di dispositivo stiamo utilizzando in modo tale da poter inserire, all'interno del metodo applicationDidFinishingLaunching() nel file AppDelegate.cpp il seguente codice: 

//Flurry Analitics integration

#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)

if(Utilities::IsiPad()) {

    AnalyticX::flurryStartSession("API_KEY_FOR_iPAD_APP");

}else{

    AnalyticX::flurryStartSession("API_KEY_FOR_iPHONE_APP");

}

#endif

#if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)    

    AnalyticX::flurryStartSession("API_KEY_FOR_ANDROID_APP");

#endif

Qui di seguito un link per le istruzioni aggiuntive di Flurry!

Per dimenticarsi ufficialmente di ricreare gli sprite sheets.

Prerequisiti: 

- aver installato TexturePacker

- aver generato il link all'eseguibile tramite: 

sudo ln -s /Applications/TexturePacker.app/Contents/MacOS/TexturePacker /usr/local/bin/TexturePacker

Integrazione con xcode: 

Abbiamo deciso di utilizzare coco2d-x, per lo sviluppo multipiattaforma utilizzando C++. 

Maggiori dettagli qui: link

Scaricato cocos2dx, installati i template in XCode tramite lo script "install-templates-xcode.sh -f".

Il seguente snippet di codice fa in modo che tutti i TODO: e i FIXME: presenti nei commenti vengano trattati come warning in fase di compilazione.

Le istruzioni sono molto semplici:

Entrare nella configurazione del target selezionando il nome del progetto

Selezionare il tab “Build Phases”

Aggiungere una nuova fase con il bottone “Add Build Phase” > “Add Run Script”

Inserire nell’editor il seguente script

KEYWORDS="TODO:|FIXME:|\?\?\?:|\!\!\!:" find "${SRCROOT}" \( -name "*.h" -or -name "*.m" \) -print0 | xargs -0 egrep --with-filename --line-number --only-matching "($KEYWORDS).*\$" | perl -p -e "s/($KEYWORDS)/ warning: \$1/"

Reminder, 

teniamo presente fin dalla progettazione dei game l'importanza di monitorare l'utilizzo e i dati che passano tramite le nostre applicazioni. 

Importante e veramente valido servizio web per l'analisi e le reportistiche delle app di tutto il mondo: 

http://www.appannie.com/

Altrimenti: Flurry. 

Una questione che ci stiamo ponendo durante la fase di analisi e studio delle tecnologie attualmente a disposizione sul mercato è la questione del multiplaying. 

Ovvero: il nostro gioco metterà in relazione più giocatori, qual'è il modo migliore di progettarlo? 

Risposta più ovvia: utilizzare il Game Center Kit di iOS. È la più ovvia e quindi non può essere quella giusta, no? 

Nella rete si possono trovare varie alternative, anche Google sembra che ne stia per realizzare una simile, ma le caratteristiche importanti sembrano essere: 

Multi-piattaforma (e quindi SDK per i vari sistemi operativi mobile - e non, se il vostro gioco prevede il target desktop)

Più possibile free, ma non per forza: molti sistemi permettono l'utilizzo gratuito fino al raggiungimento di un certo grado di scalabilità (e mi sembra corretto)

Supportato, ben documentato, possibilmente con la previsione di lunga e prosperosa vita e sviluppo (vedi OpenFeint)

Alternative trovate: 

OpenKit: successore open del defunto OpenFeint. Progetto partito a dicembre 2012 (sulle ceneri di un sistema stabile e largamente diffuso) e già alla prima beta con qualche migliaio di sviluppatori registrati. iOS, Android, Unity. Nessuna SDK C++

ElectroTank: il sito è poco navigabile, non si può sapere quanto costa se non contattando l'azienda, ha buonissimi clienti all'attivo. iOS, Android, Unity, Java, Flash, HTML5

SmartFox, gratuito fino a 100 CCU (utenti concorrenti), scalabile con i servizi di hosting partner, azienda di supporto italiana. iOS, Android, Unity, Java, Flash, HTML5

Scoreloop: non si capiscono i costi. Molto ben curato il sito, iOS, Android, Windows Phone, Blackberry.

Photon: Unity, iOS, Flash, Java, Android, HTML5, Win, Blackberry, etc. Gratuito fino a 100 CCU. SDK C++ compatibile con cocos2d-x.

ScoreOid: API Rest per multiplayer gaming, notification e quant'altro (probabilmente no social integration). Prezzi non ancora definiti in quanto sono in beta. Cocos2d-x compatibile.

Cosa è cocos2d: http://www.cocos2d-iphone.org/about

Come installare cocos2d-iphone per xcode: http://www.oscarvgg.com/installing-cocos2d-for-iphone/

Tutorial scritto da Zynga a proposito dell'utilizzo di CocosBuilder, ambiente grafico integrato con XCode per la grafica di base (e soprattutto le animazioni tramite timeline) dei giochi 2d basati su cocos2d. 

Creazione del gioco dalla A alla Z, veramente ben fatto da una delle più popolari ditte produttrici di games per dispositivi iOS

Porting del tutorial per cocos2d-x in c++ perfettamente funzionante: 

Speedy Method parte 1

Speedy Method parte 2

Fonti: 

http://idevgames.com/

http://www.cocos2d-iphone.org/

Appunti:

Lo sviluppo dei giochi su iOS è da considerarsi fin dall'inizio diverso dallo sviluppo di app. Lo si chiarisce subito in quanto non ci si deve aspettare di programmare in Objective-C soltanto ma anche nel buon vecchio C. 

Linguaggi di programmazione utilizzati: 

Objective-C

C / C++

Le peculiarità dello sviluppo dei giochi sono l'utilizzo di appositi framework e librerie di terze parti. In particolare quelle più significative sembrano essere: 

OpenGL ES: Versione ridotta di OpenGL per iOS e portabile anche su altre piattaforme - utile quindi studiarlo in previsione di sviluppo anche Android) - utilizzo della GPU

Core Graphics: Disegni in 2D tramite CPU

Core Animation: Framework per la gestione del layout e movimenti degli elementi grafici

Core Motion

Core Audio: Framework per lo streaming audio

Open AL: Effetti audio

GameKit: networking peer-to-peer, chat, leaderboards

StoreKit: per in-app purchase

Social: Facebook & Twitter

iAd

Una delle librerie / framework / game engine (sono termini che si confondono in alcuni casi) più usate nel mondo Apple e quindi iOS è cocos2d che integra alcune parti di OpenGL ES, librerie di terze parti quali Chipmunk ed altro per la fisica e l'interazione e collisione degli elementi grafici.

EDIT: 

Oltre a cocos2d, bisogna considerare la presenza di: 

cocos2d-x, porting di cocos2d per C++ e quindi portabile per iOS e Android (software per animazioni personalizzate skeleton con cocos2d-x: Spine - 60$). Tutorial, tutorial2

Corona, SDK potente e molto utilizzata, fornisce anche game center integrato e molto altro. Non è estendibile con altre features o librerie di terze parti o utilizzare periferiche dei dispositivi (per questo serve una licenza "Enterprise"). Si programma tramite linguaggio di scripting "lua". Articolo di .Net magazine a riguardo, tutorial