Android Canvas o Open GL ES para el juego 2d?

Quiero crear un juego 2d y me gustaría saber qué camino seguir teniendo mi conocimiento de fondo y algunos detalles sobre el juego en sí.

Mi experiencia (el material relevante):

  • Comencé a aprender la programación del androide hace 10 días, he hecho el menú del juego.

  • Tengo una buena cantidad de experiencia de programación en java (para escritorio).

  • Tengo una cierta experiencia en el pasado con openGL en C ++, pero solamente haciendo la materia 3d (también no recuerdo muchas cosas que aprendí). Nunca he programado ningún shaders GL abierto. Aprendí cosas como transformaciones básicas como rotaciones / escalamiento / traducción, aplicación de texturas (coordenadas de textura), y algunas cosas de luces muy primitivas.

El juego se supone que tiene:

  • Sprites. + -50 promedio visible por fotograma.

  • Pellizca para hacer gestos de zoom / panorámica.

  • Esta característica: Ser capaz de mover por ejemplo un sprite a otro lugar, usando el dedo para dibujar el camino a seguir. Esto debería ser posible en cualquier nivel de zoom.

  • Sonidos. Tiros, explosiones, simples sonidos cortos.

  • Como un bono sería bueno tener algunos efectos como líneas con brillo, efectos de urdimbre, etc, pero esto realmente no es necesario.

  • Debe haber maneras simples de dibujar formas geométricas como círculos / cuadrados / triángulos / etc (me refiero no en el juego de sí mismo, pero en la API se utiliza para desarrollarlo)

Me gustaría terminar el juego en 1/2 meses.

Ahora, ¿qué crees que sería la mejor solución dada las características del juego, mi fondo y el tiempo disponible? ¿OpenGL ES 2.0? ¿Lona? O API / gráficos / motores de juego / bibliotecas (cuáles, y hay documentación / tutoriales?)?

El juego en sí es simple. Las cosas que he mencionado son realmente las cosas grandes aquí, al menos para mí.

Ejemplos de juegos que comparten características con la mía serían: Osmos , Spirit

3 Solutions collect form web for “Android Canvas o Open GL ES para el juego 2d?”

En primer lugar, Canvas no es incapaz de hacer un juego. Sin embargo, si usted mira el juego que hice enteramente con la lona "guerras de la ardilla" (en el mercado), ése es sobre las limitaciones de un juego usando la lona en un dispositivo medio.

Los problemas con el uso de Canvas son limitaciones de la memoria con la que usted tiene que trabajar, y las limitaciones del FPS, ya que no es hardware acelerado.

La mayor limitación y una de mis razones para cambiar a OpenGL ES 1.1 es que OpenGL lo hará mucho más fácil de portar a iOS si es necesario.

También usando OpenGL ES usted tendrá mucho más poder sobre lo que usted hace, mucho más control, y debe ser suficiente para sostener un muchos sprites como usted podría caber en la pantalla con hacia fuera atascándola.

En mi actual juego Open GL estoy diseñando, soy capaz de hacer 300-400 sprites un marco a 25-32 FPS.

Sin embargo, al limitar el dibujo de sprites a lo que está en la pantalla, más como 20-50, sostener a unos 60-70 FPS.

Hay una curva de aprendizaje con OpenGL sin embargo, pero vale la pena aprender. Tengo un 2D FrameWork que diseñé en 2Days de ser introducido y de investigar el asunto, y satisface todas mis necesidades 2D perfectamente.

Ahora puedo reutilizar mi FrameWork para cualquier juego en 2D que pueda querer diseñar.

Sin dar mucho de aquí es un código para empezar

import android.app.Activity; import android.opengl.GLSurfaceView; import android.os.Bundle; import android.util.Log; import android.view.MotionEvent; import android.view.Window; import android.view.WindowManager; public class RunGameActivity extends Activity{ private GLSurfaceView glSurfaceView; private GLRenderer GLRENDERER; @Override public void onCreate(Bundle savedInstanceState) { /***************************************************************************************** * This is called when this activity is first creates. * First we remove the title bar, make our app full screen * It is set to landscape in the manifest file. * We than create our OPENGL ES surfaceview and its renderer for us to use * and finally setContentView() view so we see the OPENGL ES surfaceview * ***************************************************************************************/ requestWindowFeature(Window.FEATURE_NO_TITLE); getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN); super.onCreate(savedInstanceState); Log.d("RunGameActivity", "onCreate"); glSurfaceView = new GLSurfaceView(this); GLRENDERER = new GLRenderer(this); glSurfaceView.setRenderer(GLRENDERER); setContentView(glSurfaceView); } @Override public boolean onTouchEvent(MotionEvent event) { /***************************************************************************************** * Here we get the incoming on touch event and send it down towards our game * via the GLRenderer class. The game does all the actual work with it. * ***************************************************************************************/ Log.d("RunGameActivity", "OnTouchEvent"); synchronized(this) { GLRENDERER.HandleMotionEvent(event); } return true; } /* Remember to resume the glSurface */ @Override protected void onResume() { /***************************************************************************************** * Called when app resumes * ***************************************************************************************/ super.onResume(); glSurfaceView.onResume(); Log.d("RunGameActivity", "onResume"); } /* Also pause the glSurface */ @Override protected void onPause() { /***************************************************************************************** * Called when app pauses * ***************************************************************************************/ super.onPause(); glSurfaceView.onPause(); Log.d("RunGameActivity", "onPause"); } 

}

Realmente no quiero regalar todo, vale la pena APRENDER

Pero he creado una manera para mí de manejar todo de una manera muy organizada, desde la creación de vértices, texturas, texto dinámico, a la manipulación de entrada, simulando una "Cámara" gestionar la velocidad de cuadros movimiento independiente, el manejo de la gravedad Cuando lo necesito, la detección de colisión , Y la animación de sprites. Por no mencionar, el manejo de los anuncios de AdMob, inAppBilling, y todo el sonido que necesite nunca.

Sólo empieza a leer. Está en toda la web, y en los libros. Vale la pena la inversión de $ 40 si puedes encontrar un buen libro.

Una gran parte del código que tendrá que crear personalizado a ti mismo. Pero vale la pena configurar su propio marco.

Nuevamente recomiendo OpenGL 1. * Compatible en todos los dispositivos que usted podría desear también.

Para empezar con el código que te di, copie pegarlo en su actividad, haga clic derecho en los objetos, y crear sus clases. Eclipse se auto decir / llenar un montón de las cosas básicas para usted.

Si desea incluir dispositivos pre Android 3.0, no utilizaría el lienzo. No es hardware acelerado, por lo que obtendrá realmente terrible tasas de fotogramas.

Hice un poco de experimentación con lienzo en mi dispositivo Android 2.3, e incluso con un procesador de gama alta no pude obtener un cuadrado con textura para deslizarse a través de la pantalla sin tartamudez severa.

Android 3 y 4 tienen vistas aceleradas de hardware, pero para 2,3 creo que realmente necesita la utilización de la GPU para hacer cualquier cosa remotamente jugable. Probablemente puede olvidarse de efectos especiales (partículas, brillos, etc.) si no tiene aceleración de GPU.

OpenGL Creo que es la manera de ir aquí, o puede utilizar una librería OpenGL (AndEngine parece popular) si no quiere tratar con la API usted mismo.

Yo sugeriría usar AndEngine para hacer juegos. Es acelerado por hardware (utiliza OpenGL ES) y proporciona una buena API para manipular sprites.

  • La textura transparente de Android OpenGL dibuja negro
  • ¿Hay algún dispositivo Android con un tamaño de pantalla mayor que GL_MAX_TEXTURE_SIZE?
  • Cómo configurar el color de fondo en Open GL ES Android
  • Android NDK OpenGL ES 2.0 Tono de textura
  • Cómo y comprensión del evento de arrastre y zoom con GLSurfaceView
  • Android: ¿Cómo crear VR-controles parecidos a YouTube?
  • Dibuja Pixel con OpenGLEs para Android
  • Limitación del tamaño de la textura? Android Open GL ES 2.0
  • ¿Mejor velocidad de cuadro que dibuja los mapas de bits en una lona?
  • OpenGL (ES) - ¿Cuál es la diferencia entre frustum y ortho?
  • ¿Cómo tratar con diferentes relaciones de aspecto en libGDX?
  • FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.