Belajar Menciptakan Game 2D Dengan Java Dan Netbeans Bab 5: Bufferstrategy Dan Menampilkan Grafik

Halo sobat, kali ini admin mau melanjutkan tutorial menciptakan game 2D dengan Java dan IDE Netbeans. Oh, iya tutorial ini berseri ya, jadi teman lebih baik mengikutinya dari awal, sebab jikalau tidak demikian maka beresiko "tersesat". Ya, nggaklah cuma bercanda saja.

Setiap aba-aba dan penjelasannya di buat tahap demi tahap. Makara anda tidak hanya copy paste aba-aba kemudian di jalankan di Netbeans tanpa tahu apa maksudnya. Dan cara terbaik mencar ilmu koding bergotong-royong ialah harus menulisnya sendiri, sebab akan beda "feel-nya" dengan hanya pribadi copy paste.

Ok, kali ini kita akan masuk ke tahap BufferStrategy dan juga menampilkan grafik.

Menariknya ialah dari awal dibicarakan mengenai beberapa objek, contohnya objek Canvas sebagai kawasan grafik, terus objek JFrame sebagi penampung atau container, kemudian juga ada objek Game yang menjalankan thread, dan lainnya.

Makara kesimpulan apa yang sanggup di ambil?

Kesimpulannya ialah jadwal itu hanyalah komunikasi antar objek yang dibentuk dari class untuk mencapai suatu tujuan, di mana masing -masing objek mempunyai method dan properti untuk melaksanakan tugasnya. Apa kesimpulan ini terasa sedikit menggelitik pemahaman anda mengenai Java sebagai pemrograman berorientasi objek?.

Nah, kini contohnya anda ingin menciptakan grafik. Pasti dong ada objek yang melaksanakan kiprah menggambar?. Ya, itu ialah objek dari class Graphics.

BufferStrategy

Apa itu buffer strategy?

Buffer strategy ialah suatu cara atau teknik untuk merender gambar pada layar memakai gambar buffer untuk menghindari tampilan gambar game yang berkedip (flickering).

Jadi, jikalau anda pernah memainkan game jadul terus melihat gambarnya kurang tepat atau berkedip-kedip ini sebab grafik pribadi dirender pada layar. Bad idea!.

Sedangkan yang dimaksud dengan buffer itu sendiri di sini ialah layar komputer yang tersembunyi di dalam komputer.

Mungkin pengertian mengenai buffer ini menciptakan anda bingung. Biar lebih jelas, buffer strategy ini bekerja mirip pada gambar berikut:

Buffer strategy in action

Jangan anggap buffer itu ialah layar komputer yang nyata, gambar di atas ialah bentuk representasi dari memori komputer. Yang benar-benar layar komputer ialah layar aktual.

Jadi, pertama-tama komputer akan menggambar pada buffer yang pertama (lihat alur tanda panah). Kemudian sehabis proses menggambar di buffer pertama selesai, buffer tersebut akan pindah ke buffer berikutnya, dan di sini kita masih belum melihat apa-apa. Selanjutnya buffer itu akan pindah lagi ke layar positif di mana kita sanggup melihatnya.

Teknik buffer strategy ini di perlukan untuk mencegah grafik berkedip (flickering) yang sanggup saja terjadi jikalau proses render pribadi di lakukan pada layar aktual. Dengan demikian grafik yang terlihat akan terlihat mulus. Mantap ya!.

Graphics

Objek Graphics bertugas untuk mengambar grafik. Objek ini sanggup diibaratkan kuas serba bisa, atau apalah itu, yang terperinci ia sanggup menggambar grafik secara penuh, sanggup menggambar kotak, persegi, garis, dengan komposisi warna bervariasi.

Saatnya Merender, back to Coding!

Merender ini sanggup diartikan dengan menggambar segala sesuatunya pada layar. Kali ini perhatian anda akan sangat terfokus pada method render di yang berada class Game, dimana method ini akan terus dipanggil untuk merender ketika game berjalan.

Tapi, untuk merender anda perlu untuk mengakses objek Canvas yang yang berada di class GameDisplay. Kenapa demikian? Ini sebab anda akan menggambar pada canvas. Nah, bagaimana cara melakukannya?

Praktis saja, anda cukup memakai method getter. Di sini tidak akan lagi di jelaskan apa itu method getter sebab sudah dibahas sebagai dasar pemrograman Java.

Ok deh sobat, berikut ini ialah aba-aba untuk class GameDisplay, sehabis di tambahkan method getter untuk Canvas.

package com.bahasajava.gamejava.gamedisplay;  import java.awt.Canvas; import java.awt.Dimension; import javax.swing.JFrame;  public class GameDisplay {          private JFrame frame;//sebagai container komponen lainnya          private int lebar, tinggi;//dalam ukuran piksel     private String judul;          private Canvas canvas;//Untuk meletakkan gambar atau grafik          //Constructor     public GameDisplay(String judul, int lebar, int tinggi){         this.judul = judul;         this.lebar = lebar;         this.tinggi = tinggi;                  buatGameDisplay();//Memanggil method buatGameDisplay();     }          private void buatGameDisplay(){         frame = new JFrame(judul);//Mengatur judul         frame.setSize(lebar, tinggi);//Mengatur ukuran lebar dan tinggi window         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//Agar window di close tepat         frame.setResizable(false);//Agar ukuran window tidak sanggup di ubah         frame.setLocationRelativeTo(null);//Agar window berada ditengah layar         frame.setVisible(true);//Agar window terlihat ketika ditampilkan                  canvas = new Canvas();//Membuat objek canvas                  //Memilih ukuran canvas yang sesuai dengan ukuran lebar dan tinggi frame         canvas.setPreferredSize(new Dimension(lebar, tinggi));                  //Untuk selalu menjamin ukuran kanvas sesuai yang diinginkan         canvas.setMaximumSize(new Dimension(lebar, tinggi));         canvas.setMinimumSize(new Dimension(lebar, tinggi));                  frame.add(canvas);//Menambahkan canvas ke dalam frame                  //Agar window pas sesuai dengan ukuran yang diinginkan atau dipilih         //sehingga sanggup melihat ukuran canvas secara keseluruhan         frame.pack();              }          //Method getter untuk Canvas     public Canvas getCanvas(){         return canvas;     } } 

Perhatikan pada line 51 - 52. Pada baris aba-aba di atas di buat method getter untuk canvas.

Selanjutnya di bawah ini ialah aba-aba untuk class game, dimana di dalam method render sudah berisi pernyataan-pernyataan untuk memakai buffer strategy dan juga menggambar memakai objek Graphics.

 package com.bahasajava.gamejava;  import com.bahasajava.gamejava.gamedisplay.GameDisplay; import java.awt.Color; import java.awt.Graphics; import java.awt.image.BufferStrategy; import java.util.logging.Level; import java.util.logging.Logger;  //Mnegimplementasikan interface Runnable untuk thread public class Game implements Runnable {    private GameDisplay gameDisplay;        public int lebar, tinggi;    public String judul;        private Thread thread;//thread yang dijalankan        private boolean gameRunning = false;//Untuk mengontrol while loop        private BufferStrategy bufferStrategy;    private Graphics graphics;        public Game(String judul, int lebar, int tinggi){        this.lebar = lebar;        this.tinggi = tinggi;        this.judul= judul;            }        //Method inisialisasi() akan menginisialisasi semua graphic    //dan akan memastikan semuanya siap sebelum game dijalankan    private void inisialisasi(){        //objek gameDisplay mempunyai konstruktor dengan parameter        //judul, lebar, dan tinggi, jadi semua parameter ini harus terpenuhi        gameDisplay = new GameDisplay(judul, lebar, tinggi);    }        //Method updateGame() akan terus melaksanakan update game    private void updateGame(){            }        //Method render() untuk merender     private void render(){                bufferStrategy = gameDisplay.getCanvas().getBufferStrategy();                if(bufferStrategy == null){           //Membuat buffer strategy dengan memakai 3 buffer           gameDisplay.getCanvas().createBufferStrategy(3);           return;        }                graphics = bufferStrategy.getDrawGraphics();                graphics.setColor(Color.GREEN);        graphics.fillRect(0, 0, lebar, tinggi);               bufferStrategy.show();//Menampilkan grafik                graphics.dispose();    }      //run() ialah method abstract yang harus diimplentasikan     //ketika class mengimplementasikan Runnable     @Override     public void run() {         inisialisasi();                  //Di sini kita akan menjalankan loop game         while(gameRunning){             updateGame();             render();         }         stopThread();     }          //synchronized dipakai ketika pribadi berafiliasi dengan thread     //startThread() akan menjalankan thread     public synchronized void startThread(){                  if(gameRunning)             return;                  gameRunning = true;                  //Konstruktor Thread mengambil parameter class mana yang          //akan di jalankan, dalam hal ini ialah class Game         //oleh sebab itu memakai keyword this         thread = new Thread(this);         thread.start();//Method start() ini akan menjalankan method run()     }          //stopThread akan menghentikan thread     public synchronized void stopThread(){        if(!gameRunning)            return;                gameRunning = false;                 //Method join() melemparkan checked exception sehingga        //akan memaksa anda untuk memakai blok try-catch        //atau sanggup juga dengan memakai clausa Throws        try {            thread.join();//Method join() akan menunggu thread untuk "mati"        } catch (InterruptedException ex) {            Logger.getLogger(Game.class.getName()).log(Level.SEVERE, null, ex);        }     }        } 

Ok, sebelum masuk ke method render() di line 44, perhatikan bahwa variable objek telah di buat untuk class BufferStrategy dan juga Graphics di line 20 -21.

Sekarang lihat pada body pada method render(), line 46:
bufferStrategy = gameDisplay.getCanvas().getBufferStrategy();

Baris aba-aba di atas akan menetapkan bufferStrategy equal dengan buffer strategy apapun yang terdapat pada canvas.

Line 50:
gameDisplay.getCanvas().createBufferStrategy(3);

Kode tersebut menyatakan bahwa buffer strategy akan memakai 3 buffer. Ini mungkin ialah jumlah maksimum buffer yang sebaiknya digunakan. Makara lebih baik tidak lebih dari 3.

Selanjutnya untuk menggambar objek, anda memakai objek Graphics.

Line 54:
graphics = bufferStrategy.getDrawGraphics();

Method getDrawGraphics() dari class BufferStrategy akan menciptakan sebuah konteks graphics untuk buffer gambar.

Line 57-58:
graphics.setColor(Color.GREEN);
graphics.fillRect(0, 0, lebar, tinggi);

Mengatur konteks warna graphics menjadi warna spesifik yaitu hijau. Kemudian mengisi warna tersebut pada persegi di koordinat x = 0 dan y = 0, dan kemudian ukuran lebar dan panjang area persegi tersebut ditentukan sama dengan ukuran panjang dan lebar layar game.

Berikut ini ialah hasil ketika jadwal di jalankan:

Hmm, jadi aba-aba sepanjang itu hanya untuk menunjukkan tampilan mirip ini saja? Ya. Ini ialah basic di mana game akan di jalankan dan di tampilkan nantinya. Tapi,sebenarnya banyak yang sudah anda pelajari. Dari mulai frame, canvas, thread, buffer strategy, warna, dan grafik dengan banyak sekali method yang ada pada setiap class.

Jadi, hingga di sini dulu ya. Selanjutnya nanti kita akan membahas mengenai sistem koordinat dan grafik lebih dalam lagi.

Bagikan Artikel ini