BAB 9 Project Pilihan

(1)

9.1 Random Maze

9.1.1 Konsep

Random Maze merupakan permainan yang mengedepankan

strategi untuk mencari jalan keluar dengan cepat, tanpa tersesat pada

jalan yang buntu. Pertama ketika aplikasi dijalankan, maka map dari

daerah pencarian akan dirandom dengan ukuran tertentu. Pada

kondisi awal, letak dari agen berada di posisi start, dan tujuan

akhirnya adalah posisi goal. Untuk menggerakkan agen (yang

berbentuk segitiga), tombol control dibagian kanan bawah dapat

digunakan untuk melakukan hal tersebut.

9.1.2 Tampilan Implementasi

Aplikasi ini mengimplementasikan primitive object, texture

map-ping, pencahayaan dengan tampilan objek garis, segitiga, segiempat,

bola, counter pantulan bola, serta dengan tombol control yang

diberikan texture tertentu untuk memindahkan objek (agen) dalam

mencari solusi pencarian jalan keluar. Berikut ini beberapa visualisasi

dari permainan Random Maze, mulai dari adanya background

(gambar, fractal), tombol control, animasi objek bergerak, efek

pencahayaan, sampai pada log posisi track sentuhan tangan pada

layar.

(2)

Gambar 9.2 Random Maze dengan Background Abu-Abu

Gambar 9.3 Random Maze Background Gambar

(3)

9.1.3 Source Code

Source Code 9.1 Code Random Maze

ESRender.java

package com.fractalbackground;

import javax.microedition.khronos.egl.EGLConfig; import javax.microedition.khronos.opengles.GL10; import android.content.Context;

import android.opengl.GLSurfaceView.Renderer; public class ESRender implements Renderer {

private ESText glText;

private PrimitivesObject primobbg; private PrimitivesObject primobflappy; private PrimitivesObject primobground; private PrimitivesObject primob1; private PrimitivesObject primob3; private ObjectBall objectball2; //private ObjectBall objectball3; private ObjectBall objectballstick; //private ObjectBall objectballstickdua; private ObjectBall objectballbgstick; private PrimitivesObject primob; //private PrimitivesObject primob2; private TransObject transobject;

private final MySphere mEarth,mEarth2,mEarth3; Context context;

int Run_Mode=0;

float CurrentAngle = 0.0f; // Angle in degrees

float CurrentAngle2 = 0.0f; // Angle in degrees

float AnimateStep = 2.0f; // Rotation step per update

float AnimateStep2 = 0.2f; // Rotation step per update

float ScaleStep = 1.0f;

private float move_left_right1 =0.f; private float move_left_right2 =0.f; private float kecepatan_ground = 5.0f; private int faktor_naik_turun=0; private int flag_naik=1;

(4)

private long fpsElapsed_temp; private long numFrames_temp;

private boolean startTimeInit=true;

private long fpsStartTime2; private long numFrames2; private int numIDFrame=0; float CurrentScale =1.0f;

float radius = 50.0f; // Ball's radius float x = radius; // Ball's center (x,y) float y = radius;

float speedX = 0.5f; // Ball's speed (x,y) float speedY = 0.3f;

int xMin, xMax, yMin, yMax; private int mywidth = 0; private int myheight = 0; private int jumlah_pantulan=0; private float x_player = 0; private float y_player = 0; private float x_player_end = 0; private float y_player_end = 0; private int Navigate = 0; private int positionRow = 0; private int positionCol = 0; //private int hori[][] = new

int[2*primob.numberRow*primob.numberCol][2*primob.num berRow*primob.numberCol];

//private int verti[][] = new

int[2*primob.numberRow*primob.numberCol][2*primob.num berRow*primob.numberCol];

private int hori[][] = new int[1000][1000]; private int verti[][] = new int[1000][1000]; private int numberCol =0;

(5)

private float jarak_center = 0; private String arah_joystick=""; boolean get_size_screen=true; private float x_graf = 0; private float y_graf = 0;

int[] textures_indek = new int[1];

float black[] = new float[] { 0.0f, 0.0f, 0.0f, 1.0f };

float yellow[] = new float[] { 1.0f, 1.0f, 0.0f, 1.0f };

float cyan[] = new float[] { 0.0f, 1.0f, 1.0f, 1.0f };

float white[] = new float[] { 1.0f, 1.0f, 1.0f, 1.0f };

float diffuseMaterial[] = new float[] { 0.73f, 0.13f, 0.86f, 1.0f }; // set cahaya warna ungu

float diffuseMaterial2[] = new float[] { 0.5f, 0.5f, 0.5f, 1.0f }; // set cahaya warna ungu

float lightAmbient[] = new float[] { 0.2f, 0.3f, 0.6f, 1.0f };

float mat_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };

float light_position[] = { 0.0f, 0.0f, 1.0f, 0.0f };

float light_position2[] = { 0.0f, 0.0f, 1.0f, 0.0f };

/** Constructor to set the handed over context */ public ESRender(Context context) {

// super();

this.context = context;

this.primobbg = new PrimitivesObject(); this.primobflappy = new

PrimitivesObject();

this.primobground = new PrimitivesObject();

this.primob1 = new PrimitivesObject(); this.primob3 = new PrimitivesObject(); this.objectball2 = new ObjectBall(); //this.objectball3 = new ObjectBall(); this.objectballstick = new ObjectBall(); this.objectballbgstick = new

ObjectBall();

this.primob = new PrimitivesObject(); //this.primob2 = new PrimitivesObject(); this.mEarth = new MySphere(5, 3);

(6)

this.x_player = primob.x_player; this.y_player = primob.y_player;

this.x_player_end = primob.x_player_end; this.y_player_end = primob.y_player_end; this.positionRow = primob.positionRow; this.positionCol = primob.positionCol; this.hori = primob.hori;

this.verti = primob.verti;

this.numberCol = primob.numberCol; this.numberRow = primob.numberRow; this.WidthObject = primob.WidthObject;

}

@Override

public void onDrawFrame(GL10 gl) { // menangkap ukuran layar if(get_size_screen){

this.x_lebar_layar = mywidth; this.y_tinggi_layar = myheight; get_size_screen=false;

}

// Draw background color

gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);

// gl.glClear(GL10.GL_COLOR_BUFFER_BIT); gl.glEnable(GL10.GL_DEPTH_TEST);

gl.glEnable(GL10.GL_NORMALIZE); //gl.glLoadIdentity();

//gl.glMaterialfv(GL10.GL_FRONT,

GL10.GL_AMBIENT_AND_DIFFUSE, makeFloatBuffer(cyan)); //gl.glMaterialfv(GL10.GL_FRONT,

GL10.GL_SPECULAR, white,0);

//gl.glMaterialfv(GL10.GL_FRONT, GL10.GL_SHININESS, white,0);

//gl.glMaterialfv(GL10.GL_FRONT, GL10.GL_DIFFUSE, white,0);

// multi light

/*float light1_ambient[] = { 0.2f, 0.2f, 0.2f, 1.0f };

float light1_diffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f };

float light1_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };

float light1_position[] = { -2.0f, 2.0f, 1.0f, 1.0f };

float spot_direction[] = { -1.0f, -1.0f, 0.0f };

*/

(7)

GL10.GL_AMBIENT, light1_ambient,0); gl.glLightfv(GL10.GL_LIGHT1, GL10.GL_DIFFUSE, light1_diffuse,0);

gl.glLightfv(GL10.GL_LIGHT1, GL10.GL_SPECULAR, light1_specular,0);

gl.glLightfv(GL10.GL_LIGHT1, GL10.GL_POSITION, light1_position,0);

gl.glLightf(GL10.GL_LIGHT1, GL10.GL_CONSTANT_ATTENUATION, 1.5f);

gl.glLightf(GL10.GL_LIGHT1, GL10.GL_LINEAR_ATTENUATION, 0.5f);

gl.glLightf(GL10.GL_LIGHT1, GL10.GL_QUADRATIC_ATTENUATION, 0.2f);

gl.glLightf(GL10.GL_LIGHT1, GL10.GL_SPOT_CUTOFF, 45.0f);

gl.glLightfv(GL10.GL_LIGHT1, GL10.GL_SPOT_DIRECTION, spot_direction,0);

gl.glLightf(GL10.GL_LIGHT1, GL10.GL_SPOT_EXPONENT, 2.0f);

gl.glEnable(GL10.GL_LIGHT1);*/ //end multi light

//

//membuat background gl.glPushMatrix();

gl.glDisable(GL10.GL_LIGHTING); gl.glScalef(x_lebar_layar, y_tinggi_layar, 1.0f);

primobbg.draw_background(gl); gl.glEnable(GL10.GL_LIGHTING); gl.glPopMatrix();

int x_lebar_layar_temp=(int)

(Math.ceil(x_lebar_layar/kecepatan_ground)*kecepatan_ ground);

//membuat ground 1 flappy gl.glPushMatrix();

gl.glDisable(GL10.GL_LIGHTING); gl.glTranslatef(move_left_right1, 0.f, 0.f);

gl.glTranslatef(0, -50.f, 0.f);

gl.glScalef(x_lebar_layar_temp, 1.5f*y_tinggi_layar/10, 1.0f);

primobground.draw_background(gl);

gl.glEnable(GL10.GL_LIGHTING); gl.glPopMatrix();

move_left_right1-=kecepatan_ground;

(8)

}

//membuat ground 2 flappy gl.glPushMatrix();

gl.glDisable(GL10.GL_LIGHTING);

gl.glTranslatef(move_left_right2, 0.f, 0.f);

gl.glTranslatef(x_lebar_layar_temp, 0.f, 0.f); gl.glTranslatef(0, -50.f, 0.f); gl.glScalef(x_lebar_layar_temp, 1.5f*y_tinggi_layar/10, 1.0f);

primobground.draw_background(gl); gl.glEnable(GL10.GL_LIGHTING);

gl.glPopMatrix();

move_left_right2-=kecepatan_ground;

if(-move_left_right2==2*x_lebar_layar_temp){ move_left_right2=0;

}

//membuat flappy bird

// Keep track of number of frames drawn

numFrames2++;

long fpsElapsed2 = System.currentTimeMillis() - fpsStartTime2;

if (fpsElapsed2 > 0.09 * 1000) { // every 5 seconds

float fps2 = (numFrames2 * 1000.0F) / fpsElapsed2;

//glText.draw( "Frames per second : "+ fps + " (" + numFrames + " frames in " + fpsElapsed + " ms)",150, 30); // Draw Test String

fpsStartTime2 = System.currentTimeMillis(); numFrames2 = 0;

gl.glPushMatrix();

gl.glBlendFunc(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);

gl.glEnable(GL10.GL_BLEND);

// mengatur naik turun gl.glTranslatef(0, faktor_naik_turun, 0.0f);

gl.glTranslatef(x_lebar_layar/2, y_tinggi_layar/2, 0.0f);

(9)

1.0f);

primobflappy.loadBallTexture2(gl, context, numIDFrame);

//gl.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);

primobflappy.draw_background(gl);

gl.glDisable(GL10.GL_BLEND);

numIDFrame++;

if(flag_naik==1){

faktor_naik_turun+=2; }else if(flag_naik==-1){ faktor_naik_turun-=2;

}

if(faktor_naik_turun%20==0){ flag_naik*=-1;

}

if(numIDFrame%8==0){ numIDFrame=0;

}

}else{

gl.glPushMatrix(); gl.glDisable(GL10.GL_LIGHTING); gl.glBlendFunc(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);

gl.glEnable(GL10.GL_BLEND);

// mengatur naik turun gl.glTranslatef(0, faktor_naik_turun, 0.0f);

gl.glTranslatef(x_lebar_layar/2, y_tinggi_layar/2, 0.0f);

gl.glScalef(x_lebar_layar/10, y_tinggi_layar/10, 1.0f);

primobflappy.loadBallTexture2(gl, context, numIDFrame);

//gl.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);

(10)

gl.glDisable(GL10.GL_BLEND);

}

//fractal mandelbrot /*gl.glPushMatrix();

gl.glDisable (GL10.GL_LIGHTING); gl.glTranslatef(550.0f, 200.0f, 0.0f);

//gl.glScalef(CurrentScale*5.0f, CurrentScale*5.0f, 1.0f);

gl.glScalef(60.0f, 60.0f, 1.0f);

//gl.glRotatef(CurrentAngle2, 0, 0, 1);

//

primob2.draw_fractal_mandelbrot(gl);

gl.glEnable (GL10.GL_LIGHTING); gl.glPopMatrix();*/

//fractal julia

/*gl.glPushMatrix();

gl.glScalef(100.0f, 100.0f, 1.0f);

gl.glRotatef(CurrentAngle2, 0, 0, 1);

//primob2.draw_fractal_julia(gl);

//fractal julia_m /*gl.glPushMatrix();

gl.glTranslatef(550.0f, 200.0f, 0.0f);

gl.glScalef(50.0f, 50.0f, 1.0f); //gl.glRotatef(CurrentAngle2, 0, 0, 1);

gl.glEnable(GL10.GL_POINT_SMOOTH); gl.glPointSize(1);

primob2.draw_fractal_julia_m(gl); gl.glEnable(GL10.GL_LIGHTING);

(11)

// bola 1

gl.glScalef(25.0f, 25.0f, 25.0f);

gl.glRotatef(CurrentAngle, 0, 1, 0);

mEarth.draw(gl);

// menampilkan object bola2 + lighting /*gl.glPushMatrix ();

gl.glTranslatef(600.0f, 200.0f, 0.0f); gl.glScalef(25.0f, 25.0f, 25.0f); gl.glTranslatef (0.0f, 0.0f, -5.0f);

gl.glPushMatrix ();

gl.glRotatef (CurrentAngle, 1.0f, 0.0f, 0.0f);

gl.glMaterialf(GL10.GL_FRONT, GL10.GL_SHININESS, 100.0f);

gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_POSITION, light_position,0);

gl.glLightfv (GL10.GL_LIGHT0, GL10.GL_DIFFUSE, white,0);

gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_AMBIENT, lightAmbient, 0);

gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_SPECULAR, white, 0);

gl.glTranslatef (0.0f, 0.0f, 3.5f);

gl.glDisable (GL10.GL_LIGHTING);

transobject.draw_kubus(gl);

gl.glEnable (GL10.GL_LIGHTING); gl.glPopMatrix ();

gl.glRotatef(CurrentAngle, 0, 1, 0); mEarth2.draw(gl);

gl.glPopMatrix (); */

// menampilkan object bola3 + lighting /*gl.glPushMatrix ();

gl.glTranslatef(mywidth-2*radius, myheight-4f*radius, 0.0f);

(12)

-5.0f);

gl.glPushMatrix ();

gl.glRotatef (CurrentAngle, 0.0f, 1.0f, 0.0f);

gl.glLightfv (GL10.GL_LIGHT0, GL10.GL_POSITION, light_position,0);

gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_DIFFUSE, white, 0);

gl.glEnable (GL10.GL_LIGHTING);

gl.glPopMatrix ();

gl.glPushMatrix ();

gl.glRotatef (-CurrentAngle, 0.0f, 1.0f, 0.0f);

gl.glLightfv (GL10.GL_LIGHT1, GL10.GL_POSITION, light_position,0);

gl.glLightfv(GL10.GL_LIGHT1, GL10.GL_DIFFUSE, white, 0);

gl.glEnable (GL10.GL_LIGHTING); gl.glEnable(GL10.GL_LIGHT0); gl.glEnable(GL10.GL_LIGHT1);

gl.glPopMatrix ();

(13)

mEarth3.draw(gl); gl.glPopMatrix (); gl.glLoadIdentity(); */

// cahaya bola ungu /*gl.glPushMatrix ();

gl.glTranslatef(mywidth-2*radius, myheight-1.2f*radius, 0.0f);

gl.glScalef(15.0f, 15.0f, 15.0f); gl.glTranslatef (0.0f, 0.0f, -5.0f);

gl.glPushMatrix (); gl.glRotatef (CurrentAngle, 1.0f, 0.0f, 0.0f);

gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_POSITION, light_position,0);

gl.glLightfv (GL10.GL_LIGHT0, GL10.GL_DIFFUSE,

diffuseMaterial,0);

gl.glEnable (GL10.GL_LIGHTING);

gl.glEnable(GL10.GL_LIGHT0);

gl.glDisable(GL10.GL_LIGHT1);

gl.glPopMatrix (); mEarth2.draw(gl); gl.glPopMatrix ();

*/

// menampilkan persegi dengan gradasi warna

(14)

gl.glTranslatef(0.0f, 0.0f, -5.0f); // objectarena.draw_kotak(gl); gl.glPopMatrix();*/

// menampilkan lingkaran dengan tepian berwarna

gl.glDisable (GL10.GL_LIGHTING); // gl.glScalef(150.0f, 150.0f, 150.0f);

// gl.glTranslatef(150.0f, 150.0f, -5.0f);

gl.glLineWidth(1.0f); gl.glEnable(GL10.GL_LINE_SMOOTH);

objectball.draw_circle(gl);

gl.glEnable (GL10.GL_LIGHTING); gl.glPopMatrix();

*/

// menampilkan bola bumi /*gl.glPushMatrix();

gl.glDisable (GL10.GL_LIGHTING); //gl.glLineWidth(1.0f); //gl.glEnable(GL10.GL_LINE_SMOOTH);

// bounds.set(x - radius, y - radius, x + radius, y + radius);

gl.glTranslatef(-x, -y, 0.0f);

gl.glTranslatef(mywidth-radius, myheight-gl.glTranslatef(mywidth-radius, 0.0f);

gl.glScalef(50.0f/3.0f,50.0f/3.0f,50.0f/3.0f); gl.glRotatef(CurrentAngle, 0, 1, 0);

mEarth.draw(gl);

*/

// menampilkan bola putar dengan gradasi warna (3D)

gl.glDisable (GL10.GL_LIGHTING); gl.glLineWidth(1.0f); gl.glEnable(GL10.GL_LINE_SMOOTH);

// bounds.set(x - radius, y - radius, x + radius, y + radius);

//gl.glTranslatef(x, y, 0.0f);

(15)

//objectball2.draw_circle_color(gl);

//mEarth3.draw(gl); gl.glEnable (GL10.GL_LIGHTING); gl.glPopMatrix();

*/

// menampilkan bola pantul dengan gradasi warna (3D)

gl.glPushMatrix();

gl.glDisable (GL10.GL_LIGHTING); gl.glLineWidth(1.0f);

gl.glEnable(GL10.GL_LINE_SMOOTH); // bounds.set(x - radius, y - radius, x + radius, y + radius);

gl.glTranslatef(x, y, 0.0f); gl.glTranslatef(50.0f, 50.0f, 0.0f);

gl.glScalef(50.0f/3.0f,50.0f/3.0f,50.0f/3.0f);

//objectball2.draw_circle_color(gl);

mEarth3.draw(gl); gl.glEnable (GL10.GL_LIGHTING); gl.glPopMatrix();

// segitiga merah /*gl.glPushMatrix();

gl.glDisable (GL10.GL_LIGHTING); //GLU.gluLookAt(gl, 0, 0, 0.01f, 0f, 0f, 0f, 0f, 1.0f, 0.0f);

gl.glColor4f(1.0f, 0.0f, 0.0f, 0.5f);

gl.glRotatef(180, 1.0f, 0.0f, 0.0f);

//gl.glRotatef(mAngle, 0.0f, 1.0f, 0.0f);

gl.glTranslatef(0.5f, -0.5f, 0.0f);

objectball.draw_segitiga(gl);

*/

// segitiga hijau /*gl.glPushMatrix();

(16)

//GLU.gluLookAt(gl, 0, 0, 0.01f, 0f, 0f, 0f, 0f, 1.0f, 0.0f);

gl.glColor4f(0.0f, 0.0f, 1.0f, 0.5f);

gl.glRotatef(180, 1.0f, 0.0f, 0.0f);

//gl.glRotatef(mAngle, 0.0f, 1.0f, 0.0f);

gl.glTranslatef(0.5f, -0.5f, 0.0f);

objectball.draw_segitiga(gl);

*/

// menampilkan lingkaran dengan warna merah + blending

gl.glEnable(GL10.GL_BLEND); // Turn blending on (NEW)

gl.glDisable(GL10.GL_DEPTH_TEST); // Turn depth testing off (NEW)

gl.glLineWidth(1.0f);

gl.glEnable(GL10.GL_LINE_SMOOTH); gl.glTranslatef(100, 150, 0.0f);

objectball3.draw_circle_color(gl,1.0f,0.f,0.f,0.5 f);

gl.glDisable(

GL10.GL_BLEND ); // Disable Alpha Blend

// menampilkan lingkaran dengan warna hijau + blending

gl.glPushMatrix();

(17)

gl.glEnable(GL10.GL_LINE_SMOOTH); gl.glTranslatef(70,100, 0.0f);

gl.glDisable(

// menampilkan lingkaran dengan warna biru + blending

gl.glPushMatrix();

gl.glEnable(GL10.GL_BLEND); // Turn blending on (NEW)

gl.glEnable(GL10.GL_LINE_SMOOTH); gl.glTranslatef(130,100, 0.0f);

gl.glDisable(

*/

// update

(18)

set((int)-radius, (int)-radius, mywidth, myheight);

// Log.i("Test get width : ", "" + mywidth);

// Log.i("Test get height : ", "" + myheight);

// render text gl.glPushMatrix();

gl.glDisable (GL10.GL_LIGHTING); // gl.glScalef(10.0f, 10.0f, 10.0f);

// enable texture + alpha blending

// NOTE: this is required for text rendering! we could incorporate it

// into

// the GLText class, but then it would be called multiple times (which

// impacts performance).

gl.glEnable(GL10.GL_TEXTURE_2D); // Enable Texture Mapping

gl.glEnable(GL10.GL_BLEND); // Enable Alpha Blend gl.glDisable(GL10.GL_DEPTH_TEST); // Turn depth testing off (NEW)

gl.glBlendFunc(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA); // Set

// Alpha

// Blend

// Function glText.begin(1.0f, 1.0f, 1.0f, 1.0f); // Begin Text Rendering (Set Color

// WHITE)

glText.draw("Jumlah Pantulan : (" + jumlah_pantulan + ")", 450, 2); // Draw

// Test // String //

textview.setText(String.valueOf(x));

// glText.draw( "Line 1", -2, 2 ); // Draw Test String

(19)

0, 0 ); // Draw Test String

glText.end(); // End Text Rendering

gl.glLoadIdentity(); glText.begin(1.0f, 1.0f, 1.0f, 1.0f); // Begin Text Rendering (Set Color

// WHITE)

glText.draw("Posisi Bola : (" + x + "," + y + ")", 50, 2); // Draw

// Test

// String //

// glText.draw( "Line 2", 0, 0 ); // Draw Test String

// WHITE)

glText.draw("Posisi Touch : (" + x_touch + "," + y_touch + ")", 450, 400); // Draw

// Test

// String //

(20)

// WHITE)

glText.draw("Posisi Player : (" + ((400*x_player)+50) + "," +

((400*y_player)+50) + ")", 50, 400); // Draw

// Test

// String //

// WHITE)

glText.draw("Ukuran Layar : (" + x_lebar_layar + "," + y_tinggi_layar + ")", 50, 380); // Draw

// Test

// String //

// WHITE)

glText.draw("Posisi Tujuan Player : (" + ((400*x_player_end)+50) + "," +

((400*y_player_end)+50) + ")", 450, 380); // Draw

(21)

// String //

if(

(x_player>=(x_player_end-(WidthObject/2))) && (x_player<=(x_player_end+(WidthObject/2)))){

if(

(y_player>=(y_player_end-(WidthObject/2))) && (y_player<=(y_player_end+(WidthObject/2)))){

gl.glLoadIdentity();

glText.begin(1.0f, 1.0f, 1.0f, 1.0f); // Begin Text Rendering (Set Color

// WHITE)

//gl.glTranslatef(((400*x_player_end)+50)+50, ((400*y_player_end)+50), 0.f);

gl.glTranslatef(mywidth/2, -myheight/2, 0.f); gl.glScalef(2.5f, 2.5f, 1.0f);

gl.glTranslatef(5.f, 140.f, 0.f);

//gl.glRotatef(CurrentAngle, 0.1f, 1.0f, 0.2f); // Rotate

gl.glTranslatef(-50.f, 0.f, 0.f);

glText.draw(" You Win..!", 0,0 ); // Draw

// Test

// String

// textview.setText(String.valueOf(x));

(22)

} }

//gl.glLoadIdentity(); //glText.begin(0.0f, 0.0f, 1.0f, 1.0f); // Begin Text Rendering (Set Color

// Keep track of number of frames drawn

//numFrames++; //long fpsElapsed = System.currentTimeMillis() - fpsStartTime;

//float fps = (numFrames * 1000.0F) / fpsElapsed;

//if (fpsElapsed > 5 * 1000) { // every 5 seconds

//float fps = (numFrames * 1000.0F) / fpsElapsed;

// glText.draw( "Frames per second : "+ fps + " (" + numFrames + " frames in " + fpsElapsed + " ms)",470, 30); // Draw Test String

//temp nilai fps dan fpsElapsed terakhir

// fps_temp=fps;

// numFrames_temp=numFrames; //

fpsElapsed_temp=fpsElapsed;

// fpsStartTime = System.currentTimeMillis();

// numFrames = 0; // startTimeInit=false; /*}else{

if(startTimeInit){ //glText.draw( "Frames per second : "+ fps + " (" + numFrames + " frames in " + fpsElapsed + " ms)",450, 30); // Draw Test String

}else{

glText.draw( "Frames per second : "+ fps_temp + " (" +

numFrames_temp + " frames in " + fpsElapsed_temp + " ms)",470, 30); // Draw Test String

} }*/

//glText.end(); // End Text Rendering

(23)

glText.begin(0.0f, 1.0f, 0.0f, 1.0f); // Begin Text Rendering (Set Color

// WHITE)

glText.draw("Arah : (" + arah_joystick + ")", 450, 460); // Draw

// Test

// String //

// WHITE)

glText.draw("Nilai Jarak ke Center : (" + jarak_center + ")", 450, 440); // Draw

// Test

// String //

gl.glLoadIdentity(); glText.begin(.0f, 1.0f, 0.0f, 1.0f); // Begin Text Rendering (Set Color

// WHITE)

(24)

// Test

// String //

// WHITE)

glText.draw("Sudut Pointer : (" + sudut_pointer + ")", 50, 460); // Draw

// Test

// String //

// WHITE)

glText.draw("Posisi xy_pointer : (" + x_pointer + "," + y_pointer + ")", 50, 440); // Draw

// Test

// String //

(25)

0, 0 ); // Draw Test String

// WHITE)

glText.draw("Posisi xy_pointer awal : (" + x_pointer_awal + "," + y_pointer_awal + ")", 50, 420); // Draw

// Test

// String //

/*gl.glLoadIdentity(); glText.begin( 1.0f, 1.0f, 0.0f, 1.0f ); // Begin Text Rendering

glText.draw( "Grafika Komputer", 40.0f, 140); //

// Draw Test String glText.end(); // End Text Rendering

*/

gl.glLoadIdentity(); glText.begin( 0.0f, 0.0f, 1.0f, 0.5f ); // Begin Text Rendering

//gl.glTranslatef(x_graf, y_graf, 0.f); //Log.v("nilai x_graf :", ""+x_graf);

//Log.v("nilai y_graf :", ""+y_graf);

(26)

gl.glRotatef(CurrentAngle, 0.1f, 1.0f, 0.2f); // Rotate

gl.glTranslatef(-50.f, 0.f, 0.f);

glText.draw( "Grafika Komputer", 0.0f, 0.0f); //

// Draw Test String glText.end(); // End Text Rendering

gl.glEnable (GL10.GL_LIGHTING); // disable texture + alpha gl.glDisable(GL10.GL_BLEND); // Disable Alpha Blend

gl.glDisable(GL10.GL_TEXTURE_2D); // Disable Texture Mapping

gl.glPopMatrix();

// membuat background joystick dari lingkaran dengan texture

gl.glPushMatrix();

//gl.glTranslatef(-x, -y, 0.0f);

gl.glTranslatef(mywidth-(2*radius)-radius, 0.0f+radius, 0.0f);

objectballbgstick.draw_circle_color(gl); gl.glEnable (GL10.GL_LIGHTING); gl.glPopMatrix();

// membuat joystick dari lingkaran dengan texture

gl.glPushMatrix();

gl.glTranslatef(x_anim_stick, y_anim_stick, 0.0f);

//gl.glTranslatef(mywidth-2*radius, 0.5f*radius, 0.0f);

//canvas.drawBitmap(_joystick.get_joystick(), //_controls._touchingPoint.x - 26,

(27)

gl.glTranslatef(mywidth-(1.5f*radius)-radius, (0.5f*radius)+radius, 0.0f);

//gl.glTranslatef(mywidth-1.5f*radius, 0.5f*radius, 0.0f);

//gl.glTranslatef(1013.0f, 500.0f, 0.0f);

objectballstick.draw_circle_color(gl);

// membuat joystick dari lingkaran dengan texture 2

gl.glTranslatef(x_anim_stick, y_anim_stick, 0.0f);

//gl.glTranslatef(mywidth-2*radius, 0.5f*radius, 0.0f);

gl.glTranslatef(-5*radius,0.0f,0.0f);

//canvas.drawBitmap(_joystick.get_joystick(), //_controls._touchingPoint.x - 26,

_controls._touchingPoint.y - 26, null);

gl.glTranslatef(mywidth-(1.5f*radius)-radius, (0.5f*radius)+radius, 0.0f);

//gl.glTranslatef(mywidth-1.5f*radius, 0.5f*radius, 0.0f);

objectballstickdua.draw_circle_color(gl); gl.glEnable (GL10.GL_LIGHTING); gl.glPopMatrix();*/

//Log.v("mywidth: ", "" + mywidth); //Log.v("myheight: ", "" + myheight); //Log.v("radius: ", "" + radius); // membuat jaring-jaring labirin gl.glPushMatrix();

(28)

//gl.glDisable(GL10.GL_DEPTH_TEST); // Turn depth testing off (NEW)

//gl.glScalef(25.0f, 25.0f, 25.0f);

gl.glScalef(400.0f, 400.0f, 1.0f);

gl.glTranslatef (0.0f, 0.0f, -5.0f);

gl.glLineWidth(4.0f); gl.glEnable(GL10.GL_LINE_SMOOTH);

primob.draw_line_maze_horiverti(gl);

//gl.glLoadIdentity();

// segitiga dengan texture sebagai player labirin

gl.glDisable (GL10.GL_LIGHTING); //GLU.gluLookAt(gl, 0, 0, 0.01f, 0f, 0f, 0f, 0f, 1.0f, 0.0f);

gl.glScalef(80.0f, 80.0f, 0.0f); gl.glRotatef(180, 1.0f, 0.0f, 0.0f);

gl.glTranslatef(-0.5f, -0.5f, 0.0f);

objectball.draw_segitiga_texture(gl);

// membuat player untuk labirin gl.glPushMatrix();

gl.glScalef(400.0f, 400.0f, 1.0f);

gl.glTranslatef (0.0f, 0.0f, -5.0f);

// start me-manage pergerakan player

if(Navigate == 1) //Navigate right

(29)

gl.glTranslatef(x_player, y_player, 0.0f);

gl.glRotatef(-90.0f, 0.0f, 0.0f, 1.0f);

gl.glTranslatef(-x_player, -y_player, 0.0f);

}

else if(Navigate == 2) //Navigate bottom

{

gl.glTranslatef(x_player, y_player, 0.0f);

gl.glRotatef(-180.0f, 0.0f, 0.0f, 1.0f);

}

else if(Navigate == 3) //Navigate left

{

gl.glTranslatef(x_player, y_player, 0.0f); gl.glRotatef(90.0f, 0.0f, 0.0f, 1.0f);

} // end me-manage pergerakan player

primob.draw_segitiga_labirin_player(gl,positionCo l,positionRow);

//primob.draw_segitiga_labirin_player(gl);

//primob1.draw_segitiga_texture(gl,positionCol,po sitionRow);

// membuat player untuk labirin as bot /*int min = 1;

int max = 3;

Random init_random = new Random(); int my_random = init_random.nextInt(max - min + 1) + min;

Navigate=my_random;

Log.v("my_random =",""+my_random); */

// Update the rotational angle after each refresh

// re-Calculate animation parameters

(30)

//CurrentAngle -= 360.0*Math.floor(CurrentAngle/360.0);

CurrentAngle=0.0f; CurrentAngle += AnimateStep;

}

CurrentAngle2 += AnimateStep2; if (CurrentAngle2 > 360.0) {

//CurrentAngle -= 360.0*Math.floor(CurrentAngle/360.0);

CurrentAngle2=0.0f; CurrentAngle2 += AnimateStep2;

}

// pengkondisian penghitungan pantulan mulai dari nol

/*if(Run_ModeScale==0){ this.CurrentScale-=ScaleStep;

this.Run_ModeScale=1; }*/

CurrentScale += ScaleStep; if (CurrentScale % 10.0f==0) {

ScaleStep = -1*ScaleStep; }

//gl.glFlush(); }

public float getX_graf() { return x_graf; }

public void setX_graf(float x_graf) { this.x_graf = x_graf;

}

public float getY_graf() { return y_graf; }

public void setY_graf(float y_graf) { this.y_graf = y_graf;

}

(31)

public void setX_touch(float x_touch) { this.x_touch = x_touch;

}

public float getY_touch() { return y_touch; }

public void setY_touch(float y_touch) { this.y_touch = y_touch;

}

public String getArah_joystick() { return arah_joystick; }

public void setArah_joystick(String arah_joystick) {

this.arah_joystick = arah_joystick; }

public float getJarak_center() { return jarak_center; }

public void setJarak_center(float jarak_center) { this.jarak_center = jarak_center;

}

public float getSudut_pointer() { return sudut_pointer; }

public void setSudut_pointer(float sudut_pointer) {

this.sudut_pointer = sudut_pointer; }

public float getX_lebar_layar() { return x_lebar_layar; }

public void setX_lebar_layar(float x_lebar_layar) {

this.x_lebar_layar = x_lebar_layar; }

(32)

public void setY_tinggi_layar(float y_tinggi_layar) {

this.y_tinggi_layar = y_tinggi_layar; }

public float getX_pointer_awal() { return x_pointer_awal; }

public void setX_pointer_awal(float x_pointer_awal) {

this.x_pointer_awal = x_pointer_awal; }

public float getY_pointer_awal() { return y_pointer_awal; }

public void setY_pointer_awal(float y_pointer_awal) {

this.y_pointer_awal = y_pointer_awal; }

public float getX_pointer() { return x_pointer; }

public void setX_pointer(float x_pointer) { this.x_pointer = x_pointer;

}

public float getY_pointer() { return y_pointer; }

public void setY_pointer(float y_pointer) { this.y_pointer = y_pointer;

}

public float getX_anim_stick() { return x_anim_stick; }

public void setX_anim_stick(float x_anim_stick) { this.x_anim_stick = x_anim_stick;

}

(33)

}

public void setY_anim_stick(float y_anim_stick) { this.y_anim_stick = y_anim_stick;

}

public float getRadius() { return radius; }

public void setRadius(float radius) { this.radius = radius;

}

public int getMywidth() { return mywidth; }

public void setMywidth(int mywidth) { this.mywidth = mywidth; }

public int getMyheight() { return myheight; }

public void setMyheight(int myheight) { this.myheight = myheight; }

public int getNumberRow() { return numberRow; }

public void setNumberRow(int numberRow) { this.numberRow = numberRow; }

public float getWidthObject() { return WidthObject; }

public void setWidthObject(float widthObject) { WidthObject = widthObject;

}

public float getX_player() { return x_player; }

(34)

}

public float getY_player() { return y_player; }

public void setY_player(float y_player) { this.y_player = y_player;

}

public int getNavigate() { return Navigate; }

public void setNavigate(int navigate) { Navigate = navigate;

}

public boolean goForward() {

if(Navigate == 0 && positionRow > 0 && hori[positionRow][positionCol] == 0) return true;

if(Navigate == 1 && positionCol <

(numberCol-1) && verti[positionRow][positionCol+1] == 0) return true;

if(Navigate == 2 && positionRow <

(numberRow-1) && hori[positionRow+1][positionCol] == 0) return true;

if(Navigate == 3 && positionCol > 0 && verti[positionRow][positionCol] == 0) return true;

return false; }

public int getPositionRow() { return positionRow; }

public void setPositionRow(int positionRow) { this.positionRow = positionRow; }

public int getPositionCol() { return positionCol; }

public void setPositionCol(int positionCol) { this.positionCol = positionCol; }

@Override

public void onSurfaceCreated(GL10 gl, EGLConfig config) {

//gl.glClearColor(0.5f, 0.5f, 0.5f, 1.0f); // Set color's clear-value to

//gl.glClearColor(1.0f, 1.0f, 1.0f, 1.0f); // Set color's clear-value to

(35)

// Set color's clear-value to

gl.glClearDepthf(1.0f); // Set depth's clear-value to farthest

gl.glEnable(GL10.GL_DEPTH_TEST); // Enables depth-buffer for hidden

// surface removal

gl.glDepthFunc(GL10.GL_LEQUAL); // The type of depth testing to do

gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_NICEST); // nice

// perspective // view

gl.glShadeModel(GL10.GL_SMOOTH); // Enable smooth shading of color

gl.glDisable(GL10.GL_DITHER); // Disable dithering for better

// performance

gl.glEnable(GL10.GL_LIGHTING); gl.glEnable(GL10.GL_LIGHT0);

//gl.glEnable(GL10.GL_LIGHT1);

// Create the GLText glText = new ESText(gl, context.getAssets());

// Load the font from file (set size + padding), creates the texture

// NOTE: after a successful call to this the font is ready for

// rendering!

glText.load("Roboto-Regular.ttf", 14, 2, 2); // Create Font (Height: 14

// Pixels / X+Y Padding

// 2 Pixels)

// gl.glDisable(GL10.GL_DITHER); // Disable dithering for better

// performance

// Setup Blending (NEW)

gl.glColor4f(1.0f, 1.0f, 1.0f, 0.5f); // Full brightness, 50% alpha (NEW)

gl.glBlendFunc(GL10.GL_SRC_ALPHA, GL10.GL_ONE); // Select blending function (NEW)

// Setup Texture, each time the surface is created (NEW)

primob3.loadBallTexture(gl, context,1); primob1.loadBallTexture(gl, context,4);

(36)

objectballbgstick.loadBallTexture(gl, context,3);

mEarth.loadGLTexture(gl, context,2); //mEarth2.loadGLTexture(gl, context,6); mEarth3.loadGLTexture(gl, context,4); primobbg.loadBallTexture(gl, context, 5); primobflappy.loadBallTexture2(gl,

context, 0);

primobground.loadBallTexture(gl, context, 6);

gl.glEnable(GL10.GL_TEXTURE_2D); // Enable texture (NEW)

}

@Override

public void onSurfaceChanged(GL10 gl, int width, int height) {

mywidth = width; myheight = height;

gl.glViewport(0, 0, width, height); // Setup orthographic projection

gl.glMatrixMode(GL10.GL_PROJECTION); // Activate Projection Matrix

gl.glLoadIdentity(); // Load Identity Matrix

gl.glOrthof( // Set Ortho Projection (Left,Right,Bottom,Top,Front,Back)

0, width, 0, height, 500.0f, -500.0f);

// Save width and height

// this.width = width; // Save Current Width

// this.height = height; // Save Current Height

gl.glMatrixMode(GL10.GL_MODELVIEW); // Select model-view matrix

gl.glLoadIdentity(); // Reset

/*float[] vertices_quad = { // Vertices for the square

-1.0f, -1.0f, 0.0f, // 0. left-bottom

1.0f, -1.0f, 0.0f, // 1. right-bottom

-1.0f, 1.0f, 0.0f, // 2. left-top

1.0f, 1.0f, 0.0f // 3. right-top

};

// set background Bitmap bitmap =

(37)

.openRawResource(R.drawable.splash)); float tex_quad[] = {

-100, -100, 0, 100, -100, 0, -100, 100, 0, 100, 100, 0 };

gl.glEnableClientState(GL10.GL_VERTEX_ARRAY); gl.glVertexPointer(3, GL10.GL_FLOAT, 0, makeFloatBuffer(tex_quad));

gl.glTexCoordPointer(3, GL10.GL_FLOAT, 0, makeFloatBuffer(vertices_quad)); // 5

gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRA Y);

//gl.glVertexPointer(2, GL_FLOAT, sizeof(GLfloat)*4, &tex_quad[0]);

//glTexCoordPointer(2, GL_FLOAT, sizeof(GLfloat)*4, &tex_quad[2]);

gl.glDisable(GL10.GL_DEPTH_TEST); gl.glDepthMask(false);

gl.glEnable(GL10.GL_TEXTURE_2D);

//gl.glGenTextures(1, textures_indek, 0); gl.glBindTexture(GL10.GL_TEXTURE_2D, 0); gl.glDrawArrays(GL10.GL_TRIANGLE_FAN, 0, 4);

//glDrawArrays(GL_TRIANGLE_FAN, 0, 4); //glEnable(GL_DEPTH_TEST);

gl.glEnable(GL10.GL_DEPTH_TEST); gl.glDepthMask(true);

gl.glDisable( GL10.GL_TEXTURE_2D ); // Disable Texture Mapping

*/ }

public float getxMax() { return xMax; }

public void setxMax(int xmax) { xMax = xmax;

}

(38)

public void setxMin(int xmin) { xMin = xmin;

}

public float getyMax() { return yMax; }

public void setyMax(int ymax) { yMax = ymax;

}

public float getyMin() { return yMin; }

public void setyMin(int ymin) { yMin = ymin;

}

public float getspeedX() { return speedX; }

public void setspeedX(float speedX_) { speedX = speedX_;

}

public float getspeedY() { return speedY; }

public void setspeedY(float speedY_) { speedY = speedY_;

}

public void moveWithCollisionDetection(ESRender esRender) {

// Get new (x,y) position x += speedX;

y += speedY;

// Detect collision and react

if (x + radius > esRender.getxMax()) { speedX = -speedX;

x = esRender.getxMax() - radius; this.jumlah_pantulan+=1;

} else if (x - radius < esRender.getxMin()) {

speedX = -speedX;

x = esRender.getxMin() + radius; this.jumlah_pantulan+=1;

}

if (y + radius > esRender.getyMax()) { speedY = -speedY;

y = esRender.getyMax() - radius; this.jumlah_pantulan+=1;

(39)

speedY = -speedY;

y = esRender.getyMin() + radius; this.jumlah_pantulan+=1;

}

// pengkondisian penghitungan pantulan mulai dari nol

if(Run_Mode==0){

this.jumlah_pantulan-=4; this.Run_Mode=1;

} }

public void set(int x, int y, int width, int height) {

xMin = x;

// xMax = x + width - 1; xMax = x + width;

yMin = y;

// yMax = y + height - 1; yMax = y + height;

} }

ESSurfaceView.java

package com.fractalbackground; import android.content.Context; //import android.graphics.PixelFormat; import android.graphics.Point;

import android.opengl.GLSurfaceView; import android.util.Log;

import android.view.KeyEvent; import android.view.MotionEvent; /**

* A view container where OpenGL ES graphics can be drawn on screen. This view

* can also be used to capture touch events, such as a user interacting with

* drawn objects. */

public class ESSurfaceView extends GLSurfaceView { private final ESRender esRender;

private float previousX; private float previousY; /*

* public float initx_stick = 425; public float inity_stick = 267; public

(40)

public Point _pointerPosition * = new Point(220,150); */

public float initx_stick = 1013; public float inity_stick = 500;

public Point _touchingPoint = new Point(1013, 500);

public Point _pointerPosition = new Point(220, 150);

private Boolean _dragging = false; private int flag_first = 0;

private float mypointer_awal_x = 0; private float mypointer_awal_y = 0; public ESSurfaceView(Context context) {

super(context);

// Set the Renderer for drawing on the GLSurfaceView

esRender = new ESRender(context); setRenderer(esRender);

// To enable keypad this.setFocusable(true); this.requestFocus(); // To enable touch mode

this.setFocusableInTouchMode(true); // Render the view only when there is a change in the drawing data

// merender hanya ketika ada perubahan/ event

//

setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY); //set background

//glSurfaceView = ...

/*glSurfaceView.setEGLConfigChooser(8, 8, 8, 8, 16, 0);

glSurfaceView.getHolder().setFormat(PixelFormat.T RANSLUCENT);

glSurfaceView.setBackgroundResource(R.drawable.my _background);

glSurfaceView.setZOrderOnTop(true); glSurfaceView.setRenderer(...); glSurfaceView.setRenderMode(...);*/ //this.setEGLConfigChooser(8, 8, 8, 8, 16, 0);

(41)

//this.setBackgroundResource(R.drawable.splash); //this.setZOrderOnTop(true);

//glSurfaceView.setRenderer(...); //glSurfaceView.setRenderMode(...); }

@Override

public boolean onTouchEvent(MotionEvent v) { // MotionEvent reports input details from the touch screen

// and other input controls. In this case, we are only

// interested in events where the touch position changed.

/*

* initx_stick =

esRender.getWidthObject()-esRender.getRadius(); * inity_stick = 0.0f; _touchingPoint.x = (int) initx_stick;

* _touchingPoint.y= (int) inity_stick; *

* _pointerPosition.x = (int) initx_stick; _pointerPosition.y= (int)

* inity_stick; */

update(v);

float currentX = v.getX(); float currentY = v.getY(); float deltaX, deltaY;

// float scalingFactor = 0.50f / ((esRender.xMax > esRender.yMax) ?

// esRender.yMax // : esRender.xMax); switch (v.getAction()) { case MotionEvent.ACTION_DOWN:

//Log.v("Test Action Down", "action down working");

// esRender.setX_anim_stick(-esRender.getRadius());

// esRender.setY_anim_stick(0.0f); // membuat animasi pergerakan tombol joystick

// bound to a box disekitar joystick

/*

* if( currentX >=

(42)

_touchingPoint.x+esRender.getRadius()){ *

* if( currentY >=

_touchingPoint.y-esRender.getRadius() && currentY * <=

_touchingPoint.y+esRender.getRadius()){ *

* // lakukan pergerakan pada stick

*

esRender.setX_anim_stick(esRender.getRadius()); *

esRender.setY_anim_stick(esRender.getRadius()); *

* } * * } */ // break;

// requestRender(); // case

MotionEvent.ACTION_POINTER_DOWN:

// Log.v("Test Action ACTION_POINTER_DOWN", "action working");

// esRender.setX_anim_stick(-esRender.getRadius());

// esRender.setY_anim_stick(-esRender.getRadius());

// membuat animasi pergerakan tombol joystick

// bound to a box disekitar joystick

/*

* if( currentX >=

_touchingPoint.x-esRender.getRadius() && currentX * <=

_touchingPoint.x+esRender.getRadius()){ *

* if( currentY >=

_touchingPoint.y-esRender.getRadius() && currentY * <=

_touchingPoint.y+esRender.getRadius()){ *

* // lakukan pergerakan pada stick

*

esRender.setX_anim_stick(esRender.getRadius()); *

esRender.setY_anim_stick(esRender.getRadius()); *

* } * * } */

// requestRender(); case MotionEvent.ACTION_UP:

(43)

"action working");

// esRender.setX_anim_stick(0.0f); // esRender.setY_anim_stick(-esRender.getRadius());

// requestRender();

// case MotionEvent.ACTION_MOVE: // Log.v("Test Action

ACTION_POINTER_DOWN", "action working"); // requestRender();

// case MotionEvent.ACTION_UP: // Log.v("Test Action Up", "action up working");

// requestRender(); case MotionEvent.ACTION_MOVE:

// Modify rotational angles according to movement

/*deltaX = currentX - previousX; deltaY = currentY - previousY; //

esRender.setspeedX(esRender.getspeedX()+ (deltaX/getWidth()));

//

esRender.setspeedY(esRender.getspeedY()+ (deltaY/getHeight()));

esRender.setspeedX(esRender.getspeedX() + deltaX / 100);

esRender.setspeedY(esRender.getspeedY() + deltaY / 100);

*/

//requestRender(); }

// Save current x, y previousX = currentX; previousY = currentY;

return true; // Event handled // break;

}

private MotionEvent lastEvent;

public void update(MotionEvent event) { // initx_stick =

1066.0f-1.5f*esRender.getRadius(); // inity_stick =0.5f*esRender.getRadius();

if (event == null && lastEvent == null) { return;

} else if (event == null && lastEvent != null) {

(44)

lastEvent = event; }

// drag drop

if (event.getAction() == MotionEvent.ACTION_DOWN) {

_dragging = true; flag_first = 0;

} else if (event.getAction() == MotionEvent.ACTION_UP) {

_dragging = false; }

// penanda untuk menyimpan koordinat yang pertama kali diklik

if (_dragging) { // get the pos

_touchingPoint.x = (int) event.getX();

_touchingPoint.y = (int) event.getY();

esRender.setX_touch(_touchingPoint.x); esRender.setY_touch(esRender.getMyheight() - _touchingPoint.y);

esRender.setJarak_center((float) ((Math.pow(_touchingPoint.x

-

(esRender.getMywidth() - 2 * esRender.getRadius()), 2)) + (Math

.pow(esRender.getMyheight() - _touchingPoint.y - 2

* esRender.getRadius(), 2))));

if(esRender.getJarak_center()<=Math.pow(25,2)){ //esRender.setX_graf(esRender.getX_graf()-10); esRender.setY_graf(esRender.getY_graf()-10);

}else{

esRender.setY_graf(esRender.getY_graf()+10); }

// membuat radius touch screen if (_touchingPoint.x >=

(esRender.getMywidth() - 200)

&& _touchingPoint.y >= (esRender.getMyheight() - 200)

(45)

_touchingPoint.x

- (esRender.getMywidth() - 2 * esRender .getRadius()), 2)) + (Math.pow(

esRender.getMyheight() - _touchingPoint.y - 2 * esRender.getRadius(), 2))) > Math.pow(

0.5 * esRender.getRadius(), 2))) {

Music.playOnce(esRender.context, R.raw.fb); // membuat penanda untuk mendapatkan point awal touch

if (flag_first == 0) { esRender.setX_pointer_awal(_touchingPoint.x);

mypointer_awal_x = esRender.getX_pointer_awal();

esRender.setY_pointer_awal(_touchingPoint.y); mypointer_awal_y = esRender.getY_pointer_awal();

flag_first = 1; }

// kodisi jika titik awal sama dengan titik pointer

if ((mypointer_awal_x == _touchingPoint.x)

&& (mypointer_awal_y == _touchingPoint.y)) {

mypointer_awal_x = esRender.getMywidth() - 100;

mypointer_awal_y = esRender.getMyheight() - 100;

}

esRender.setX_pointer(_touchingPoint.x); esRender.setY_pointer(_touchingPoint.y);

esRender.setX_lebar_layar(esRender.getMywidth()); esRender.setY_tinggi_layar(esRender.getMyheight() );

(46)

_touchingPoint.x - mypointer_awal_x)

/ (Math.PI / 180);

esRender.setSudut_pointer((float) myangle);

esRender.setX_anim_stick((float) (26.0f * Math.cos(myangle

* (Math.PI / 180))));

esRender.setY_anim_stick((float) (26.0f * Math.sin(myangle

* (Math.PI / 180))));

// set arah joystick if ((float) myangle >= 45 && (float) myangle <= 135) {

esRender.setArah_joystick("Atas"); if

(esRender.getNavigate() == 0 && esRender.goForward()) esRender.setPositionRow(esRender.getPositionRow() - 1);

else if (esRender.getNavigate() == 1

&& esRender.goForward())

esRender.setPositionCol(esRender.getPositionCol() + 1);

esRender.setPositionRow(esRender.getPositionRow() + 1);

esRender.setPositionCol(esRender.getPositionCol() - 1);

Log.v("Test Action KEYCODE_T", "action working");

esRender.setX_player((esRender.getPositionCol() * esRender

(47)

+ (esRender.getWidthObject() / 2));

esRender.setY_player(((esRender.getNumberRow() - esRender.getPositionRow() - 1) * esRender

.getWidthObject())

+ (esRender.getWidthObject() / 2));

} else if (((float) myangle >= 0 && (float) myangle < 45)

|| ((float) myangle >= -44 && (float) myangle <= 0)) {

esRender.setArah_joystick("Kanan");

esRender.setNavigate(esRender.getNavigate() + 1); } else {

esRender.setArah_joystick("Kiri");

esRender.setNavigate(esRender.getNavigate() - 1); }

// reset Navigate

if (esRender.getNavigate() < 0) {

esRender.setNavigate(3); }

esRender.setNavigate(esRender.getNavigate() % 4); }

/*

* //membuat penanda if(flag_first==0){

*

esRender.setX_pointer_awal(_touchingPoint.x); *

esRender.setY_pointer_awal(_touchingPoint.y); flag_first=1; }

* *

esRender.setX_pointer(_touchingPoint.x); *

esRender.setY_pointer(_touchingPoint.y); *

*

esRender.setX_lebar_layar(esRender.getMywidth()); *

esRender.setY_tinggi_layar(esRender.getMyheight()); *

*

(48)

*

esRender.setY_anim_stick(_touchingPoint.y); */

// bound to a box

if (_touchingPoint.x < 400) { _touchingPoint.x = 400; }

if (_touchingPoint.x > 450) { _touchingPoint.x = 450; }

if (_touchingPoint.y < 240) { _touchingPoint.y = 240; }

if (_touchingPoint.y > 290) { _touchingPoint.y = 290; }

// get the angle double angle =

Math.atan2(_touchingPoint.y - inity_stick,

_touchingPoint.x - initx_stick) / (Math.PI / 180);

// Move the beetle in proportion to how far

// the joystick is dragged from its center

_pointerPosition.y += Math.sin(angle * (Math.PI / 180))

* (_touchingPoint.x / 70);

_pointerPosition.x += Math.cos(angle * (Math.PI / 180))

* (_touchingPoint.x / 70);

//

esRender.setX_anim_stick(_touchingPoint.x); //

esRender.setY_anim_stick(_touchingPoint.y); // make the pointer go thru if (_pointerPosition.x > 480) {

_pointerPosition.x = 0; }

if (_pointerPosition.x < 0) { _pointerPosition.x = 480; }

if (_pointerPosition.y > 320) { _pointerPosition.y = 0; }

if (_pointerPosition.y < 0) { _pointerPosition.y = 320; }

(49)

flag_first = 0;

// Snap back to center when the joystick is released

_touchingPoint.x = (int) initx_stick;

_touchingPoint.y = (int) inity_stick;

esRender.setX_anim_stick(0.0f); esRender.setY_anim_stick(0.0f); // shaft.alpha = 0;

} }

// Key-up event handler @Override

public boolean onKeyUp(int keyCode, KeyEvent event) {

switch (keyCode) {

case KeyEvent.KEYCODE_A: // mengurangi kecepatan object

if ((esRender.getspeedX() - 0.05f > 0)) {

esRender.setspeedX(esRender.getspeedX() - 0.05f); }

if ((esRender.getspeedX() - 0.05f < 0)) {

esRender.setspeedX(0.0f); }

if ((esRender.getspeedY() - 0.05f >= 0)) {

esRender.setspeedY(esRender.getspeedY() - 0.05f); }

if ((esRender.getspeedY() - 0.05f < 0)) {

esRender.setspeedY(0.0f); }

Log.v("Test Action KEYCODE_A", "action working");

break;

case KeyEvent.KEYCODE_T: // up

if (esRender.getNavigate() == 0 && esRender.goForward())

esRender.setPositionRow(esRender.getPositionRow() - 1);

else if (esRender.getNavigate() == 1 && esRender.goForward())

esRender.setPositionCol(esRender.getPositionCol() + 1);

(50)

esRender.setPositionRow(esRender.getPositionRow() + 1);

else if (esRender.getNavigate() == 3 && esRender.goForward())

esRender.setPositionCol(esRender.getPositionCol() - 1);

Log.v("Test Action KEYCODE_T", "action working");

esRender.setX_player((esRender.getPositionCol() * esRender

.getWidthObject()) + (esRender.getWidthObject() / 2));

esRender.setY_player(((esRender.getNumberRow() -

esRender.getPositionRow() - 1) * esRender

.getWidthObject()) + (esRender.getWidthObject() / 2));

break;

case KeyEvent.KEYCODE_G:

Log.v("Test Action KEYCODE_G", "action working");

break;

case KeyEvent.KEYCODE_H: // right

esRender.setNavigate(esRender.getNavigate() + 1); Log.v("Test Action KEYCODE_H", "action working");

break;

case KeyEvent.KEYCODE_F: // left

esRender.setNavigate(esRender.getNavigate() - 1); Log.v("Test Action KEYCODE_F", "action working");

break; }

if (esRender.getNavigate() < 0) esRender.setNavigate(3);

esRender.setNavigate(esRender.getNavigate() % 4); return true; // Event handled

} }

(51)

// This is a OpenGL ES 1.0 dynamic font rendering system. It loads actual font

// files, generates a font map (texture) from them, and allows rendering of

// text strings. //

// NOTE: the rendering portions of this class uses a sprite batcher in order

// provide decent speed rendering. Also, rendering assumes a BOTTOM-LEFT

// origin, and the (x,y) positions are relative to that, as well as the

// bottom-left of the string to render. package com.fractalbackground;

import javax.microedition.khronos.opengles.GL10; import android.content.res.AssetManager;

import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.Paint; import android.graphics.Typeface; import android.opengl.GLUtils; public class ESText {

//--Constants--//

public final static int CHAR_START = 32; // First Character (ASCII Code)

public final static int CHAR_END = 126; // Last Character (ASCII Code)

public final static int CHAR_CNT = ( ( ( CHAR_END - CHAR_START ) + 1 ) + 1 ); // Character Count (Including Character to use for Unknown)

public final static int CHAR_NONE = 32; // Character to Use for Unknown (ASCII Code)

public final static int CHAR_UNKNOWN = ( CHAR_CNT - 1 ); // Index of the Unknown Character

public final static int FONT_SIZE_MIN = 6; // Minumum Font Size (Pixels)

public final static int FONT_SIZE_MAX = 180; // Maximum Font Size (Pixels)

public final static int CHAR_BATCH_SIZE = 100; // Number of Characters to Render Per Batch

//--Members--//

GL10 gl; // GL10 Instance

AssetManager assets; // Asset Manager

SpriteBatch batch; // Batch Renderer

(52)

// Font Padding (Pixels; On Each Side, ie. Doubled on Both X+Y Axis)

float fontHeight; // Font Height (Actual; Pixels)

float fontAscent; // Font Ascent (Above Baseline; Pixels)

float fontDescent; // Font Descent (Below Baseline; Pixels)

int textureId; // Font Texture ID [NOTE: Public for Testing Purposes Only!]

int textureSize; // Texture Size for Font (Square) [NOTE: Public for Testing Purposes Only!]

TextureRegion textureRgn; // Full Texture Region

float charWidthMax; // Character Width (Maximum; Pixels)

float charHeight; // Character Height (Maximum; Pixels)

final float[] charWidths; // Width of Each Character (Actual; Pixels)

TextureRegion[] charRgn; // Region of Each Character (Texture Coordinates) int cellWidth, cellHeight; // Character Cell Width/Height

int rowCnt, colCnt; // Number of Rows/Columns

float scaleX, scaleY; // Font Scale (X,Y Axis)

float spaceX; // Additional (X,Y Axis) Spacing (Unscaled)

//--Constructor--//

// D: save GL instance + asset manager, create arrays, and initialize the members

// A: gl - OpenGL ES 10 Instance

public ESText(GL10 gl, AssetManager assets) { this.gl = gl; // Save the GL10 Instance

this.assets = assets; // Save the Asset Manager Instance

batch = new SpriteBatch( gl, CHAR_BATCH_SIZE ); // Create Sprite Batch (with Defined Size)

charWidths = new float[CHAR_CNT]; // Create the Array of Character Widths

charRgn = new TextureRegion[CHAR_CNT]; // Create the Array of Character Regions

// initialize remaining members fontPadX = 0;

(53)

fontHeight = 0.0f; fontAscent = 0.0f; fontDescent = 0.0f; textureId = -1; textureSize = 0; charWidthMax = 0; charHeight = 0; cellWidth = 0; cellHeight = 0; rowCnt = 0; colCnt = 0;

scaleX = 1.0f; // Default Scale = 1 (Unscaled)

scaleY = 1.0f; // Default Scale = 1 (Unscaled)

spaceX = 0.0f; }

//--Load Font--// // description

// this will load the specified font file, create a texture for the defined

// character range, and setup all required values used to render with it.

// arguments:

// file - Filename of the font (.ttf, .otf) to use. In 'Assets' folder.

// size - Requested pixel size of font (height) // padX, padY - Extra padding per character (X+Y Axis); to prevent overlapping characters. public boolean load(String file, int size, int padX, int padY) {

// setup requested values

fontPadX = padX; // Set Requested X Axis Padding

fontPadY = padY; // Set Requested Y Axis Padding

// load the font and setup paint instance for drawing

Typeface tf = Typeface.createFromAsset( assets, file ); // Create the Typeface from Font File Paint paint = new Paint(); // Create Android Paint Instance

paint.setAntiAlias( true ); // Enable Anti Alias

paint.setTextSize( size ); // Set Text Size

paint.setColor( 0xffffffff ); // Set ARGB (White, Opaque)

(54)

// get font metrics

Paint.FontMetrics fm = paint.getFontMetrics(); // Get Font Metrics

fontHeight = (float)Math.ceil( Math.abs( fm.bottom ) + Math.abs( fm.top ) ); // Calculate Font Height

fontAscent = (float)Math.ceil( Math.abs( fm.ascent ) ); // Save Font Ascent

fontDescent = (float)Math.ceil( Math.abs( fm.descent ) ); // Save Font Descent

// determine the width of each character (including unknown character)

// also determine the maximum character width char[] s = new char[2]; // Create Character Array

charWidthMax = charHeight = 0; // Reset Character Width/Height Maximums

float[] w = new float[2]; // Working Width Value

int cnt = 0; // Array Counter

for ( char c = CHAR_START; c <= CHAR_END; c++ ) { // FOR Each Character

s[0] = c; // Set Character

paint.getTextWidths( s, 0, 1, w ); // Get Character Bounds

charWidths[cnt] = w[0]; // Get Width

if ( charWidths[cnt] > charWidthMax ) // IF Width Larger Than Max Width

charWidthMax = charWidths[cnt]; // Save New Max Width

cnt++; // Advance Array Counter

}

s[0] = CHAR_NONE; // Set Unknown Character

paint.getTextWidths( s, 0, 1, w ); // Get Character Bounds

charWidths[cnt] = w[0]; // Get Width

if ( charWidths[cnt] > charWidthMax ) // IF Width Larger Than Max Width

charWidthMax = charWidths[cnt]; // Save New Max Width

cnt++; // Advance Array Counter

// set character height to font height

charHeight = fontHeight; // Set Character Height

// find the maximum size, validate, and setup cell sizes

cellWidth = (int)charWidthMax + ( 2 * fontPadX ); // Set Cell Width

(55)

); // Set Cell Height

int maxSize = cellWidth > cellHeight ? cellWidth : cellHeight; // Save Max Size (Width/Height)

if ( maxSize < FONT_SIZE_MIN || maxSize > FONT_SIZE_MAX ) // IF Maximum Size Outside Valid Bounds

return false; // Return Error

// set texture size based on max font size (width or height)

// NOTE: these values are fixed, based on the defined characters. when

// changing start/end characters

(CHAR_START/CHAR_END) this will need adjustment too! if ( maxSize <= 24 ) // IF Max Size is 18 or Less

textureSize = 256; // Set 256 Texture Size

else if ( maxSize <= 40 ) // ELSE IF Max Size is 40 or Less

else if ( maxSize <= 80 ) // ELSE IF Max Size is 80 or Less

else // ELSE IF Max Size is Larger Than 80 (and Less than FONT_SIZE_MAX)

// create an empty bitmap (alpha only) Bitmap bitmap = Bitmap.createBitmap(

textureSize, textureSize, Bitmap.Config.ALPHA_8 ); // Create Bitmap

Canvas canvas = new Canvas( bitmap ); // Create Canvas for Rendering to Bitmap

bitmap.eraseColor( 0x00000000 ); // Set Transparent Background (ARGB)

// calculate rows/columns

// NOTE: while not required for anything, these may be useful to have :)

colCnt = textureSize / cellWidth; // Calculate Number of Columns

rowCnt = (int)Math.ceil( (float)CHAR_CNT / (float)colCnt ); // Calculate Number of Rows // render each of the characters to the canvas (ie. build the font map)

float x = fontPadX; // Set Start Position (X)

float y = ( cellHeight - 1 ) - fontDescent - fontPadY; // Set Start Position (Y)

(56)

s[0] = c; // Set Character to Draw

canvas.drawText( s, 0, 1, x, y, paint ); // Draw Character

x += cellWidth; // Move to Next Character

if ( ( x + cellWidth - fontPadX ) > textureSize ) { // IF End of Line Reached

x = fontPadX; // Set X for New Row

y += cellHeight; // Move Down a Row

} }

s[0] = CHAR_NONE; // Set Character to Use for NONE

canvas.drawText( s, 0, 1, x, y, paint ); // Draw Character