Programmer

EMIL STRÖM

Platform

Engine

Language

Development Time

Team Size

Android

OpenGL ES

Java

2 months

Solo

Google Play

Source

Sling Ball

Sling Ball is a solo project shipped to Google Play. The game features very simple mechanics and goals with heavy focus on gamefeel and player feedback.

The player interacts with the game by dragging their finger at the bottom of the screen then releasing it, which fires a bullet in the desired direction. The objective of the game is to shoot balls that spawn at the top of screen before they exit the screen at the bottom.

The game then tracks how many balls have been destroyed.

The game received very positive feedback on Google Play shortly after launch.

The Engine

The rules of Sling Ball are fairly straighforward and unchanging. This is delibirate to make coding the engine a lot faster.

There is not much to the engine except the communication with OpenGL. Everything else, such as gravity and bouncing, is hard-coded into the classes of the program.

Code

Sprite.java (Excerpt)

public void bindAttributes() {
	GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vertexBufferObject);

	a_position = GLES20.glGetAttribLocation(shaderProgram, "a_vertexPosition");
	a_texturePosition = GLES20.glGetAttribLocation(shaderProgram, "a_texturePosition");

	u_mvp = GLES20.glGetUniformLocation(shaderProgram, "u_mvpMatrix");
	u_color = GLES20.glGetUniformLocation(shaderProgram, "u_color");
	u_texture = GLES20.glGetUniformLocation(shaderProgram, "u_texture");
	u_alphaColor = GLES20.glGetUniformLocation(shaderProgram, "u_alphaColor");

	GLES20.glEnableVertexAttribArray(a_position);
	GLES20.glEnableVertexAttribArray(a_texturePosition);

	GLES20.glVertexAttribPointer(a_position, 3, GLES20.GL_FLOAT, false, 5 * 4, 0);
	GLES20.glVertexAttribPointer(a_texturePosition, 2, GLES20.GL_FLOAT, false, 5 * 4, 3 * 4);
}

public void initDraw() {
	GLES20.glUseProgram(shaderProgram);
	GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vertexBufferObject);
	bindAttributes();
}

public void setColor(Color c) { spriteColor.copy(c); }
public void setColor(double r, double g, double b, double a) {
	spriteColor.copy(r, g, b, a);
}

public void setAlphaColor(Color c) { alphaColor.copy(c); }
public void setAlphaColor(double r, double g, double b) {
	alphaColor.copy(r, g, b, 1.0);
}

public void reset() {
	Matrix.setIdentityM(modelMatrix, 0);
}

public void translate(double x, double y, double z) {
	Matrix.translateM(modelMatrix, 0, (float)x, (float)y, (float)z);
}

public void translate(Vertex v) {
	Matrix.translateM(modelMatrix, 0, (float)v.x, (float)v.y, 0f);
}

public void rotate(double a) {
	Matrix.rotateM(modelMatrix, 0, (float)a, 0f, 0f, 1f);
}

public void scale(double sx, double sy, double sz) {
	Matrix.scaleM(modelMatrix, 0, (float)sx, (float)sy, (float)sz);
}

public void scale(Vertex v) {
	Matrix.scaleM(modelMatrix, 0, (float)v.x, (float)v.y, 0f);
}

public void setPosition(float x, float y, float z) {
	reset();
	translate(x, y, z);
}

public void setPosition(Vertex v) {
	reset();
	translate(v);
}

public float[] getMVPMatrix() {
	float ret[] = new float[16];
	Matrix.multiplyMM(ret, 0, Game.viewProjection, 0, modelMatrix, 0);

	return ret;
}
	
public void uploadData() {
	//spriteColor.confine();
	alphaColor.confine();

	GLES20.glUniformMatrix4fv(u_mvp, 1, false, getMVPMatrix(), 0);

	//Load texture
	GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
	GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textureHandler);
	GLES20.glUniform1i(u_texture, 0);

	GLES20.glUniform4f(u_color, (float)spriteColor.r, (float)spriteColor.g, (float)spriteColor.b, (float)spriteColor.a);
	GLES20.glUniform3f(u_alphaColor, (float)alphaColor.r, (float)alphaColor.g, (float)alphaColor.b);
}

public void draw() {
	uploadData();
	GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
}

Goals

Ship a game on Google Play

I wanted to plan out and execute a full project from idea to working software

available on Google Play.

Write an app from scratch with Java, OpenGL ES and the Android API

I had worked with OpenGL and C++, but wanted experience working on a different platform with different code structure.

Why is it fun?

The game went through several iteration stages, and I found that there were some main pillars that my game was based on. The most important were:

Shooting and hitting balls should be inherently fun

Improving at the game is why players want to come back

There should be ways for the player to explore the physics of

the game, and feel smart when they do something non-trivial

When iterating I always sought to improve on each of these points. If the things I added or tweaked didn't point in the direction of these pillars, I removed it.