X STEPS FOR DEVELOPING A SLOT GAME

Plan Game Idea

Select the Target Market

Choose the Revenue/Business Model

Define the Game on Paper

Define Mini Games on Paper

Define Scatters Leading to each Mini Game on Paper

Create a Game Design Document

Define Wining Lines on Spinning Reels

Define Credit/Coins System

Define Awards for Wining Lines

Define Boosters for Awards

Define Levels

Define Limits for Bets for each Level

Define Awards for Winning in Mini Games

Define the System for Buying/Earning Credits/Coins

Define Collectibles

Define a Trading System for Converting Collectibles to Credits

Define Backgrounds and Images for Spinning Reels

Specify Features, Scenes and Details

Define Special Effects for Winning

Define Sounds for Background, Reeling, and Winning

Game Setup in Game Engine

Create a Level Scene

Set the Level's Camera and Light

Set Background and Its Texture for the Game

Create a Scene for each Mini Game

Set the Camera and Light for each Mini Game

Set Background and Its Texture for each Mini Game

[continued ...]

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

...

ASP.NET is a web application framework developed and marketed by Microsoft to allow programmers to build dynamic web sites, web applications and web services. It was first released in January 2002 with version 1.0 of the .NET Framework, and is the successor to Microsoft's Active Server Pages (ASP) technology.

in progress ...

The Open Group Architecture Framework (TOGAF) is a framework for enterprise architecture which provides a comprehensive approach to the design, planning, implementation, and governance of an enterprise information architecture.

in progress 11

in progress 11