Belajar Membuat Game 2D Dengan Java dan Netbeans Bagian 5: BufferStrategy dan Menampilkan Grafik

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

Setiap kode dan penjelasannya di buat tahap demi tahap. Jadi anda tidak hanya copy paste kode kemudian di jalankan di Netbeans tanpa tahu apa maksudnya. Dan cara terbaik belajar koding sebenarnya adalah harus menulisnya sendiri, karena akan beda "feel-nya" dengan hanya langsung copy paste.

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

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

Jadi kesimpulan apa yang bisa di ambil?

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

Nah, sekarang misalnya anda ingin membuat grafik. Pasti dong ada objek yang melakukan tugas menggambar?. Ya, itu adalah objek dari class Graphics.

BufferStrategy

Apa itu buffer strategy?

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

Jadi, jika anda pernah memainkan game jadul terus melihat gambarnya kurang sempurna atau berkedip-kedip ini karena grafik langsung dirender pada layar. Bad idea!.

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

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

Buffer strategy in action

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

Jadi, pertama-tama komputer akan menggambar pada buffer yang pertama (lihat alur tanda panah). Kemudian setelah 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 aktual di mana kita bisa melihatnya.

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

Graphics

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

Saatnya Merender, back to Coding!

Merender ini bisa 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 karena anda akan menggambar pada canvas. Nah, bagaimana cara melakukannya?

Mudah saja, anda cukup menggunakan method getter. Di sini tidak akan lagi di jelaskan apa itu method getter karena sudah dibahas sebagai dasar pemrograman Java.

Ok deh sobat, berikut ini adalah kode untuk class GameDisplay, setelah 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 sempurna
        frame.setResizable(false);//Agar ukuran window tidak bisa di ubah
        frame.setLocationRelativeTo(null);//Agar window berada ditengah layar
        frame.setVisible(true);//Agar window terlihat saat 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 bisa melihat ukuran canvas secara keseluruhan
        frame.pack();
        
    }
    
    //Method getter untuk Canvas
    public Canvas getCanvas(){
        return canvas;
    }
}

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

Selanjutnya di bawah ini adalah kode untuk class game, dimana di dalam method render sudah berisi pernyataan-pernyataan untuk menggunakan buffer strategy dan juga menggambar menggunakan 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 memiliki konstruktor dengan parameter
       //judul, lebar, dan tinggi, jadi semua parameter ini harus terpenuhi
       gameDisplay = new GameDisplay(judul, lebar, tinggi);
   }
   
   //Method updateGame() akan terus melakukan update game
   private void updateGame(){
       
   }
   
   //Method render() untuk merender 
   private void render(){
       
       bufferStrategy = gameDisplay.getCanvas().getBufferStrategy();
       
       if(bufferStrategy == null){
          //Membuat buffer strategy dengan menggunakan 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() adalah 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 digunakan ketika langsung berhubungan 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 adalah class Game
        //oleh karena itu menggunakan 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 menggunakan blok try-catch
       //atau bisa juga dengan menggunakan 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 kode 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 menggunakan 3 buffer. Ini mungkin adalah jumlah maksimum buffer yang sebaiknya digunakan. Jadi lebih baik tidak lebih dari 3.

Selanjutnya untuk menggambar objek, anda menggunakan objek Graphics.

Line 54:
graphics = bufferStrategy.getDrawGraphics();

Method getDrawGraphics() dari class BufferStrategy akan membuat 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 adalah hasil ketika program di jalankan:

Hmm, jadi kode sepanjang itu hanya untuk memberikan tampilan seperti ini saja? Ya. Ini adalah 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 berbagai method yang ada pada setiap class.

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