Game 2D selalu sangat populer. Banyak dari Anda harus telah memainkan game 2D seperti 'Super Mario' di sana anak-anak. Dalam dunia PC dan konsol sebagian besar game telah berkembang ke format 3D. Dengan munculnya game mobile game 2D telah kembali kembali dengan kekuatan penuh. Banyak orang seperti permainan sisi bergulir 2D pada kenyataannya bahkan lebih dari game 3D. Dengan demikian permainan 2D merupakan bagian penting dari arena mobile gaming. Dalam bab ini kita akan membahas game ponsel 2D secara mendalam. Alasan untuk berkonsentrasi pada permainan 2D adalah bahwa hampir semua game mobile yang baik hari ini adalah game action 2D.
Dalam bab ini kita akan mempelajari game 2D ponsel pada umumnya. Kami juga akan membahas tentang mesin permainan di API yang berbeda.
Fitur game 2D
Setiap game 2D biasanya berisi:
·
Sprite
Sprite adalah elemen penting dari sebuah game arcade. Sebagaimana
telah kita bahas sebelumnya, sprite adalah benda yang bisa bergerak,
memukul, berjalan melawan dan melakukan segala macam hal yang objek
dunia nyata dilakukan. Mereka dapat animasi maupun non - animasi. Ada tindakan mungkin dapat dikendalikan oleh pemain maupun non-dikendalikan oleh pemain. Mereka mungkin positif dalam tindakan mereka atau mereka mungkin negatif.
Sebenarnya, kita dapat membandingkan sprite untuk para aktor dalam sebuah film. Jadi sprite adalah bagian paling penting dari setiap permainan arcade. Tanpa sprite tidak ada arcade game.
Sprite perlu melakukan banyak fungsi dan dengan demikian biasanya diprogram sebagai kelas terpisah. Juga umumnya semua frame dari Sprite yang terkandung dalam satu gambar PNG. Angka
ini menunjukkan bagaimana hal ini telah dilakukan dalam permainan 'SKJ
Gubbare' yang tersedia secara komersial termasuk antara lain Reliance
Infocomm yang RWORLD dan jaringan Tata Indicom itu.
Sprite biasanya dari jenis berikut:
o Utama Pahlawan Sprite
o Mendukung Sprite Karakter
o Utama penjahat Sprite
o Sekunder penjahat Sprite
o Tersier penjahat Sprite
·
Cerita
Cerita ini merupakan komponen yang sangat penting dari sebuah permainan. Dalam storyboard kita mencoba untuk mendefinisikan peran, kepentingan dan karakteristik setiap tahap dan sprite dalam permainan. Pertanyaan-pertanyaan berikut membantu untuk menentukan cerita yang lebih baik:
·
Apa tujuan dari karakter utama dalam permainan?
·
Apa itu titik awal dari permainan?
·
Apa itu titik akhir dari permainan?
·
Yang merupakan tahapan yang berbeda dalam permainan?
·
Apa itu titik awal dari setiap tahap dalam permainan?
·
Apakah titik akhir setiap tahap dalam permainan?
·
Apa adegan utama dalam setiap tahap?
·
Yang sprite terlibat dalam setiap adegan di panggung?
·
Apa yang akan menjadi fitur khusus dari latar belakang setiap tahap?
·
Apa yang akan menjadi hal unik dalam permainan yang akan membuat permainan menarik?
Mendapatkan
jawaban atas pertanyaan-pertanyaan ini sangat penting sebelum memulai
pemrograman dan pengembangan karya seni untuk permainan.
·
Beberapa Tahapan
Setiap pertandingan biasanya memiliki beberapa tingkatan. Setiap tingkat harus memiliki sesuatu yang menarik tentang hal itu agar pemain tetap bermain itu. Tingkat harus dirancang dengan mengingat atas semua tujuan dari permainan. Hal yang perlu diingat, terutama ketika merancang game arcade pada ponsel, adalah bahwa sumber daya sangat terbatas. Pada banyak perangkat memori maksimum yang mungkin untuk sebuah game adalah 64 kb memori. Dalam beberapa handset hitam putih ukuran aplikasi maksimum harus dibatasi menjadi 32 kb. Jadi desain harus sederhana dan karya seni harus kreatif kembali digunakan sebanyak mungkin.
Setiap permainan harus memiliki lebih dari satu tingkat agar pengguna untuk benar-benar terlibat. Crossing tingkat adalah salah satu wortel terbesar seorang pemain dapat memiliki untuk bermain game. Latar belakang dapat tetap sama atau berubah sesuai dengan permintaan dari cerita. Either way titik utama adalah bahwa harus ada setidaknya 3 sampai 4 tingkat untuk membuat permainan menarik. Saat ini ada permainan di pasar, yang memiliki lebih dari 12 tingkat. Dengan demikian jumlah tingkat harus disimpan pada maksimum yang mungkin menurut waktu dan anggaran.
Perencanaan yang cermat harus dilakukan untuk setiap tahap. Kami biasanya harus istirahat setiap tahap ke dalam adegan yang berbeda. Kami kemudian harus merencanakan setiap adegan individual. Proses ini harus diulang untuk setiap tahap. Untuk setiap adegan yang harus kita tentukan berikut ini:
·
Adegan masuk
·
Adegan keluar
·
Hiburan nilai
·
Sprite terlibat dalam sebuah adegan
·
Adegan latar belakang
Setelah mendefinisikan setiap adegan di panggung kita harus hati-hati merencanakan ada urutan dalam panggung. Kita harus merencanakan mereka sedemikian rupa sehingga kelangsungan panggung tidak pecah. Di sinilah Anda harus merencanakan untuk lubang warp.
Apa Lubang Warp?
Lubang
warp adalah wilayah yang memungkinkan karakter untuk melompat ke tempat
tertentu dalam tahap yang lain tanpa melalui proses finishing semua
tahap menengah.
/ / Foto untuk beberapa adegan dalam beberapa tahapan dengan lubang warp
·
Latar belakang
Latar
belakang terdiri dari pohon-pohon, awan, jalan yang sprite dll langkah
ini dapat dijiwai serta statis dan tidak mengambil sumber daya sebanyak
sprite biasanya membutuhkan. Mereka sebenarnya set permainan kami. Seperti kita bahas sebelumnya latar belakang harus diputuskan untuk setiap adegan dan panggung. Pertimbangan yang cermat perlu diberikan untuk perencanaan latar belakang. Kita juga harus diingat bahwa permainan tertentu harus porting ke handset yang berbeda dengan ukuran layar yang berbeda. Jadi kita harus mengambil yang juga menjadi pertimbangan ketika merancang latar belakang.
Umumnya dalam permainan 2D latar belakang terdiri dari satu set ubin yang berulang kali digunakan. Strip gambar di bawah berisi 5 ubin yang berulang kali digunakan dalam 'SKJ Gubbare'.
·
Tujuan
Karakter
dari game biasanya memiliki karakteristik tertentu yang membantu dalam
mendefinisikan tujuan dan membawa unsur semangat juang dalam pemain. Hal-hal sederhana seperti poin dapat meningkatkan tingkat pemenuhan pemain memiliki dari permainan. Dengan demikian poin biasanya harus dimasukkan. Bagaikan sebuah perjalanan tanpa tujuan tidak berguna sehingga adalah permainan tanpa gol.
Waktu-waktu tertentu cerita dapat dibuat lebih menarik dengan memperkenalkan tujuan tahap sekunder bijaksana. Misalnya mengumpulkan kunci di akhir setiap tahap bisa membuat panggung lebih menarik.
·
Sumber Daya
Sumber daya adalah bagian integral dari setiap pertandingan. Karakter utama dapat memiliki jenis berikut sumber daya:
·
Poin
·
Beberapa peluang
·
Tingkat energi
·
Senjata
Bahkan sprite penjahat dapat memiliki berikut ini:
·
Beberapa peluang
·
Tingkat energi
·
Senjata
Ketika merencanakan untuk sumber daya pemain dan penjahat kita harus diingat nilai hiburan yang pemain akan berasal dari mereka. Sebuah sprite penjahat memiliki toko besar energi akan membuat hal sulit bagi pemain dan kegembiraan peningkatan! Jadi
umumnya untuk membuat permainan sulit sprite penjahat yang sama bisa
memiliki lebih banyak sumber daya dalam stadium lanjut.
Rincian Teknis
Pada bagian ini kita akan membahas aspek teknis mesin permainan. Kami
akan membahas secara rinci setiap aspek teknis dari sudut pandang MIDP
2.0, MIDP 1.0 dan Nokia UI API (Dalam hal diperlukan).
·
Sprite
Sprite memiliki karakteristik tertentu. Karakteristik ini menentukan lingkup teknis dari tindakan sprite. Karakteristik ini hanya indikasi dan karakteristik tertentu dapat ditambahkan atau dihapus sesuai dengan sifat dari permainan. Sprite biasanya memiliki karakteristik sebagai berikut:
- Posisi
- Gerakan
- Animasi
- Tabrakan
- Daya variabel
Sejak sprite adalah entitas kompleks biasanya kita menulis kelas kustom dalam MIDP 1.0 untuk mereka. Hal ini membantu dalam mengurangi kompleksitas dari kode game yang sebenarnya. MIDP 2.0 memiliki API game yang berisi kelas Sprite. Untuk
kepentingan pembaca yang tertarik dalam pemrograman untuk MIDP 1.0 Saya
telah menyertakan kode untuk kelas Sprite di bagian ini. Kami juga akan membahas berbagai variabel dan metode di kelas Sprite kebiasaan kami. Ini
kelas sprite termasuk industri skala kode tingkat penuh dan dapat
digunakan tanpa modifikasi dalam setiap proyek praktis Anda. Saya
bahkan akan merekomendasikan para pembaca yang terutama tertarik dalam
pengembangan permainan MIDP 2.0 untuk membaca bagian ini karena akan
meningkatkan ada pemahaman tentang perilaku sprite.
Sprite Kelas
Kelas Sprite dibahas di sini adalah kelas sub Layer. Layer kelas telah dibuat dalam rangka untuk kelas TiledLayer untuk memperpanjang kelas Layer. Kelas TiledLayer digunakan untuk fungsi latar belakang. Kita akan membahas kelas ini secara rinci nanti pada saat kita akan membahas topik pemrograman latar belakang gambar.
/ *
* Layer.java
*
* Dibuat pada 20 Mei, 2002 16:44
* /
mengimpor javax.microedition.lcdui *;.
/ **
*
* @ Saurabh Jain penulis
* @ Version 1.0.0
* /
Lapisan masyarakat kelas abstrak
{
/ / Mendeklarasikan semua variabel swasta
private int x;
private int y;
lebar int swasta;
int tinggi swasta;
boolean swasta tampak;
/ *********************************** /
/ / Getter metode
/ *********************************** /
public int getX ()
{
kembali this.x;
}
public int getY ()
{
kembali this.y;
}
public int getWidth ()
{
kembali this.width;
}
public int getHeight ()
{
kembali this.height;
}
public boolean getVisible ()
{
kembali this.visible;
}
/ *********************************** /
/ / Setter metode
/ *********************************** /
public void setVisible (boolean terlihat)
{
this.visible = terlihat;
}
public void setWidth (lebar int)
{
this.width = lebar;
}
public void setHeight (int tinggi)
{
this.height = tinggi;
}
public void setPosition (int x, int y)
{
this.x = x;
this.y = y;
}
/ *********************************** /
/ / Metode lain
/ *********************************** /
public boolean isVisible ()
{
kembali this.visible;
}
public void bergerak (int x, int y)
{
this.x + = x;
this.y + = y;
}
publik void paint abstrak (Graphics g);
}
/ *
* Sprite.java
*
* Dibuat pada 20 Mei, 2002 04:45
* /
mengimpor javax.microedition.lcdui *;.
/ **
*
* @ Saurabh Jain penulis
* @ Version 1.0.0
* /
Sprite kelas publik meluas Lapisan
{
/ / Mendeklarasikan variabel Instance
swasta Gambar gambar;
private int bingkai;
private int negara;
swasta Sprite sprite;
publik Sprite (Image img, int frWidth, int frHeight)
{
this.image = img;
this.setWidth (frWidth);
this.setHeight (frHeight);
}
/ / Batas tabrakan kotak
public boolean collidesWith (Sprite sprite)
{
if (this.getVisible () == false | | sprite.getVisible () == false)
{
return false;
}
int lx = this.getX ();
int ly = this.getY ();
int lwidth = this.getWidth ();
int lheight = this.getHeight ();
int SPX = sprite.getX ();
int = mata-mata sprite.getY ();
int spwidth = sprite.getWidth ();
int spheight = sprite.getHeight ();
if (lx <= SPX &&
ly <= mata-mata &&
lx + lwidth> = SPX &&
ly + lheight> = mata-mata)
{
return true;
}
lain jika (lx <= SPX + spwidth &&
ly <= mata-mata &&
lx + lwidth> = SPX + spwidth &&
ly + lheight> = mata-mata)
{
return true;
}
lain jika (lx <= SPX &&
ly <= mata-mata + spheight &&
lx + lwidth> = SPX &&
ly + lheight> = mata-mata + spheight)
{
return true;
}
lain jika (lx <= SPX + spwidth &&
ly <= mata-mata + spheight &&
lx + lwidth > = + SPX spwidth &&
ly + lheight> = mata-mata + spheight)
{
return true;
}
lain
{
return false;
}
}
/ *********************************************** /
/ / Getter metode
/ *********************************************** /
public int getFrame ()
{
kembali this.frame;
}
public int getState ()
{
kembali this.state;
}
/ *********************************************** /
/ / Setter metode
/ *********************************************** /
public void setFrame (int fr)
{
this.frame = fr;
}
public void setState (int negara)
{
this.state = negara;
}
public void paint (Graphics g)
{
if (this.getVisible () == true)
{
int lx = g.getClipX ();
int ly = g.getClipY ();
int lWidth = g.getClipWidth ();
int lHeight = g.getClipHeight ();
g.setClip (this.getX (), this.getY (), this.getWidth (), this.getHeight ());
g.drawImage (this.image, this.getX () - (frame * this.getWidth ()), this.getY (), Graphics.TOP | Graphics.LEFT);
g.setClip (lx, ly, lWidth, lHeight);
}
}
}
Sprite Kelas Variabel
Dalam bagian sub-kita akan membahas variabel dari kelas sprite. Sprite biasanya memiliki variabel-variabel berikut:
Gambar
Gambar mengacu pada file gambar yang mewakili grafis sprite. Grafik ini harus hati-hati bekerja atas untuk membuat permainan lebih menghibur. MIDP 1.0 hanya mendukung PNG (Portable Network Graphics) file. Jadi semua karya seni Anda harus selalu dikonversi ke dalam format PNG terlebih dahulu untuk digunakan. Juga perawatan harus dilakukan untuk memastikan bahwa gambar PNG yang diambil adalah gambar 32 bit. Jika gambar Anda adalah sedikit gambar PNG 24, Anda kode akan memunculkan eksepsi.
Hal lain yang harus hati-hati bekerja adalah jumlah frame sprite Anda akan memiliki. Untuk menghemat ruang dianjurkan untuk memasukkan semua frame dalam satu file PNG dalam satu baris. Setiap frame biasanya harus dengan lebar sama dan tinggi. Menyimpan
semua frame dari sebuah sprite tertentu dalam satu file biasanya
menyimpan banyak ruang berharga sebagai informasi header dari file PNG
ini kemudian sering digunakan oleh semua frame.
Ini adalah gambaran tentang bagaimana Anda harus menyimpan sprite Anda:
Dalam contoh ini ikan tersebut memiliki 3 frame. Kita
akan menggunakan metode setFrame () yang telah kita bahas nanti dalam
bab ini untuk menetapkan frame yang benar untuk sprite dari gambar ini.
X posisi
Posisi X mengacu pada x saat ini koordinasi dari sprite. Ini digunakan dengan metode cat dan metode deteksi tabrakan. Perubahan variabel ini bergerak sprite horizontal.
Y posisi
Posisi Y mengacu pada y saat ini koordinasi dari sprite. Ini digunakan dengan metode cat dan metode deteksi tabrakan. Perubahan variabel ini bergerak sprite secara vertikal.
Lebar
Lebar mengacu pada lebar frame. Biasanya
dianjurkan untuk mengatur lebar yang sama untuk semua frame sehingga
satu variabel int cukup untuk menyimpan informasi ini.
Tinggi
Tinggi mengacu pada ketinggian frame. Hal
ini juga dianjurkan untuk menjadi yang sama untuk semua frame dari
sebuah sprite tertentu untuk menghindari kompleksitas yang tidak perlu
dalam kode.
Visibilitas Status
Ini adalah variabel boolean yang biasanya digunakan untuk menentukan apakah sprite saat terlihat atau tidak. Metode cat menggunakannya untuk menentukan apakah harus menggambar sprite di kanvas.
Bingkai
Bingkai mengacu pada frame dari sprite. Variabel ini biasanya harus int. Yang
menyimpan jumlah frame dan digunakan dengan metode cat dari sprite
untuk menentukan frame yang akan dicat pada saat x dan y koordinat.
Negara
Negara biasanya variabel int. Ini adalah variabel yang bisa memiliki banyak kegunaan. Ini bisa digunakan untuk kode apakah sprite dalam keadaan anak atau negara dewasa. Atau juga dapat digunakan untuk menentukan apakah sprite dalam keadaan terluka atau tidak aktif. Kami akan menggunakan variabel negara untuk tugas yang sangat penting.
Anda dapat memiliki variabel lain tergantung pada kebutuhan permainan Anda. Beberapa karakteristik penting juga dapat ditinggalkan untuk membuat jalan bagi karya seni lebih. Masing-masing adalah memiliki sebuah utilitas penting dari sana sendiri dan dengan demikian selanjutnya dibahas secara rinci.
Sprite metode:
Ada beberapa metode tertentu yang biasanya melaksanakan fungsi umum dari sprite. Metode ini meskipun tidak direkomendasikan untuk digunakan secara wajib. Ada inklusi atau pengecualian tergantung pada sifat dari sprite. Juga ada isi tergantung pada sifat dari fungsi sprite. Metode ini telah diberikan di bawah ini.
Pembina
Konstruktor dari sprite adalah seperti konstruktor dari kelas lain dalam hal fungsi. Dalam konstruktor sprite, sebuah objek sprite dibuat dengan variabel dibahas di atas.
CollidesWith (Sprite sprite)
CollidesWith () metode adalah metode yang mendeteksi benturan antara sprite dengan sprite lain. Tabrakan merupakan salah satu bagian paling penting dari setiap permainan arcade. Tabrakan yang tepat adalah suatu keharusan untuk permainan yang baik. Ada berbagai jenis pendeteksian tabrakan. Tak satu pun dari mereka saat ini sedang didukung dengan mekanisme built-in dalam Informasi Mobile Device Profile 1.0. Informasi Mobile Device Profile 2.0 mendukung 2 jenis deteksi tumbukan, yaitu:
·
Batas deteksi tabrakan persegi panjang
·
Bit-bertopeng tabrakan deteksi pixel yaitu tingkat deteksi tabrakan
Berikut ini adalah berbagai jenis deteksi tabrakan yang umumnya digunakan:
i. Batas deteksi tabrakan persegi panjang
Ini sederhana dan cepat tabrakan teknik deteksi. Dalam kode digambarkan di atas kita telah membahas 'persegi panjang berlari tabrakan.
ii. Tabrakan deteksi dengan berbagai tingkat
Ini
adalah teknik tabrakan kompleks yang membutuhkan waktu lebih dan
memori, tetapi lebih efektif dalam menangkap memegang tabrakan, maka
teknik yang dibahas di atas. Berikut sprite dibagi ke daerah-daerah yang berbeda yang disebut tingkat. Wilayah terluas adalah tingkat akar dan tidak memiliki tingkat orangtua lainnya. Setiap tingkat dapat memiliki tingkat lain di dalamnya. Tingkat sprite dibandingkan dengan masing-masing sprite lain untuk mengetahui apakah ada dua tingkat telah bertabrakan. Tabrakan untuk setiap zona diimplementasikan dengan cara yang mirip dengan teknik yang dibahas di atas. Berikut ini adalah potongan kode untuk teknik tabrakan:
tingkat int dilindungi [] [] = {0, 0, 10, 14}, {3, 2, 4, 11}};
public int bertabrakan (Sprite sprite)
{
for (int i = 0; I <levels.length; i + +)
{
if ((tingkat [i] [0] + tingkat [I] [2])> sprite.getX () && tingkat [i] [0] <sprite.getX () &&
(Tingkat [i] [1] + tingkat [I] [3]> sprite.getY () &&
tingkat [i] [1] <sprite.getY ())
kembali i;
}
return -1;
}
iii. Tabrakan deteksi dengan beberapa daerah
Berikut daerah sprite ini dibagi ke daerah persegi panjang. Daerah sini berbeda dibandingkan satu sama lain untuk mengetahui tumbukan. Kehebatan
dari teknik ini adalah bahwa daerah bahkan sangat kecil seperti hidung
bisa dibuat menjadi persegi panjang terpisah yang bisa diperiksa. Hal ini memberikan dorongan luar biasa untuk hasil hasil tabrakan. Potongan kode adalah sebagai berikut:
daerah int dilindungi [] [] = {2, 1, 6, 3}, {3, 4, 4, 5}, {0, 9, 10, 14}};
public boolean bertabrakan (Sprite sprite)
{
for (int i = 0; I <areas.length; i + +)
{
if ((daerah [i] [0] + daerah [I] [2])> sprite.getX () &&
daerah [i] [0] <sprite.getX () &&
(Daerah [i] [1] + daerah [I] [3]> sprite.getY ()
&&
daerah [i] [1] <sprite.getY ())
return true;
}
return false;
}
iv. Bit-bertopeng collision detection
Tabrakan Bit bertopeng adalah bentuk terbaik dari tabrakan dalam hal hasil tabrakan. Hal ini dapat memeriksa pada tingkat piksel. Tapi pada saat yang sama itu tidak secepat teknik-teknik yang diberikan di atas.
Kami
biasanya menggunakan tabrakan persegi panjang melompat-lompat karena
merupakan yang paling cepat dan paling mudah dimengerti.
Cat
Metode cat digunakan untuk melukis gambar bingkai nyata dari sprite ke objek grafis yang disediakan untuk itu.
Pindah
Pindah adalah metode yang sangat penting karena memungkinkan sprite untuk melakukan berbagai aksi. Metode
langkah adalah metode sederhana yang mengubah x dan y koordinat sprite
dengan jumlah piksel yang diberikan dalam parameter.
Getter metode
Metode pengambil untuk sebagian besar metode yang dibahas di atas harus ditulis menurut sana menggunakan dalam permainan. Pendekatan murni berorientasi objek meskipun baik pada PC harus dibuang dalam pemrograman ponsel karena keterbatasan memori. Jadi hanya metode-metode yang bermanfaat harus ditambahkan.
Metode setter
Metode setter juga harus sama ditulis sesuai dengan ada gunakan untuk menghemat ruang.
Jadi kita melihat bagaimana kita dapat membuat kelas Sprite pada MIDP 1.0. Adapun MIDP 2.0, mendefinisikan kelas Sprite sendiri yang telah kita bahas sebelumnya. Jadi sekarang Anda tahu cara kerja kelas Sprite cukup luas.
·
TiledLayer
Kelas TiledLayer adalah kelas yang membantu kita dalam menggambar latar belakang 2D yang kompleks dari beberapa ubin. Kelas TiledLayer adalah sub-class khusus kelas Layer. Ini membagi latar belakang ke dalam sel tetap lebar dan tinggi seperti sel MS Excel. Satu-satunya perbedaan adalah bahwa setiap sel TiledLayer adalah ukuran yang sama. Di sini kita akan membahas pelaksanaan MIDP 1.0 dari kelas TiledLayer. Kode lengkap dari kelas TiledLayer di MIDP 1.0 adalah sebagai berikut:
/ *
* TiledLayer.java
*
* Dibuat pada 20 Mei, 2002 04:48
* /
mengimpor javax.microedition.lcdui *;.
/ **
*
* @ Author Saurabh Jain
* @ Version 1.00
* /
TiledLayer kelas publik meluas Lapisan
{
private int kolom;
private int baris;
swasta Gambar gambar;
private int tWidth;
private int tHeight;
private int [] [] sel;
private int tIndex;
/ / Konstruktor
publik TiledLayer (int col, int row, Gambar img, int tileW, int tileH)
{
this.columns = col;
this.rows = baris;
this.image = img;
this.tWidth = tileW;
this.tHeight = tileH;
this.cells = new int [baris] [col];
}
public void fillCells (int col, int row, int nCol, int nRow, int tIndex)
{
tIndex -;
for (int i = 0; i <nRow; i + +)
{
for (int j = 0; j <nCol; j + +)
{
sel [baris + i] [col j] = tIndex;
}
}
}
public void setCell (int col, int baris, tIndex int)
{
tIndex -;
if (col <this.columns && baris <= this.rows)
{
sel [baris] [col] = tIndex;
}
}
public void paint (Graphics g)
{
int lx = g.getClipX ();
int ly = g.getClipY ();
int lWidth = g.getClipWidth ();
int lHeight = g.getClipHeight ();
for (int i = 0; i <this.rows; i + +)
{
for (int j = 0; j <this.columns; j + +)
{
g.setClip (j * this.tWidth, i * tHeight, tWidth, tHeight);
g.drawImage (this.image, j * this.tWidth - (sel [i] [j] * tWidth), i * tHeight, Graphics.TOP | Graphics.LEFT);
g.setClip (lx, ly, lWidth, lHeight);
}
}
}
}
Kelas TiledLayer berisi variabel-variabel berikut:
o
gambar
Ini berisi gambar latar belakang PNG dengan semua ubin latar belakang dalam file yang sama. Latar belakang diubah menjadi ubin berulang dan setiap ubin yang unik ditambahkan ke gambar. Jadi latar belakang yang kompleks dapat dikurangi dari gambar besar untuk gambar kecil.
Kendali Latar Belakang SKJ Aqua
Ubin latar belakang SKJ Aqua
Dengan
demikian banyak ruang bisa diselamatkan jika kita benar mengubah latar
belakang besar menjadi gambar keramik memiliki ubin unik
Kolom adalah variabel int berisi jumlah kolom dalam TiledLayer tersebut.
Baris adalah variabel int berisi jumlah total baris dalam TiledLayer tersebut.
Lebar masing-masing ubin individu.
Tinggi setiap ubin individu
Ini adalah array dari tipe data int. Ini adalah array dimensi dua yang berisi penempatan yang benar dari ubin yang benar dalam grid.
TiledLayer memiliki metode berikut:
o
TiledLayer (int baris, int col, Gambar img, int tileW, int tileH)
Mengatur variabel tersebut di atas kecuali sel [] [] dengan parameter ini.
o
fillCells (int baris, int col, int nCol, int nRow, int tIndex)
Memenuhi jumlah nCol kolom dan jumlah nRow baris dari baris dan col diberikan dengan tIndex ditentukan ke dalam sel [] [] array.
o
getCell (int baris, di col)
Mendapat tIndex pada suatu sel tertentu dalam sel [] [] berdasarkan parameter yang diberikan.
o
setCell (int col, int baris, tIndex int)
Mengatur tIndex pada suatu sel tertentu dalam sel [] [] berdasarkan kolom tertentu dan nomor baris.
o
cat (Graphics g)
Metode ini melakukan rendering sebenarnya dari ubin di kelas TiledLayer.
·
LayerManager
Kelas LayerManager berguna untuk mengelola sprite khususnya ketika ada sprite banyak dalam satu pertandingan. Tugas
utama dari LayerManager adalah untuk mengatur jendela tampilan yang
aktif dan kemudian memanggil method paint untuk menggambar semua sprite. Metode cat kelas ini disebut dalam metode cat dari kelas permainan utama. Metode cat LayerManager bergantian memanggil metode cat dari semua sprite ditambahkan untuk itu.
LayerManager menggunakan vektor untuk menyimpan semua lapisan ditambahkan untuk itu. Jendela
tampilan saat ini diatur dengan menggunakan metode set klip berdasarkan
x, y, lebar, tinggi variabel yang pengguna dapat diatur menggunakan
metode setter untuk ini.
Berikut ini adalah kode lengkap dari kelas LayerManager.
/ *
* LayerManager.java
*
* Dibuat pada 20 Mei, 2002 16:44
* /
mengimpor javax.microedition.lcdui *;.
mengimpor java.util.Vector:
/ **
*
* @ Author
Saurabh Jain
* @ Version 1.00
* /
masyarakat kelas LayerManager
{
/ Fungsi / Basic
swasta Vector lapisan;
private int x;
private int y;
lebar int swasta;
int tinggi swasta;
/ / Konstruktor
publik LayerManager ()
{
this.layers = new Vector ();
}
/ / Menambahkan l lapisan
public void append (Layer l)
{
this.layers.addElement (l);
}
/ / Mengatur tampilan jendela persegi panjang
public void setViewWindow (int x, int y, int width, int tinggi)
{
this.x = x;
this.y = y;
this.width = lebar;
this.height = tinggi;
}
/ / Cat metode
public void paint (Graphics g)
{
g.setClip (this.x, this.y, this.width, this.height);
for (int i = this.layers.size () - 1; i> = 0; i -)
{
((Layer) (this.layers.elementAt (i))) cat (g).;
}
}
}
Berikut ini adalah penjelasan untuk setiap variabel global kelas LayerManager kebiasaan kami:
·
lapisan
Variabel ini adalah vektor yang berisi daftar semua Layers yang LayerManager ini harus melacak.
·
x
Variabel int melacak x mulai koordinasi dari jendela melihat saat ini LayerManager tersebut.
·
y
Variabel int melacak y mulai koordinasi dari jendela melihat saat ini LayerManager tersebut.
·
lebar
Variabel int melacak lebar jendela tampilan saat ini LayerManager tersebut.
·
tinggi
Variabel int melacak ketinggian jendela tampilan saat ini LayerManager tersebut.
Kelas LayerManager berisi metode berikut:
·
publik LayerManager ()
Ini adalah konstruktor untuk kelas LayerManager.
·
public void append (Layer l)
Metode ini membantu dalam menambahkan sebuah Layer dalam LayerManager tersebut.
·
public void setViewWindow (int x, int y, int width, int tinggi)
Metode ini membantu kita mengatur jendela tampilan yang aktif untuk LayerManager tersebut. Hal ini membantu dalam kasus di mana kita ingin menampilkan semua layer di area tampilan yang tercantum pada layar.
·
public void paint (Graphics g)
Metode ini sebenarnya melukiskan lapisan atas dasar jendela tampilan yang sebenarnya.
Tidak ada komentar:
Posting Komentar