Performance con AndEngine

[Zate]

Sto creando un gioco che richiede il disegno di alcune linee che poi verranno trasformate in physics object. Si tratta di linee curve, formate in realtà da molte piccole linee. Il problema è che dopo poco il gioco comincia a rallentare quasi regolarmente (comunque senza andare a crashare), ma durante i primi 20 secondi i fps sono regolari.

Codice: [Seleziona]

12-11 19:15:22.478: D/AndEngine(20462): FPS: 54,33 (MIN: 7 ms | MAX: 450 ms)
12-11 19:15:27.478: D/AndEngine(20462): FPS: 65,03 (MIN: 8 ms | MAX: 31 ms)
12-11 19:15:32.478: D/AndEngine(20462): FPS: 64,87 (MIN: 9 ms | MAX: 34 ms)
12-11 19:15:37.477: D/AndEngine(20462): FPS: 65,17 (MIN: 10 ms | MAX: 38 ms)
12-11 19:15:42.467: D/AndEngine(20462): FPS: 64,79 (MIN: 11 ms | MAX: 31 ms)
12-11 19:15:47.649: D/AndEngine(20462): FPS: 61,52 (MIN: 13 ms | MAX: 25 ms)
12-11 19:15:52.639: D/AndEngine(20462): FPS: 57,57 (MIN: 15 ms | MAX: 23 ms)
12-11 19:15:57.658: D/AndEngine(20462): FPS: 52,94 (MIN: 16 ms | MAX: 27 ms)
12-11 19:16:02.668: D/AndEngine(20462): FPS: 49,04 (MIN: 17 ms | MAX: 38 ms)
12-11 19:16:06.418: D/dalvikvm(8424): GC_EXPLICIT freed <1K, 52% free 3354K/6919K, external 3676K/4591K, paused 1362ms
12-11 19:16:07.657: D/AndEngine(20462): FPS: 45,11 (MIN: 18 ms | MAX: 50 ms)
12-11 19:16:08.167: D/dalvikvm(20462): GC_CONCURRENT freed 658K, 41% free 4715K/7879K, external 885K/1391K, paused 4ms+6ms
12-11 19:16:12.677: D/AndEngine(20462): FPS: 40,81 (MIN: 21 ms | MAX: 185 ms)
12-11 19:16:17.657: D/AndEngine(20462): FPS: 41,14 (MIN: 22 ms | MAX: 49 ms)
12-11 19:16:22.666: D/AndEngine(20462): FPS: 40,04 (MIN: 23 ms | MAX: 33 ms)
12-11 19:16:27.666: D/AndEngine(20462): FPS: 37,26 (MIN: 24 ms | MAX: 38 ms)
12-11 19:16:31.026: D/dalvikvm(1530): GC_CONCURRENT freed 1226K, 41% free 6186K/10311K, external 1893K/2233K, paused 11ms+37ms
12-11 19:16:32.665: D/AndEngine(20462): FPS: 35,09 (MIN: 25 ms | MAX: 61 ms)
12-11 19:16:37.665: D/AndEngine(20462): FPS: 34,25 (MIN: 26 ms | MAX: 60 ms)
12-11 19:16:42.665: D/AndEngine(20462): FPS: 32,90 (MIN: 28 ms | MAX: 39 ms)
12-11 19:16:47.654: D/AndEngine(20462): FPS: 30,52 (MIN: 30 ms | MAX: 43 ms)
12-11 19:16:52.654: D/AndEngine(20462): FPS: 29,97 (MIN: 30 ms | MAX: 39 ms)
12-11 19:16:57.673: D/AndEngine(20462): FPS: 28,21 (MIN: 32 ms | MAX: 42 ms)
12-11 19:17:02.259: D/AndEngine(20462): FPS: 27,39 (MIN: 33 ms | MAX: 59 ms)

E questo è il codice che uso per la creazione, modifica e distruzione della linee (che in realtà sono più linee)

Codice (Java): [Seleziona]

scene.setOnSceneTouchListener(new IOnSceneTouchListener() {

                        @Override
                        public boolean onSceneTouchEvent(Scene pScene,
                                        TouchEvent pSceneTouchEvent) {
                                // TODO Auto-generated method stub

                                if (pSceneTouchEvent.isActionDown()) {
                                        sX = pSceneTouchEvent.getX();
                                        sY = pSceneTouchEvent.getY();
                                } else if (pSceneTouchEvent.isActionMove()) {
                                        mX = pSceneTouchEvent.getX();
                                        mY = pSceneTouchEvent.getY();

                                        line = new Line(sX, sY, mX, mY, 5);
                                        line.setColor(0, 1, 0);
                                        scene.attachChild(line);

                                        final Body bodyLine = PhysicsFactory.createLineBody(
                                                        mPhysicsWorld, line, lineFixtureDef);
                                        bodyLine.setUserData("line");

                                        sX = pSceneTouchEvent.getX();
                                        sY = pSceneTouchEvent.getY();

                                        // Trasparenza linea e distruzione
                                        final LoopEntityModifier entityModifier = new LoopEntityModifier(
                                                        new IEntityModifierListener() {
                                                                @Override
                                                                public void onModifierStarted(
                                                                                final IModifier<IEntity> pModifier,
                                                                                final IEntity pItem) {

                                                                }

                                                                @Override
                                                                public void onModifierFinished(
                                                                                final IModifier<IEntity> pEntityModifier,
                                                                                final IEntity pEntity) {

                                                                }
                                                        }, 1, new ILoopEntityModifierListener() {
                                                                @Override
                                                                public void onLoopStarted(
                                                                                final LoopModifier<IEntity> pLoopModifier,
                                                                                final int pLoop, final int pLoopCount) {

                                                                }

                                                                @Override
                                                                public void onLoopFinished(
                                                                                final LoopModifier<IEntity> pLoopModifier,
                                                                                final int pLoop, final int pLoopCount) {
                                                                        Main.this.runOnUpdateThread(new Runnable() {
                                                                                @Override
                                                                                public void run() {

                                                                                        final PhysicsConnector physicsConnector = mPhysicsWorld
                                                                                                        .getPhysicsConnectorManager()
                                                                                                        .findPhysicsConnectorByShape(
                                                                                                                        line);

                                                                                        mPhysicsWorld
                                                                                                        .unregisterPhysicsConnector(physicsConnector);
                                                                                        mPhysicsWorld.destroyBody(bodyLine);

                                                                                }
                                                                        });
                                                                }
                                                        },

                                                        new SequenceEntityModifier(new AlphaModifier(1, 1,
                                                                        0)));
                                        line.registerEntityModifier(entityModifier);
                                }
                                return false;
                        }

                });
Sono piuttosto sicuro che il problema sia causato dalle linee dato che se ne disegno nessuna/poche il gioco rimane fluido.
Qualche idea su quale possa essere il problema?

[Verandi]

Ciao! Premetto che non ho mai usato andengine e quindi non ne conosco le classi e relativi utilizzi.
Con "rallentare quasi regolarmente" intendi che ci sono degli scatti? Nel logcat ci sono queste tre righe:

Codice: [Seleziona]

12-11 19:16:06.418: D/dalvikvm(8424): GC_EXPLICIT freed <1K, 52% free 3354K/6919K, external 3676K/4591K, paused 1362ms
12-11 19:16:08.167: D/dalvikvm(20462): GC_CONCURRENT freed 658K, 41% free 4715K/7879K, external 885K/1391K, paused 4ms+6ms
12-11 19:16:31.026: D/dalvikvm(1530): GC_CONCURRENT freed 1226K, 41% free 6186K/10311K, external 1893K/2233K, paused 11ms+37ms

che segnalano che il garbage collector sta liberando memoria. Il problema è che crei troppi oggetti temporanei e ogni "scatto/rallentamento" è causato proprio dal garbage collector che entra in azione. Nella prima riga il rallentamento è durato quasi un secondo e mezzo.
Nei giochi la regola del creare il minor numero di oggetti temporanei possibile è ancora più importante che in una normale applicazione "statica", proprio perché, in generale, in un gioco la UI è costantemente aggiornata.
Purtroppo, come ho scritto sopra, non conosco andengine, quindi non saprei se il codice che hai postato sia da ottimizzare. Potresti usare l'allocation tracker nel ddms dell'sdk in eclipse per cercare cosa porti il garbage collector ad entrare in azione così spesso.
Faccio anche un esempio: mettiamo il caso che tu voglia disegnare un rettangolo che quando muovi il dito sullo schermo si sposti e cambi continuamente colore.
- PRATICA SBAGLIATA: creare un nuovo rettangolo ed un nuovo paint ad ogni spostamento del dito. In questo modo vengono creati innumerevoli rettangoli e altrettanti paint inutili.
- PRATICA CORRETTA: creare un rettangolo e un paint nel costruttore della classe. Ad ogni spostamento del dito cambiare le coordinate al rettangolo e il colore al paint. In questo modo hai allocato in memoria il rettangolo e il paint e ad ogni movimento non andrai ad allocare ulteriore memoria.

[Zate]

Quello che intendo dire con "rallentare quasi regolarmente" è questo: togliendo la prima linea di logcat (dove sto caricando le risorse e quindi è normale che i fps siano un po' bassi) le quattro indicano i fps che sono più o meno uguali. Poi cominciano a diminuire di 3,4 o anche di 5. Da 64 a 61, da 61 a 57, da 57 a 52 e così via. Chiamando il garbage collector c'è effettivamente un momento di "incertezza", ma poi il gioco riprende a girare normalmente. Non ricordo bene, ma mi sembra che lo avessi chiamato io per vedere se si verificava un aumento di performance (dopo lo scatto prodotto appunto dal gc).
Qui c'è un logcat nuovo:

Codice: [Seleziona]

12-12 18:54:24.851: D/AndEngine(2410): FPS: 16,76 (MIN: 4 ms | MAX: 2826 ms)
12-12 18:54:29.850: D/AndEngine(2410): FPS: 65,31 (MIN: 5 ms | MAX: 39 ms)
12-12 18:54:34.860: D/AndEngine(2410): FPS: 65,41 (MIN: 7 ms | MAX: 37 ms)
12-12 18:54:39.849: D/AndEngine(2410): FPS: 65,47 (MIN: 7 ms | MAX: 59 ms)
12-12 18:54:44.849: D/AndEngine(2410): FPS: 64,78 (MIN: 9 ms | MAX: 34 ms)
12-12 18:54:49.858: D/AndEngine(2410): FPS: 62,81 (MIN: 12 ms | MAX: 37 ms)
12-12 18:54:54.848: D/AndEngine(2410): FPS: 57,51 (MIN: 14 ms | MAX: 62 ms)
12-12 18:54:59.838: D/AndEngine(2410): FPS: 51,99 (MIN: 15 ms | MAX: 50 ms)
12-12 18:55:04.857: D/AndEngine(2410): FPS: 45,07 (MIN: 18 ms | MAX: 54 ms)
12-12 18:55:09.857: D/AndEngine(2410): FPS: 41,11 (MIN: 21 ms | MAX: 55 ms)
12-12 18:55:14.846: D/AndEngine(2410): FPS: 36,99 (MIN: 23 ms | MAX: 49 ms)
12-12 18:55:18.546: D/dalvikvm(5392): GC_CONCURRENT freed 362K, 48% free 3034K/5831K, external 716K/1038K, paused 6ms+21ms
12-12 18:55:19.856: D/AndEngine(2410): FPS: 30,33 (MIN: 26 ms | MAX: 131 ms)
12-12 18:55:24.866: D/AndEngine(2410): FPS: 32,30 (MIN: 27 ms | MAX: 66 ms)
12-12 18:55:25.326: D/dalvikvm(1788): GC_EXPLICIT freed 187K, 50% free 2834K/5575K, external 716K/1038K, paused 1665ms
12-12 18:55:29.875: D/AndEngine(2410): FPS: 31,01 (MIN: 29 ms | MAX: 42 ms)
Il gc entra in azione due volte, ma non ha il pid 2410. Ci sono delle analogie con il logcat precedente: le 4 righe dopo la prima indicano fps piuttosto alti e regolari (sempre sui 65) e poi comincia a diminuire di 3,4,5 (o anche 6 questa volta) ecc. Non so perché alla fine aumentano (di poco comunque). Quello che non capisco è perché durante i primi 15-20 secondi i fps non diminuiscono.

[Verandi]

Il framerate credo dipenda da vari fattori. Tenendo conto che entrano in gioco sia cpu che gpu, potrebbe anche essere influenzato da qualche processo in background.
Inoltre più "entità" devi disegnare in quel momento e più aumenta il lavoro della cpu per calcolare le varie posizioni ed eventuali collisioni, diminuendo il framerate.  Per esempio, tempo fa leggevo che per controllare le collisioni tra i vari oggetti in 2d senza aumentare esponenzialmente il lavoro della cpu, di solito si divide lo spazio in una griglia e si controlla se ci sono collisioni solo tra oggetti vicini, quindi oggetti presenti nello stesso quadrato o quadrati adiacenti della griglia. E immagino che anche andengine usi la stessa tecnica. Supponendo che tu in quei 20 secondi non faccia nulla, potrebbe essere che in quel momento ci siano più collisioni da controllare rispetto all'inizio, diminuendo di conseguenza il framerate.
Ovviamente tu conosci il codice e tu sai cosa viene fatto dall'applicazione e come l'utente ha interagito in quei 20 secondi. 

[Zate]

No, il numero delle collisioni intercettate non cambia. In poche parole bisogna far saltare una pallina disegnando una linea (che in realtà sono molto linee). In più c'è un ostacolo che "cade" e ogni volta che esce dallo schermo ne creo uno nuovo.
Ma sono piuttosto sicuro che il problema è nelle linee perché disegnando una sola linea il framerate non diminuisce (ho fatto dei test facendo in modo che le linee non venissero eliminate e ho "intrappolato" la pallina in modo che continuasse a rimbalzare senza dover disegnare altre linee).

[bradipao]

Anche io non ho mai usato AndEngine e nemmeno lo conosco, però butto là un'idea che si riallaccia al suggerimento iniziale di Verandi.

Hai detto che con una sola linea tutto è a posto, mentre creandole si genera il rallentamento sistematico. Come ha detto Verandi sopra, crare continuamente nuovi oggetti è sempre fonte di sovraccarico per il sistema. Ora io non so quanti oggetti di quel genere possono esserci contemporaneamente attivi, però se sono qualche decina, prendi in considerazione l'ipotesi di avere un pool fisso di oggetti.

Comunque dovresti poter vedere se è un problema di troppe allocazioni, guardando come evolve l'allocation tracker del DDMS.

[Zate]

Grazie a entrambi, comincio a guardarci e vi farò sapere
Se ad altri servisse una guida...
AndEngine: Using the Object Pool « c0deattack

[Verandi]

Ciao Zate! Oggi ho un po' di tempo e mi sono messo a giocare con andengine.   
Volevo chiederti: come fai con il javadoc della libreria? Ne conosci uno abbastanza completo?

[Zate]

Proprio questo è il problema Bisogna provare a vedere cosa succede cambiando/togliendo parti di codice.
Cercando su Google qualcosa si può trovare.
http://codetheater.com/?p=24

 denravonska-javadoc -
 
 
 AndEngine Javadoc work - Google Project Hosting
 

[Zate]

Eccomi che mi rifaccio vivo
Ho trovato due soluzioni: la prima è appunto usare l'object pooling, la seconda è cambiare sempre la posizione della linea. In entrambi i casi sorge un secondo problema.
Per chi fosse interessato nelle soluzioni che ho adottato...

PRIMA SOLUZIONE (Object Pooling)

Codice (Java): [Seleziona]

package test.gioco.ae;

import org.anddev.andengine.entity.primitive.Line;
import org.anddev.andengine.util.pool.GenericPool;

public class LinePool extends GenericPool<Line>{
       
        @Override
        protected Line onAllocatePoolItem() {
                // TODO Auto-generated method stub
                Line line = new Line(0,0,0,0,5);
                return line;
        }
       
        @Override
         protected void onHandleRecycleItem(final Line line) {
          line.setIgnoreUpdate(true);
          line.setVisible(false);
         }

        @Override
         protected void onHandleObtainItem(final Line line) {
          line.reset();
         }

}E poi nella classe del gioco:

Codice (Java): [Seleziona]

private static LinePool LINE_POOL;e nell'onLoadResources:

Codice (Java): [Seleziona]

LINE_POOL = new LinePool();Dove creavo una nuova linea:

Codice (Java): [Seleziona]

line = getLineFromLinePool();
line.detachSelf();
line.setPosition(sX, sY, mX, mY);
line.setLineWidth(5);
line.setColor(0, 1, 0);
scene.attachChild(line);E infine:

Codice (Java): [Seleziona]

private void sendLineToLinePool(Line line) {
        LINE_POOL.recyclePoolItem(line);
}

private Line getLineFromLinePool() {
        return LINE_POOL.obtainPoolItem();
}Ho messo la linea line.detachSelf() perché altrimenti andava incontro ad un errore: pEntity already has a parent perché la linea era appunta già "attaccata". In questo modo però rimane sullo schermo l'ultima parte della linea, che in realtà è una linea intera (il body, dove rimbalza, è invece intero).

SECONDA SOLUZIONE:
Nell'onLoadScene():

Codice (Java): [Seleziona]

line = new Line(0,0,0,0,5);
scene.attachChild(line);Dove creavo una nuova linea:

Codice (Java): [Seleziona]

line.setPosition(sX, sY, mX, mY);
line.setColor(0, 1, 0);
Anche qui ho lo stesso problema. Vedo solo l'ultima parte della linea che, ripeto, è in realtà una linea intera.

Le differenze di performance sono impercettibili, ma penso che la seconda soluzione sia migliore perché, oltre al fatto di essere molto più semplice, alloco un solo oggetto all'inizio mentre nella prima soluzione se l'oggetto non è disponibile ne devo allocare uno nuovo (se non è così allora penso di aver capito male l'object pool ).

Probabilmente non avete capito niente del problema, effettivamente è un po' difficile da spiegare, quindi vi linko l'apk in modo che possiate capire meglio cosa intendo

Multiupload.com - upload your files to multiple file hosting sites!

[Verandi]

Ciao di nuovo! 
Sai che non riesco ad usare l'applicazione nel mio telefono? Si avvia, appare un toast con uno zero come testo e lo schermo resta nero. Nel logcat mi dà continuamente "low memory" finché si chiude da sé senza dialog alcuno.
Il telefono è un Acer Liquid.

Codice: [Seleziona]

12-23 22:15:44.975: I/ActivityManager(312): Displayed test.gioco.ae/.Menu: +520ms (total +4s709ms)
12-23 22:15:45.125: D/libEGL(1854): loaded /system/lib/egl/libGLES_android.so
12-23 22:15:45.165: D/libEGL(1854): loaded /system/lib/egl/libEGL_adreno200.so
12-23 22:15:45.255: D/libEGL(1854): loaded /system/lib/egl/libGLESv1_CM_adreno200.so
12-23 22:15:45.255: D/libEGL(1854): loaded /system/lib/egl/libGLESv2_adreno200.so
12-23 22:15:45.335: D/AndEngine(1854): onSurfaceCreated
12-23 22:15:45.335: D/AndEngine(1854): RENDERER: Adreno 200
12-23 22:15:45.335: D/AndEngine(1854): VERSION: OpenGL ES-CM 1.1
12-23 22:15:45.335: D/AndEngine(1854): EXTENSIONS: GL_AMD_compressed_3DC_texture GL_AMD_compressed_ATC_texture GL_OES_EGL_image GL_OES_blend_equation_separate GL_OES_blend_func_separate GL_OES_blend_subtract GL_OES_compressed_ETC1_RGB8_texture GL_OES_compressed_paletted_texture GL_OES_draw_texture GL_OES_framebuffer_object GL_OES_matrix_palette GL_OES_point_size_array GL_OES_point_sprite GL_OES_read_format GL_OES_stencil_wrap GL_OES_texture_cube_map GL_OES_texture_env_crossbar GL_OES_texture_mirrored_repeat
12-23 22:15:45.335: D/AndEngine(1854): EXTENSIONS_VERXTEXBUFFEROBJECTS = true
12-23 22:15:45.335: D/AndEngine(1854): EXTENSIONS_DRAWTEXTURE = true
12-23 22:15:45.335: D/AndEngine(1854): onSurfaceChanged: pWidth=480  pHeight=800
12-23 22:15:45.405: D/dalvikvm(1854): GC_EXTERNAL_ALLOC freed 66K, 49% free 2886K/5639K, external 33K/513K, paused 55ms
12-23 22:15:45.545: D/dalvikvm(1854): GC_EXTERNAL_ALLOC freed 17K, 50% free 2869K/5639K, external 33K/2433K, paused 47ms
12-23 22:15:45.845: D/dalvikvm(1854): GC_EXTERNAL_ALLOC freed 1K, 50% free 2869K/5639K, external 33K/545K, paused 33ms
12-23 22:15:45.925: D/dalvikvm(1854): GC_EXPLICIT freed <1K, 50% free 2868K/5639K, external 33K/1057K, paused 34ms
12-23 22:15:48.115: D/dalvikvm(1854): GC_CONCURRENT freed 321K, 49% free 3021K/5831K, external 33K/1057K, paused 4ms+7ms
12-23 22:15:48.305: D/dalvikvm(1854): GC_FOR_MALLOC freed 130K, 49% free 3059K/5959K, external 33K/1057K, paused 27ms
12-23 22:15:48.385: D/dalvikvm(1854): GC_FOR_MALLOC freed 21K, 47% free 3259K/6087K, external 33K/1057K, paused 33ms
12-23 22:15:54.385: I/WindowManager(312): WIN DEATH: Window{408c9c10 SurfaceView paused=false}
12-23 22:15:54.435: I/ActivityManager(312): Process android.process.acore (pid 1923) has died.
12-23 22:15:54.445: I/WindowManager(312): WIN DEATH: Window{4088b188 test.gioco.ae/test.gioco.ae.Menu paused=false}
12-23 22:15:54.485: I/ActivityManager(312): Low Memory: No more background processes.
12-23 22:15:54.495: I/ActivityManager(312): Low Memory: No more background processes.
12-23 22:15:54.505: I/ActivityManager(312): Low Memory: No more background processes.


[Zate]

Il toast 0 è il punteggio più alto. Provo a mandarti una versione che parte direttamente dal gioco, ma dubito possa cambiare qualcosa...
Multiupload.com - upload your files to multiple file hosting sites!
Se non funziona prova ad "alleggerire" un po' il codice togliendo gli autoparallaxbackground.
E quest'ultima è la versione senza autoparallaxbackground (spero che funzioni :S)
Multiupload.com - upload your files to multiple file hosting sites!

[Verandi]

Senza background funziona, anche se appena la pallina cade mi va in force close. L'errore immagino sia dovuto al fatto che hai tolto il punteggio,  perché è un nullpointer nel metodo Score.submitTo() di openfeint, che è all'interno di postDistanceLeaderBoard a sua volta richiamato nel finishGame.
Comunque sono riuscito a provare e ho capito cosa intendi: il body nel world "fisico" è giusto, ma visualizza solo l'ultimo segmento della linea nella scena.
Vuoi una linea curva, giusto? Quindi mi sa che devi per forza utilizzare l'object pool per salvarne i segmenti.
Nella seconda soluzione, visualizzi solo l'ultima parte della linea perché semplicemente la sposti. Infatti nell'onLoadScene allochi una linea (un segmento) e l'aggiungi alla scena, mentre a te serve aggiungerne una nuova ad ogni movimento del dito e non spostare quell'unico segmento.
Usando il pool, invece, la logica dovrebbe essere questa:
- Il gioco parte e disegno una linea di 10 segmenti: il pool è vuoto, quindi alle 10 richieste di 10 segmenti, ne creerà 10.
- La palla rimbalza: dico all'object pool che può riciclare i 10 segmenti, quindi, di suo, li nasconde.
- Disegno un'altra linea di 5 segmenti: il pool ne ha 10 al suo interno, quindi ad ogni richiesta prenderà uno di quei 10 segmenti e alla fine 5 resteranno inutilizzati.
- La palla rimbalza: vedi secondo punto.
- Disegno ancora una linea, ma di 13 segmenti: il pool ne ha dieci, quindi alla richiesta di un'undicesimo, dodicesimo e tredicesimo segmento, ne creerà di nuovi.
- E così via, ottenendo un pool di dimensioni dinamiche.
I vantaggi di questa sorta di "cache dinamica" sono un risparmio di cpu perché crei segmenti solo quando ne hai bisogno (inizio del gioco o linea più lunga di tutte le precedenti), e non hai lag perché il garbage collector non entra in azione.

Secondo me, hai lo stesso problema anche nel caso dell'object pool perché si trova a contenere sempre un solo segmento, in quanto (credo) ricicli i segmenti appena li hai disegnati, mentre devi riciclarli quando l'utente ha finito di disegnare la linea. Può essere?
 

[Zate]

Sì, va in crash perché, iniziando dal gioco, non hai attivato openfeint. Quindi è normale.
Ed ogni segmento consiste in una linea (Line), giusto? Quello che intendi dire è di partire con più linee invece che una sola e poi di usare un counter per fare in modo che se, per esempio se counter == 1 usa line, se counter == 2 usa line2, se counter == 3 usa line3 ecc.? Penso di aver capito male...

[Verandi]

Scusa, probabilmente mi sono espresso male io. 
Io con linea intendo la curva intera, ovvero quello che l'utente disegna da quando tocca lo schermo a quando stacca il dito. Con segmento intendo l'entity line, ovvero ogni segmento che l'utente va a creare quando sposta il dito sullo schermo e che va ad aggiungersi alla curva.
Ora scriverò "line" per l'entity line e "curva" per la curva finale disegnata dall'utente, che in realtà è un insieme di line.

Quello che ho scritto nel post precedente è che ti conviene usare il pool, come hai fatto e come suggeriva Bradipao. Il pool si occuperà da solo di creare line nuove, se servono, o di dartene una che aveva già creato ma al momento è inutilizzata (riciclata). Nell'onLoadResources basta solo che inizializzi il pool proprio come hai scritto nel codice nel codice che hai postato.
Però dovrai gestirne tu il riciclo, ovvero dovrai dire tu al pool che deve riciclare le linee che non ti servono più. E, se non sbaglio, a te non servono più quando c'è stato un rimbalzo della palla sulla curva, giusto? Quindi, a collisione avvenuta, per ogni line presente nella scena richiami il metodo sendLineToLinePool(line). Spero di essere stato più chiaro.