Username Password

Register Here || Lost Password
View Thread
Explore Your Brain Pemrograman Java
Game labirin pake JAVA(J2ME)
Username
Password
Register FAQ Members List Today's Posts Search

Print Thread

27-12-2009 11:38 PM Game labirin pake JAVA(J2ME) | Edited by bad_samt 27-12-2009 11:43 PM
User Avatar

bad_samt
Anbu


Posts: 270
Joined: 23.04.09
Location: Searcing........
import java.util.Random;
import java.util.Vector;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

/* ini adalah class utama game Labytinth */
public class Labyrinth extends MIDlet implements CommandListener {
//----------------------------------------------------------------
// game object fields

/**
* Canvas untuk menggambar Labyrinth
*/
private LabyrinthCanvas myCanvas;

/**
* Screen yang mengijinkan user untuk mengubah ukuran parameter dari
* Labyrinth.
*/
private SelectScreen mySelectScreen;

//----------------------------------------------------------------
// command fields

/**
* Command untuk keluar
*/
private Command myExitCommand = new Command("Keluar", Command.EXIT, 99);

/**
* Command untuk membuat game baru. (Command ini akan muncul di menu)
*/
private Command myNewCommand = new Command("Game Baru", Command.SCREEN, 1);

/**
* Command untuk menghilangkan alert error message. Di MIDP 2.0
* Alert diset untuk Alert.FOREVER secara otomatis sebagai default
* command untuk menghilangkan. Program ini tidak digunakan di command
* backwards
*/
private Command myAlertDoneCommand = new Command("Ok", Command.EXIT, 1);

/**
* Command untuk pergi ke screen yang mengijinkan user untuk mengubah
* ukuran parameter. (Command ini akan tampil di menu)
*/
private Command myPrefsCommand = new Command("Pilih Ukuran", Command.SCREEN, 1);

//----------------------------------------------------------------
// Inisialisasi
/**
* Inisialisasi canvas dan command
*/
public Labyrinth() {
try {
myCanvas = new LabyrinthCanvas(Display.getDisplay(this));
myCanvas.addCommand(myExitCommand);
myCanvas.addCommand(myNewCommand);
myCanvas.addCommand(myPrefsCommand);
myCanvas.setCommandListener(this);
} catch(Exception e) {
// Menampilkan alert ketika program erorr saat di jalnkan.
Alert errorAlert = new Alert("error",
e.getMessage(), null, AlertType.ERROR);
errorAlert.setCommandListener(this);
errorAlert.setTimeout(Alert.FOREVER);
errorAlert.addCommand(myAlertDoneCommand);
Display.getDisplay(this).setCurrent(errorAlert);
}
}
//----------------------------------------------------------------
// Implementasi dari MIDlet

/**
* Memulai aplikasi.
*/
public void startApp() throws MIDletStateChangeException {
if(myCanvas != null) {
myCanvas.start();
}
}

/**
* Membersihkan canvas.
*/
public void destroyApp(boolean unconditional)
throws MIDletStateChangeException {
myCanvas = null;
System.gc();
}

/**
* Menghentikan program sementara.
*/
public void pauseApp() {
}

//----------------------------------------------------------------
// implementasi dari CommandListener

/*
* Respon untuk command hasil dari Canvas.
* (reset, keluar, mengubah ukuran).
*/
public void commandAction(Command c, Displayable s) {
if(c == myNewCommand) {
myCanvas.newLabyrinth();
} else if(c == myAlertDoneCommand) {
try {
destroyApp(false);
notifyDestroyed();
} catch (MIDletStateChangeException ex) {
}
} else if(c == myPrefsCommand) {
if(mySelectScreen == null) {
mySelectScreen = new SelectScreen(myCanvas);
}
Display.getDisplay(this).setCurrent(mySelectScreen);
} else if(c == myExitCommand) {
try {
destroyApp(false);
notifyDestroyed();
} catch (MIDletStateChangeException ex) {
}
}
}

}

/**
* Class untuk display dari game.
*/
class LabyrinthCanvas extends javax.microedition.lcdui.Canvas {
//---------------------------------------------------------
// static fields
/**
* Warna tetap untuk dinding
*/
public static final int BLACK = 0x0000ff;
/**
* Warna tetap untuk jalur
*/
public static final int WHITE = 0xffffff;
//---------------------------------------------------------
// contoh fields
/**
* kontrol pada tampilan
*/
private Display myDisplay;
/**
* Objek data yang melukiskan konfigurasi Labyrinth.
*/
private Grid myGrid;
/**
* Menambah atau tidak display yang menampilkan Labyrinth telah lengkap/selesai
*/
private boolean myGameOver = false;
/**
* Dimensi Labyrinth: lebar dari dinding Labyrinth.
*/
private int mySquareSize;

/**
* Dimensi Labyrinth: lebar maksimum yang bisa ditampilkan untuk dinding Labyrinth.
*/
private int myMaxSquareSize;
/**
* Dimensi Labyrinth: lebar minimum yang bisa ditampilkan untuk dindig Labyrinth.
*/
private int myMinSquareSize;
/**
* sudut atas dari Tampilan kordinat X
*/
private int myStartX = 0;
/**
* sudut atas dari Tampilan Kordinat Y
*/
private int myStartY = 0;
/**
* berapa baris yang ditampilkan untuk membagi.
*/
private int myGridHeight;

/**
* berapa kolom yang digunakan untuk membagi.
*/
private int myGridWidth;
/**
* maksimum banyaknya kolom yang ditampilkan dapat dibagi.
*/
private int myMaxGridWidth;
/**
* minimum banyaknya kolom yang ditampilkan dapat dibagi.
*/
private int myMinGridWidth;
/**
* lokasi sebelumnya dari player pada Labyrinth: Kordinat X
* (berkaitan dengan koordinat dari grid Labyrinth, tdak berkaitan
* dengan sistem dari kanvas)
*/
private int myOldX = 1;

/**
* lokasi sebelumnya dari player pada Labyrinth: y-coordinate
* (berkaitan dengan koordinat dari grid Labyrinth, tdak berkaitan dengan sistem dari kanvas)
*/
private int myOldY = 1;
/**
* lokasi saat ini dari player dalam Labyrinth: x-coordiate
* (berkaitan dengan koordinat dari grid Labyrinth, tidak berkaitan dengan sistem dari kanvas)
*/
private int myPlayerX = 1;
/**
* lokasi saat ini dari player dalam Labyrinth: kordinat Y
* (berkaitan dengan koordinat dari grid Labyrinth, tidak berkaitan dengan sistem dari kanvas)
*/
private int myPlayerY = 1;

//-----------------------------------------------------
// gets / sets

/**
* Mengganti lebar dari dinding labyrinth dan memperhitungkan
* bagaimana pengaruh pergantian banyaknya baris dan kolom
* yang diijinkan Labyrinth the Labyrinth can have.
* @kembalikan banyaknya kolom sekarang dimana lebar
* kolom telah diperbarui width of the
*/
int setColWidth(int colWidth) {
if(colWidth < 2) {
mySquareSize = 2;
} else {
mySquareSize = colWidth;
}
myGridWidth = getWidth() / mySquareSize;
if(myGridWidth % 2 == 0) {
myGridWidth -= 1;
}
myGridHeight = getHeight() / mySquareSize;
if(myGridHeight % 2 == 0) {
myGridHeight -= 1;
}
myGrid = null;
return(myGridWidth);
}

/**
* @kembalikan lebar minimal yang diperbolehkan untuk dinding Labyrinth.
*/
int getMinColWidth() {
return(myMinSquareSize);
}

/**
* @kembalikan lebar maksimum yang diperbolehkan untuk dinding Labyrinth.
*/
int getMaxColWidth() {
return(myMaxSquareSize);
}

/**
* @kembalikan maksimum banyaknya kolom pada display yang dapat dibagi.
*/
int getMaxNumCols() {
return(myMaxGridWidth);
}

/**
* @kembalikan lebar dari dinding labyrinth.
*/
int getColWidth() {
return(mySquareSize);
}

/**
* @kembalikan banyaknya kolom Labyrinth yang menampilkan pemisah.
*/
int getNumCols() {
return(myGridWidth);
}

//-----------------------------------------------------
// inisialisasi dan pergantian keadaan game

/**
* Constructor melaksanakan kalkulasi ukuran.
* @memberi pengecualian jika tampilan ukuran terlalu kecil untuk
* membuat Labyrinth.
*/
public LabyrinthCanvas(Display d) throws Exception {
myDisplay = d;
// beberapa kalkulasi untuk membuat Labyrinth yang benar
// untuk tampilan saat ini.
int width = getWidth();
int height = getHeight();
// test menunjukkan bahwa 5 adalah suatu kelalaian baik ukuran bujur sangkar,
// tetapi user dapat menggantinya...
mySquareSize = 5;
myMinSquareSize = 3;
myMaxGridWidth = width / myMinSquareSize;
if(myMaxGridWidth % 2 == 0) {
myMaxGridWidth -= 1;
}
myGridWidth = width / mySquareSize;
if(myGridWidth % 2 == 0) {
myGridWidth -= 1;
}
myGridHeight = height / mySquareSize;
if(myGridHeight % 2 == 0) {
myGridHeight -= 1;
}
myMinGridWidth = 15;
myMaxSquareSize = width / myMinGridWidth;
if(myMaxSquareSize > height / myMinGridWidth) {
myMaxSquareSize = height / myMinGridWidth;
}
// jika tampilan terlalu kecil untuk membuat suatu Labyrint yang layak,
// kemudian kita memberi suatu Perkecualian
if(myMaxSquareSize < mySquareSize) {
throw(new Exception("Tampilan terlalu kecil"Wink);
}
}
/**
* Ini dipanggil segera setelah aplikasi dijalankan.
*/
void start() {
myDisplay.setCurrent(this);
repaint();
}
/**
* membuang Labyrinth yang sekarang dan menggambar yang baru.
*/
void newLabyrinth() {
myGameOver = false;
// membuang Labyrinth yang sekarang.
myGrid = null;
// set player kembali ke awal dari Labyrinth.
myPlayerX = 1;
myPlayerY = 1;
myOldX = 1;
myOldY = 1;
myDisplay.setCurrent(this);
// melukis Labyrinth yang baru
repaint();
}

//-------------------------------------------------------
// graphics methods

/**
* Membuat dan menampilkan Labyrinth jika diperlukan, sebaliknya hanya
* memindahkan player. sejak gerakan dalam game ini adalah sangat sederhana,
* ini tidak penting untuk melukis ulang keseluruhan Labyrinth stiap waktu
* hanya player + menghapus lapangan persegi
* bahwa player itu hanya sebelah kiri...
*/
protected void paint(Graphics g) {
// Jika tidak ada Labyrinth sekarang, membuat satu dan menggambarkannya.
if(myGrid == null) {
int width = getWidth();
int height = getHeight();
// membuat lapisan dalam data dari Labyrinth.
myGrid = new Grid(myGridWidth, myGridHeight);
// menggambar Labyrinth:
// pengulangan sampai data grid dan mewarnai masing-masing
// bujur sangkar warna yang benar
for(int i = 0; i < myGridWidth; i++) {
for(int j = 0; j < myGridHeight; j++) {
if(myGrid.mySquares[i][j] == 0) {
g.setColor(BLACK);
} else {
g.setColor(WHITE);
}
// mengisi persegi dangan warna yang tepat
g.fillRect(myStartX + (i*mySquareSize),
myStartY + (j*mySquareSize),
mySquareSize, mySquareSize);
}
}
// mengisi ruang yang ekstra diluar Labyrinth
g.setColor(BLACK);
g.fillRect(myStartX + ((myGridWidth-1) * mySquareSize),
myStartY, width, height);
// menghapus path exit:
g.setColor(WHITE);
g.fillRect(myStartX + ((myGridWidth-1) * mySquareSize),
myStartY + ((myGridHeight-2) * mySquareSize), width, height);
// mengisi ruang yang ekstra diluar Labyrith
g.setColor(BLACK);
g.fillRect(myStartX,
myStartY + ((myGridHeight-1) * mySquareSize), width, height);
}
// memberi warna player (merah):
g.setColor(255, 0, 0);
g.fillRoundRect(myStartX + (mySquareSize)*myPlayerX,
myStartY + (mySquareSize)*myPlayerY,
mySquareSize, mySquareSize,
mySquareSize, mySquareSize);
// menghapus lokasi sebelumnya
if((myOldX != myPlayerX) || (myOldY != myPlayerY)) {
g.setColor(WHITE);
g.fillRect(myStartX + (mySquareSize)*myOldX,
myStartY + (mySquareSize)*myOldY,
mySquareSize, mySquareSize);
}
// jika player telah mencapai akhir dari Labyrinth,
// kita menampilkan pesan selesai.
if(myGameOver) {
// melakukan beberapa kalkulasi untuk tempat text dengan tepat:
int width = getWidth();
int height = getHeight();
Font font = g.getFont();
int fontHeight = font.getHeight();
int fontWidth = font.stringWidth("Selamat..."Wink;
g.setColor(WHITE);
g.fillRect((width - fontWidth)/2, (height - fontHeight)/2,
fontWidth + 2, fontHeight);
// memberi warna merah
g.setColor(255, 0, 0);
g.setFont(font);
g.drawString("Selamat...", (width - fontWidth)/2,
(height - fontHeight)/2,
g.TOP|g.LEFT);
}
}

/**
* Memindahkan player.
*/
public void keyPressed(int keyCode) {
if(! myGameOver) {
int action = getGameAction(keyCode);
switch (action) {
case LEFT:
if((myGrid.mySquares[myPlayerX-1][myPlayerY] == 1) &&
(myPlayerX != 1)) {
myOldX = myPlayerX;
myOldY = myPlayerY;
myPlayerX -= 2;
repaint();
}
break;
case RIGHT:
if(myGrid.mySquares[myPlayerX+1][myPlayerY] == 1) {
myOldX = myPlayerX;
myOldY = myPlayerY;
myPlayerX += 2;
repaint();
} else if((myPlayerX == myGrid.mySquares.length - 2) &&
(myPlayerY == myGrid.mySquares[0].length - 2)) {
myOldX = myPlayerX;
myOldY = myPlayerY;
myPlayerX += 2;
myGameOver = true;
repaint();
}
break;
case UP:
if(myGrid.mySquares[myPlayerX][myPlayerY-1] == 1) {
myOldX = myPlayerX;
myOldY = myPlayerY;
myPlayerY -= 2;
repaint();
}
break;
case DOWN:
if(myGrid.mySquares[myPlayerX][myPlayerY+1] == 1) {
myOldX = myPlayerX;
myOldY = myPlayerY;
myPlayerY += 2;
repaint();
}
break;
}
}
}

}

/**
* Ini adalah tampilan yang memperbolehkan user untuk mengubah
* lebar dari dinding Labyrinth..
*/
class SelectScreen extends Form
implements ItemStateListener, CommandListener {

//----------------------------------------------------------------
// Dasar

/**
* Button "Ok" untuk keluar dari screen ini dan kembali ke Labyrinth.
*/
private Command myExitCommand = new Command("Ok", Command.EXIT, 1);

/**
* Gauge yang mengubah lebar dari dinding Labyrinth.
*/
private Gauge myWidthGauge;

/**
* Gauge yang mengubah tampilan banyaknya kolom pada Labyrinth.
*/
private Gauge myColumnsGauge;

/**
* kontrol terpenting pada game canvas.
*/
private LabyrinthCanvas myCanvas;

//----------------------------------------------------------------
// initialization

/**
* Membuat gauges dan tempatnya pada screen.
*/
public SelectScreen(LabyrinthCanvas canvas) {
super("Pilih Ukuran"Wink;
addCommand(myExitCommand);
setCommandListener(this);
myCanvas = canvas;
setItemStateListener(this);
myWidthGauge = new Gauge("Lebar Kolom", true,
myCanvas.getMaxColWidth(),
myCanvas.getColWidth());
myColumnsGauge = new Gauge("Jumlah Kolom", false,
myCanvas.getMaxNumCols(),
myCanvas.getNumCols());
// Peringatan: method setLayout belum terdapat pada
// MIDP 1.4. Jika ada perubahan pada target
// device akan menggungkan MIDP 1.4, keluarkan
// dua baris komentar di bawah ini:
//myWidthGauge.setLayout(Item.LAYOUT_CENTER);
//myColumnsGauge.setLayout(Item.LAYOUT_CENTER);
append(myWidthGauge);
append(myColumnsGauge);
}

//----------------------------------------------------------------
// implementasu dari ItemStateListener

/**
* Merespon user untuk mengubah lebar.
*/
public void itemStateChanged(Item item) {
if(item == myWidthGauge) {
int val = myWidthGauge.getValue();
if(val < myCanvas.getMinColWidth()) {
myWidthGauge.setValue(myCanvas.getMinColWidth());
} else {
int numCols = myCanvas.setColWidth(val);
myColumnsGauge.setValue(numCols);
}
}
}

//----------------------------------------------------------------
// implementasen dari CommandListener

/*
* Merespon command hasil dari screen.
* (salah satu dari reset atau exit).
*/
public void commandAction(Command c, Displayable s) {
if(c == myExitCommand) {
myCanvas.newLabyrinth();
}
}

}


/**
* Class berisi data yang diperlukan untuk menggambar Labyrinth.
*/
class Grid {

/**
* Random number generator untuk membuat random Labyrinth.
*/
private Random myRandom = new Random();

/**
* data untuk persegi yang penuh dan yang kosong.
* 0 = hitam
* 1 = putih
* nilai lebih dari 1 akan menggunakan algoritma
* pembuatan Labyrinth.
*/
int[][] mySquares;

/**
* Membuat labirin baru.
*/
public Grid(int width, int height) {
mySquares = new int[width][height];
// initialize all of the squares to white except a lattice
// framework of black squares.
for(int i = 1; i < width - 1; i++) {
for(int j = 1; j < height - 1; j++) {
if((i % 2 == 1) || (j % 2 == 1)) {
mySquares[i][j] = 1;
}
}
}
// jalan masuk dari Labyrinth adalah pada (0,1).
mySquares[0][1] = 1;
createLabyrinth();
}

/**
* Method untuk mengacak pembangkitan Labyrinth.
*/
private void createLabyrinth() {
// membuat inisial framework dari black squares.
for(int i = 1; i < mySquares.length - 1; i++) {
for(int j = 1; j < mySquares[i].length - 1; j++) {
if((i + j) % 2 == 1) {
mySquares[i][j] = 0;
}
}
}
// inisialisasi squares yang dapat diantara hitam atau putih
// tergantung pada Labyrinth.
// Pertama kita mengeset nilai untuk 3 cara yang meragukan.
for(int i = 1; i < mySquares.length - 1; i+=2) {
for(int j = 1; j < mySquares[i].length - 1; j+=2) {
mySquares[i][j] = 3;
}
}
// Kemudian squares itu yang dapat terpilih untuk dibuka
// (putih) path yang memberi nilai dari 2.
// Kita memilih acak square dimana pohon dari Labyrinth
// path akan dimulai. Labyrinth membangkitkan starting dari
// inisial square ini dan cabang keluar dari semua
// arah untuk memenuhi grid Labyrinth.
Vector possibleSquares = new Vector(mySquares.length
* mySquares[0].length);
int[] startSquare = new int[2];
startSquare[0] = getRandomInt(mySquares.length / 2)*2 + 1;
startSquare[1] = getRandomInt(mySquares[0].length / 2)*2 + 1;
mySquares[startSquare[0]][startSquare[1]] = 2;
possibleSquares.addElement(startSquare);
// Disini kita mengulang pilihan squares satu per satu untuk
// menampilkan jalan kecil Labyrinth.
while(possibleSquares.size() > 0) {
// Square selanjutnya untuk digabungkan pada pilihan acak.
int chosenIndex = getRandomInt(possibleSquares.size());
int[] chosenSquare = (int[])possibleSquares.elementAt(chosenIndex);
// kita mengeset pilihan square ke putih dan kemudian
// hapus ini dari list possibleSquares (i.e. squares
// yang mungkin dapat ditambah untuk Labyrinth), dan kita hubungkan
// square baru untuk Labyrinth.
mySquares[chosenSquare[0]][chosenSquare[1]] = 1;
possibleSquares.removeElementAt(chosenIndex);
link(chosenSquare, possibleSquares);
}
// sekarang Labyrinth telah lengkap dibangkitkan, kita
// berikan jauh objek yang dibuat selama algoritma
// pembuatan Labyrinth dan memperoleh kembali memory.
possibleSquares = null;
System.gc();
}

/**
* internal untuk createLabyrinth. Checks 4 squares melingkupi
* pilihan square. Dari situ bahwa telah disambungkan untuk
* Labyrinth, atu dari pilihan acak digabungkan untuk
* square saat ini (untuk menyertakan square yang sekarang pada
* pertumbuhan Labyrinth). Square itu yang tidak sebelumnya dalam
* posisi untuk digabungkan pada Labyrinth yang ditambahkan pada list
* "possible" squares (itu dapat dipilih untuk bersama
* Labyrinth pada round berikutnya).
*/
private void link(int[] chosenSquare, Vector possibleSquares) {
int linkCount = 0;
int i = chosenSquare[0];
int j = chosenSquare[1];
int[] links = new int[8];
if(i >= 3) {
if(mySquares[i - 2][j] == 1) {
links[2*linkCount] = i - 1;
links[2*linkCount + 1] = j;
linkCount++;
} else if(mySquares[i - 2][j] == 3) {
mySquares[i - 2][j] = 2;
int[] newSquare = new int[2];
newSquare[0] = i - 2;
newSquare[1] = j;
possibleSquares.addElement(newSquare);
}
}
if(j + 3 <= mySquares[i].length) {
if(mySquares[i][j + 2] == 3) {
mySquares[i][j + 2] = 2;
int[] newSquare = new int[2];
newSquare[0] = i;
newSquare[1] = j + 2;
possibleSquares.addElement(newSquare);
} else if(mySquares[i][j + 2] == 1) {
links[2*linkCount] = i;
links[2*linkCount + 1] = j + 1;
linkCount++;
}
}
if(j >= 3) {
if(mySquares[i][j - 2] == 3) {
mySquares[i][j - 2] = 2;
int[] newSquare = new int[2];
newSquare[0] = i;
newSquare[1] = j - 2;
possibleSquares.addElement(newSquare);
} else if(mySquares[i][j - 2] == 1) {
links[2*linkCount] = i;
links[2*linkCount + 1] = j - 1;
linkCount++;
}
}
if(i + 3 <= mySquares.length) {
if(mySquares[i + 2][j] == 3) {
mySquares[i + 2][j] = 2;
int[] newSquare = new int[2];
newSquare[0] = i + 2;
newSquare[1] = j;
possibleSquares.addElement(newSquare);
} else if(mySquares[i + 2][j] == 1) {
links[2*linkCount] = i + 1;
links[2*linkCount + 1] = j;
linkCount++;
}
}
if(linkCount > 0) {
int linkChoice = getRandomInt(linkCount);
int linkX = links[2*linkChoice];
int linkY = links[2*linkChoice + 1];
mySquares[linkX][linkY] = 1;
int[] removeSquare = new int[2];
removeSquare[0] = linkX;
removeSquare[1] = linkY;
possibleSquares.removeElement(removeSquare);
}
}

/* Kegunaan randomisasi.*/
public int getRandomInt(int upper) {
int retVal = myRandom.nextInt() % upper;
if(retVal < 0) {
retVal += upper;
}
return(retVal);
}
}

klo males copas download aja
http://www.4shared.com/file/182247478/e4e83794/Labyrinth.html

sory qw uploadnya di 4share,kebetulan pas qw upload IDWS lg maintinance sever
 
Offline
06-01-2010 06:47 PM RE: Game labirin pake JAVA(J2ME)
User Avatar

zeetaken
Genin


Posts: 46
Joined: 10.01.09
Age: 30
MabokMabokMabok

afa'an tuch om?????
 
Offline
Jump to Forum:
Forum powered by fusionBoard
Share this Thread
URL:
BBcode:
HTML:
Similar Threads
Thread Forum Replies Last Post
eBook Java Bahasa Indonesia Aplikasi POS Berarsitektur Three Tier Menggunakan Swing, Hibernate, da E-Book 12 03-02-2014 22:21
Game Subway Surfers For PC (full) Out Of Topic 4 21-04-2013 22:27
Cargo Bridge (Flash Game) Software 8 30-08-2012 02:02
Dasar Pemrograman Java - Chapter02 x Input Proses Output Java 2 01-05-2012 06:23
Dasar Pemrograman Java - Chapter01 x Requirement, Compile, Error & Run Java 3 01-04-2012 10:33
Copyright © 2007-2016