5 Ways to be a Successful Indie Developer

1: Don't do it alone

2: Focus on your strengths

3: Begin by working on lots of smaller games rather than a huge and lengthy project

4: Focus on what the big publishers are missing

5: Improve with each game

Source: http://indiegames.com/2012/06/5_ways_to_be_a_successful_indi.html

40 STEPS FOR DEVELOPING A SHOOTER GAME

STEP 1 - Plan Game Idea

STEP 2 - Select the Target Market

STEP 3 - Choose the Revenue/Business Model

STEP 4 - Define the Game on Paper

STEP 5 - Define Characters and Backgrounds

STEP 6 - Specify Features, Scenes and Details

STEP 7 - Create a Game Design Document

STEP 8 - Game Setup in Game Engine

STEP 9 - Create a Level Scene

STEP 10 - Set the Level's Camera and Light

STEP 11 - Set Background and Its Texture and Scrolling (if applicable)

STEP 12 - Set Player Object and Its Movement

STEP 13 - Develop Player Gun and Shooting

STEP 14 - Develop Enemy Object

STEP 15 - Develop Collision between Enemy and Player Bullet

STEP 16 - Develop Explosion Particle Effect and Sound for Collisions

STEP 17 - Develop Enemy Gun and Shooting

STEP 18 - Develop Player Collision with Enemy Bullet

STEP 19 - Develop Enemy Movement

STEP 20 - Power Up Object and Collision

STEP 21 - Power Up Sound and Multiple Guns/Bullets

STEP 22 - Power Up Functionality

STEP 23 - Setup Remaining Lives and Its Counter

STEP 24 - Setup Invincibility Delay

STEP 25 - Develop Player Collision with Enemy Object

STEP 26 - Total Score Setup

STEP 27 - Individual Points Setup

STEP 28 - Setup Game Over Condition

STEP 29 - Game Menu Setup

STEP 30 - Enemy Spawning Setup

STEP 31 - Setup Enemy Firing Frequency

STEP 32 - Setup Enemy Dropped Power Ups

STEP 33 - Develop Gift Object One; e.g. Coin

STEP 34 - Develop Gift Shooter/Distributer

STEP 35 - Gift Spawning Setup

STEP 36 - Setup Gift Frequency

STEP 37 - Develop Gift Collection

STEP 38 - Develop Gift Collection Impacts on Assets and Lives

STEP 39 - Develop Win Condition

STEP 40 - Bug Fix

21 STEPS FOR EMPLOYING OPENGL ES IN ANDROID

STEP 1

In the Activity declare a GLSurfaceView variable; for example:

private GLSurfaceView glSurfaceView;

STEP 2

In the onCreate event of the Activity set the GLSurfaceView variable, set OpenGL its version, and then set its renderer:

            glSurfaceView = new GLSurfaceView(this);
     glSurfaceView.setEGLContextClientVersion(2);
     glSurfaceView.setRenderer(new CubeRenderer(this));

STEP 3

In the Renderer, declare a Context variable:

            private final Context context;

STEP 4

In the constructor of the renderer, set the context:

            this.context = context;

STEP 5

Create a ByteBuffer object, and put the data provided for all the vertices in it:

            private final FloatBuffer vertexData;

     vertexData = ByteBuffer.allocateDirect(data.length * BYTES_PER_FLOAT)

                                    .order(ByteOrder.nativeOrder()).asFloatBuffer();

     vertexData.put(data);

STEP 6

In the onSurfaceCreated event of the Renderer, set:

     glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

     glEnable(GL_BLEND);

     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

STEP 7

Read the source of shaders:

     String vertexShaderSource = TextResourceReader

.readTextFileFromResource(context, R.raw.simple_vertex_shader);

     String fragmentShaderSource = TextResourceReader

                     .readTextFileFromResource(context, R.raw.simple_fragment_shader);

STEP 8

Compile the shader sources:

     int vertexShader = ShaderHelper.compileVertexShader(vertexShaderSource);

     int fragmentShader = ShaderHelper.compileFragmentShader(fragmentShaderSource);

STEP 9

Link the compiled code to create a Program:

            private int program;

     program = ShaderHelper.linkProgram(vertexShader, fragmentShader);

STEP 10

Ask OpenGL to use the program:

            glUseProgram(program);

STEP 11

Get the Uniform, Attribute, and Color positions from OpenGL:

     uMatrixLocation = glGetUniformLocation(program, U_MATRIX);

aPositionLocation = glGetAttribLocation(program, A_POSITION);

     aColorLocation = glGetAttribLocation(program, A_COLOR);

STEP 12

Set the Model matrix as unit, and  then, if it is required rotate it:

           setIdentityM(modelMatrix, 0);

          

           rotateM(modelMatrix, 0, -45f, 1f, 0f, 0f);

STEP 13

Set the Projection matrix:

MatrixHelper.perspectiveM(projectionMatrix, 45, (float) width / (float) height, 1f, 10f);

STEP 14

Set the View matrix:

setLookAtM(viewMatrix, 0, 0f, 1.2f, 2.2f, 0f, 0f, 0f, 0f, 1f, 0f);

STEP 15

Set the View Projection matrix:

multiplyMM(viewProjectionMatrix, 0, projectionMatrix, 0, viewMatrix, 0);

STEP 16

Set the Model View Projection matrix:

multiplyMM(modelViewProjectionMatrix, 0, viewProjectionMatrix, 0, modelMatrix, 0);

STEP 17

Set the Uniform Matrix for Location using the Model View Projection matrix:

glUniformMatrix4fv(uMatrixLocation, 1, false, modelViewProjectionMatrix, 0);

STEP 18

Bind data to the Position location, and enable it:

vertexData.position(0);

glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT,GL_FLOAT, false, STRIDE,
                                                                  vertexData);

     glEnableVertexAttribArray(aPositionLocation);

STEP 19

Bind data to the Color location, and enable it:

     vertexData.position(POSITION_COMPONENT_COUNT);

     glVertexAttribPointer(aColorLocation, COLOR_COMPONENT_COUNT, GL_FLOAT,     false, STRIDE,
                                                                     vertexData);

     glEnableVertexAttribArray(aColorLocation);

STEP 20

In the onDrawFrame event of the Renderer, clear the rendering surface:

glClear(GL_COLOR_BUFFER_BIT);

STEP 21

In the onDrawFrame event of the Renderer, draw all the arrays:

glDrawArrays(GL_TRIANGLES, 0, 18);