Selasa, 12 Juni 2012


UNIT V - Bab 4 - 3D Gaming dan Multi-Player

Hari-hari ini ada buzz tentang game 3D dan multi-player. Semua operator telekomunikasi besar cukup bullish pada game 3D dan multi-player game. Mereka sedang disebut-sebut sebagai hal besar berikutnya. Sebelum pergi ke rincian teknis kita akan melihat skenario yang muncul dan kondisi pasar mengemudi game 3D dan multi-player.
Seperti banyak dari Anda mungkin tahu, operator telekomunikasi di seluruh dunia telah berinvestasi dalam jumlah besar dalam membuat jaringan 3G ada telekomunikasi siap. 3G akan merevolusi kecepatan transfer data antara ponsel. Aplikasi seperti video on demand akan dimungkinkan oleh kedatangan jaringan 3G. Game 3D dan permainan multi-player juga akan menjadi kenyataan dengan munculnya 3G. Sudah di negara-negara dimana 3G telah diluncurkan, game 3D dan multi-player game telah menjadi kenyataan.
Game 3D yang berat dan permintaan transfer data berkecepatan tinggi untuk aplikasi untuk di-download. Ini sedang dimungkinkan oleh peluncuran layanan 3G. Juga sebagai kecepatan transfer data tumbuh masalah latency yang telah menjadi hambatan besar dalam pengenalan multi-player game akan dihapus. Untuk besar multi-player game menjadi populer jaringan bandwidth tinggi diperlukan yang akan diperkenalkan sebagai bagian dari peluncuran 3G di seluruh dunia.
3D Gaming
Kita hidup di dunia 3 dimensi. Dengan demikian otak kita telah diprogram untuk dunia 3D. Jadi adalah wajar bagi kita untuk menuntut lingkungan 3D dalam game yang kita mainkan. Sebagai programmer pekerjaan Anda adalah untuk menyenangkan konsumen dengan memberikan mereka game 3D yang sangat baik. Diharapkan game 3D akan memungkinkan developer game untuk mengisi sampai $ 10 per game. Ada pembicaraan biaya bahkan $ 25 untuk game 3D high end. Jadi bahkan dari sudut keuangan beralih pandangan untuk game 3D masuk akal bagi pengembang game. Sebelum melanjutkan ke game 3D menggunakan J2ME kita harus melihat ekosistem yang diperlukan untuk game 3D.
3D Gaming Ekosistem
·          Handphone 3D Graphics API (JSR 184) handset mobile diaktifkan
·          Sedang untuk jaringan bandwidth tinggi untuk pengiriman konten
·          Operator telekomunikasi tertarik dalam memasarkan konten 3D
·          3D modeling tool grafis untuk pengembangan game cepat
Seperti kita bahas sebelumnya secara rinci Handphone 3D Graphics API (JSR 184) telah diperkenalkan untuk memungkinkan pengembang untuk mengembangkan J2ME game 3D. Semua produsen ponsel besar adalah bullish pada memperkenalkan JSR 184 handset yang kompatibel. Dalam daftar ponsel yang diberikan dalam buku ini Anda bisa melihat daftar handset yang mendukung JSR 184. Dengan demikian elemen yang paling penting dari ekosistem 3D yang mulai berbenah.
Dengan diperkenalkannya jaringan 3G kecepatan transfer data akan mengambil melompat ke depan. Pengguna akan dapat men-download game 3D dengan ukuran file yang besar. Operator Telecom juga sangat bullish pada game 3D. Mereka ingin pasar mereka sebagai game 3D membawa lebih banyak pendapatan dan penggunaan jaringan yang lebih. Situasi menang-menang bagi operator jaringan.
JSR 184 enabled alat pemodelan 3D juga tiba di pasar. Perusahaan ingin Discreet dan meliuk mengembangkan alat pemodelan 3D yang JSR 184 kompatibel. 3ds Max 7 oleh Discreet adalah 3D akhir alat pemodelan grafis yang sangat tinggi yang sedang digunakan oleh rumah game besar dan studio film untuk membuat konten 3D. Alat ini juga memiliki dukungan untuk mengembangkan konten untuk JSR 184. Dengan demikian Anda sebagai pengembang game 3D bisa menggunakan 3ds Max 7 untuk pengembangan obyek 3 dimensi yang dapat digunakan dalam permainan Anda.
Dengan demikian kita menemukan bahwa ekosistem game 3D lengkap adalah mengambil bentuk. Satu-satunya kata dari hati-hati ketika mengembangkan sebuah game 3D adalah bahwa game 3D yang lebih kompleks. Mereka bersaing dengan kepala di game konsol dan sangat mahal untuk dikembangkan.
Technicals dari 3D Gaming
Bila Anda telah membaca tentang Handphone 3D Graphics API (JSR 184) Anda pasti berpikir bagaimana di dunia akan saya memprogram objek 3D menggunakan API ini? Sebenarnya faktanya adalah bahwa kita tidak perlu model semua objek dalam API ini sebagai seorang programmer. Kita dapat menggunakan 3ds Max 7 dan ekspor objek untuk file M3G. File M3G untuk objek 3D dan lingkungan akan berisi semua informasi yang dibutuhkan untuk menciptakan informasi tersebut.
JSR 184 memungkinkan kita untuk membuat dan menghidupkan objek 3D dalam dua mode:
·                      Segera Modus
·                      Saldo Modus
Dalam 'modus langsung', 3D konten dapat dihasilkan secara langsung melalui pemrograman. Tidak ada alat authoring 3D diperlukan. Satu-satunya masalah dengan pendekatan ini adalah bahwa Anda tidak akan bisa mengembangkan grafis kompleks menggunakan modus langsung. Alasan untuk tidak bisa membuat grafis kompleks adalah bahwa karakter kompleks, visualisasi dan animasi sangat sulit untuk model langsung melalui pemrograman. Jadi mode ini begitu relevan dengan sendirinya. Untuk menciptakan permainan yang kompleks kita harus menggunakan mode dipertahankan.
Modus Saldo memungkinkan kita untuk menggunakan grafis yang telah dimodelkan melalui perangkat lunak pemodelan 3D. Sebagaimana dibahas sebelumnya pengguna dapat membuat beberapa tubuh bekerja dalam software 3D modeling dan kemudian mengekspornya ke file M3G. Dari sana Anda dapat memuat grafis dalam aplikasi Anda dan menggunakan konten 3D.
3D Gaming Praktik Terbaik
Cobalah untuk melakukan pekerjaan sebanyak mungkin dalam alat pemodelan 3D. Sangat sulit untuk mengedit karya seni 3D melalui pemrograman langsung. Lakukan hanya yang bekerja melalui kode yang tidak mungkin untuk dicapai dalam alat pemodelan 3D.
Ketika bekerja pada aplikasi 3D ingat bahwa file konten 3D yang sangat besar. Bahkan file kecil dengan 2 objek sederhana dapat mengambil 20 kb, cukup besar ketika Anda membandingkan dengan ukuran aplikasi total dalam hari-hari awal pemrograman J2ME mobile. Oleh karena itu hati-hati merencanakan penggunaan kembali objek dalam permainan 3D Anda. Juga membatasi interaksi antara berbagai elemen. Sebuah teknik yang disebut 'pelingkupan' dapat digunakan. Dalam pelingkupan Anda dapat memberitahu pelaksanaan grafis 3D saat objek tidak akan berinteraksi satu sama lain. Ini akan menghemat memori.
Sekarang kita akan melihat contoh kode memuat konten dari file M3G dan menggunakannya dari dalam aplikasi. Ini adalah aplikasi yang sangat sederhana. Cocok penjelasan sedapat mungkin telah diberikan di dalam aplikasi tersebut.
Kode Contoh
/ ************************************************* ***************************** /
/ **
  *           Penulis   :            Saurabh Jain
  *           Versi :            1.0.0
  *
  *           Hak Cipta (C) 2004 Superscape plc
  *           File ini dimaksudkan untuk digunakan sebagai contoh kode, dan
  *           dapat digunakan, dimodifikasi, atau didistribusikan dengan sumber atau
  *           kode objek bentuk, tanpa batasan, selama
  *           informasi hak cipta ini dipertahankan.
  *           Kode dan informasi disediakan "apa adanya" tanpa
  *           jaminan apapun, baik tersurat maupun tersirat.
  * /
/ ************************************************* ***************************** /
javax.microedition.midlet.MIDlet impor;
impor javax.microedition.midlet.MIDletStateChangeException;
mengimpor javax.microedition.lcdui *;.
mengimpor javax.microedition.m3g *;.
public class MIDlet My3DWorld meluas mengimplementasikan CommandListener
{
            / / Variabel.
            / / Referensi layar MIDlet
    myDisplay pribadi Tampilan = nol;
    / / Referensi ke kanvas saat ini.
    swasta CallbackCanvas myCanvas = null;
            / / Perintah yang digunakan untuk keluar dari MIDlet.
    Command pribadi exitCommand = new Command ("Keluar", Command.ITEM, 1);
            / / Referensi ke dunia yang berisi sel My3D.
    Dunia swasta MyWorld = null;
            / / Kelompok root, yang inilah yang kita memutar perlahan.
    swasta Kelompok rootGroup = null;
            Grup pribadi rootGroup2 = null;
            myCamera Kamera swasta = nol;
            swasta mengambang angleX;
            swasta mengambang angleY;
            waktu int swasta;
            Graphics3D myGraphics3D = Graphics3D.getInstance ();
            int viewport_x;
            int viewport_y;
            int viewport_width;
            int viewport_height;
    publik My3DWorld ()
    {
          / / Mengatur user interface.
        myDisplay = Display.getDisplay (ini);
        myCanvas = new CallbackCanvas (ini);
        myCanvas.setCommandListener (ini);
        myCanvas.addCommand (exitCommand);
    }
    / **
     *       Ini menginisialisasi keadaan permainan, dan menghasilkan sebuah dunia M3G pemrograman.
     * /
    kekosongan startApp publik () throws MIDletStateChangeException
    {
            / / Menangkap excpetions sini sebelum mereka pergi terlalu jauh.
        mencoba
         {
            / / Buat dunia M3G baru dengan memuat dari file M3G
                                    MyWorld = (Dunia) Loader.load ("/ swerve.m3g") [0];
                                    setupAspectRatio ();
                                    / / Lampirkan untuk menampilkan
                 myDisplay.setCurrent (myCanvas);
                                    / / Angkatan repaint sehingga kita mendapatkan loop pembaruan dimulai.
            myCanvas.repaint ();
        }
        catch (Exception e)
        {
            e.printStackTrace ();
        }
    }
    / **
     * Pada jeda, cukup menutup semuanya.
     * /
    public void pauseApp ()
    {
                        / / Rilis sumber daya.
                        MyWorld = null;
    }
    / **
     * Pada keluar, cukup menutup segala sesuatu ke bawah
     * /
    public void destroyApp (boolean unconditional) throws MIDletStateChangeException
    {
           / / Rilis sumber daya.
   MyWorld = null;
           myCanvas = null;
     }
    / **
     *       MIDlet metode cat.
     *      Ini disebut kembali dari kelas Canvas batin. Hal itu membuat kondisi saat ini dari
     *       sel, kemudian update mereka dan jadwal pembaruan lain.
     * /
    public void paint (Graphics g)
    {
                        if (myCanvas == null | | myGraphics3D == null | | MyWorld == null)
                         kembali;
                        if (g.getClipWidth () = viewport_width |! |
                           g.getClipHeight () = viewport_height |! |
                           g.getClipX () = viewport_x! | |
                           g.getClipY () = viewport_y)!
                        {
                                    g.setColor (0x00);
                                    g.fillRect (0, 0, myCanvas.getWidth (), myCanvas.getHeight ());
                        }
                        / / Render dunia ke Grafis kami (layar) menggunakan kelas M3G Graphics3D
        / / Membuat adegan 3d
                        myGraphics3D.bindTarget (g);
                        myGraphics3D.setViewport (viewport_x, viewport_y, viewport_width, viewport_height);
                        myGraphics3D.render (MyWorld);
                        myGraphics3D.releaseTarget ();
    }
            / **
              * Pastikan bahwa konten yang diberikan dengan rasio aspek yang benar.
              * /
            private void setupAspectRatio ()
            {
                        viewport_x = 0;
                        viewport_y = 0;
                        viewport_width = myCanvas.getWidth ();
                        viewport_height = myCanvas.getHeight ();
                        / / Dapatkan kamera aktif untuk dunia
                        Kamera cam = myWorld.getActiveCamera ();
                        float [] params = mengapung baru [4];
                        tipe int = cam.getProjection (params);
                        if (type = Camera.GENERIC!)
                        {
                                    / / Menghitung rasio aspek jendela
                                    mengapung waspect = viewport_width / viewport_height;
                                    if (waspect <params [1])
                                    {
                                                melayang tinggi = viewport_width / params [1];
                                                viewport_height = (int) tinggi;
                                                viewport_y = (myCanvas.getHeight ()-viewport_height) / 2;
                                    }
                                    lain
                                    {
                                                mengapung width = viewport_height * params [1];
                                                viewport_width = (int) lebar;
                                                viewport_x = (myCanvas.getWidth ()-viewport_width) / 2;
                                    }
                        }
            }
    / **
     *       Menangani perintah.
     *       Saat ini, satu-satunya perintah diaktifkan adalah "Keluar" - ini hanya
     *       menghancurkan MIDlet segera.
     * /
    public void commandAction (Command cmd, disp dapat ditampilkan)
    {
        if (cmd == exitCommand)
        {
            mencoba
            {
                destroyApp (false);
                 notifyDestroyed ();
            }
            catch (Exception e)
            {
                e.printStackTrace ();
            }
        }
    }
    / **
     *       Menangani penekanan tombol.
     *      Ini disebut kembali dari kelas Canvas batin, dan mengimplementasikan
     *       perilaku dari berbagai kunci yang diuraikan dalam ringkasan kelas.
     * /
    public void keyPressed (int keyCode)
            {
                        / / Incrementing waktu dan menjiwai dunia berdasarkan waktu bertambah
                        waktu + = 50;
                        myWorld.animate (waktu);
                        myCanvas.repaint ();
            }
    / **
     * Batin kanvas yang diturunkan dari kelas untuk menangani event kanvas.
     * /
    CallbackCanvas kelas privat memperluas kanvas
    {
        My3DWorld mymidlet;
        / **
         * Buatlah sebuah kanvas baru
         * /
        CallbackCanvas (My3DWorld MIDlet) {mymidlet = MIDlet;}
        / **
         * Inisialisasi diri.
         * /
        init void () {}
        / **
         * Pembersihan dan menghancurkan.
         * /
        membatalkan menghancurkan () {}
        / **
         * Tanyakan mymidlet melukis itu sendiri
         * /
        void dilindungi cat (Graphics g) {mymidlet.paint (g);}

        protected void keyPressed (int keyCode) {mymidlet.keyPressed (keyCode);}
                        void dilindungi keyRepeated (int keyCode) {mymidlet.keyPressed (keyCode);}
    }
}
Jadi kita melihat bahwa meskipun menggunakan API 3D adalah sedikit sulit tetapi penggunaan alat-alat pemodelan 3D dan file M3G membuat tugas kita lebih mudah.
Multiplayer Gaming
Multiplayer game semakin sangat populer hari ini. Sebuah permainan Multiplayer dapat didefinisikan sebagai setiap permainan yang dapat dimainkan secara bersamaan oleh lebih dari satu pemain dan tindakan semua pemain mempengaruhi dunia game yang sama. Dalam ambit dari definisi ini berbagai jenis multiplayer game bisa ada, yaitu:
  • Besar Multiplayer Games
  • Bluetooth Enabled Multiplayer Games
  • SMS / MMS Enabled Multiplayer Games
Multiplayer besar adalah multiplayer yang mana sejumlah besar pemain bermain secara bersamaan. + 10000 pemain bermain game adalah hal yang normal untuk game tersebut. Permainan tersebut perlu server besar untuk sinkronisasi gerakan dari pemain yang berbeda. Permainan tersebut bisa memiliki PC, PDA dan ponsel sebagai mesin klien. Permainan ini memerlukan pengetahuan khusus dan upaya besar untuk membangun. Kita akan melihat beberapa faktor yang harus diingat saat mengembangkan permainan seperti:
  • Low Latency
  • Skalabilitas Tinggi
  • Toleransi kesalahan
  • Komputasi Efisiensi
  • Pemain otentikasi
  • Pemain kontrol akses
  • Berlangganan manajemen
  • Keamanan
  • Permainan administrasi dan pengelolaan masyarakat
  • Sisi client update
Latency adalah faktor paling penting yang dapat membuat atau merusak permainan. Untuk permainan untuk menjadi sukses latency harus dalam urutan beberapa milidetik. Persyaratan 3G dan broadband diperlukan karena masalah latency.
Skalabilitas diperlukan untuk game-game seperti ketika permainan menjadi sukses jumlah pelanggan meningkat sangat cepat. Oleh karena itu aplikasi harus terukur untuk mendukung sejumlah besar pelanggan serta sejumlah kecil pada awalnya.
Multiplayer besar melibatkan kedua sisi client dan pemrograman sisi server dan karena itu jenis yang sangat khusus aplikasi. Oleh karena itu kita akan membatasi pembahasan kita pada mereka di sini. Jika Anda ingin tahu lebih banyak tentang mereka yang mengunjungi website dari Sun Microsystems.
Multiplayer game juga dapat menjadi jenis lain. Mereka dapat memungkinkan peer to peer jaringan melalui bluetooth. Bahkan beberapa game seperti telah tiba. Permainan ini memungkinkan pemain untuk bermain game dalam mode multiplayer dalam grup tertentu. Kelompok ini harus dalam kedekatan fisik sebagai bluetooth memungkinkan jaringan hanya jarak pendek. Permainan ini meningkatkan elemen menyenangkan dalam permainan sebagai orang umumnya ingin menikmati dalam kelompok.
Bluetooth multiplayer memiliki beberapa masalah dari sana sendiri. Kami akan membahas beberapa isu-isu sekarang. Isu utama adalah bagaimana pemain akan mengaktifkan mode multiplayer. Kami dapat menyediakan pemain dengan pilihan menu untuk mengundang pemain lain untuk modus multiplayer. Hal ini dapat diaktifkan dengan memberinya fasilitas untuk mencari perangkat bluetooth di dekat telepon. Anda dapat menggunakan kelas DiscoveryAgent untuk tujuan ini.
Kemudian Anda dapat menggunakan API untuk membuat koneksi L2CAP antara perangkat. Untuk permainan multiplayer kami akan harus membuat dua arah koneksi. Perangkat pemain yang telah mengundang orang lain dapat menjadi server untuk tujuan komunikasi dalam permainan multiplayer kami.
Berikut ini adalah pseudo kode untuk membuka server dan koneksi klien masing-masing melalui penggunaan protokol L2CAP:
mencoba
{
     L2CAPConnectionNotifier myServer = (L2CAPConnectionNotifier)
     Connector.open ("btl2cap :/ / localhost: 3B9FA89520078C301355AAA694238F06;
     nama = L2CAPskj ");
     L2CAPConnection myCon = (L2CAPConnection) myServer.acceptAndOpen ();
}
mencoba
{
     L2CAPConnection myClient = (L2CAPConnection)
     Connector.open ("btl2cap :/ / 0050CD00122B: 1001; ReceiveMTU = 512;
     TransmitMTU = 512 ");
}
Setelah membuka koneksi kita harus mulai kanvas game untuk semua pemain.
Untuk permainan multiplayer untuk sinkronisasi dari setiap penggunaan variabel pertandingan penting harus dilakukan. Hal ini dapat dimungkinkan oleh sinkronisasi setelah interval yang telah ditentukan. Kami harus membuat ketentuan untuk kedua menerima dan mengirim data. Latency untuk koneksi bluetooth cukup rendah namun tetap kita harus faktor skenario yang mungkin timbul jika terjadi data tidak disinkronkan tepat waktu. Oleh karena itu aksi permainan harus dikembangkan dengan pikiran seperti masalah yang mungkin timbul.
Hal penting lain dalam sinkronisasi akan gerakan layar. Bagaimana gerakan layar akan berlabuh? Apakah akan didasarkan pada pemain, setiap pemain satu atau variabel netral? Dampak dari perubahan siklus hidup permainan satu pemain pada pemain lain juga harus diingat. Sebagai contoh di dua pemain permainan pemain satu dapat kehilangan kesempatan sementara pemain lain masih hidup. Dalam situasi seperti itu kita harus memastikan bahwa permainan tidak berhenti untuk pemain lain.
Bahkan Anda bisa melihat game konsol untuk beberapa petunjuk. Umumnya konsol mendukung 2 game player. Mereka bisa membantu sambil berpikir tentang multiplayer bluetooth diaktifkan.
Terakhir kita akan berbicara tentang game multiplayer pesan diaktifkan. Permainan tersebut sangat sedikit dan belum menjadi populer karena biaya yang terlibat untuk pengguna setiap kali pesan dikirim. Masih kita segera akan membahas topik ini.
Sejak pesan meluangkan waktu untuk melakukan perjalanan melalui jaringan kita tidak bisa memiliki multiplayer cepat melalui mereka. Permainan tersebut harus terbatas pada orang-orang seperti sebuah permainan catur atau TicTacToe. Hal yang baik adalah bahwa SMS dan tarif MMS yang jatuh. Juga game jenis ini dapat dimainkan dalam rekan rekan modus jarak jauh. Beberapa masalah yang akan Anda hadapi selama pengembangan ini jenis permainan yang mirip dengan game multiplayer bluetooth diaktifkan. Beberapa perbedaan lain yang berkaitan dengan sinkronisasi. Masalah pertama adalah bahwa Anda akan menghadapi latency dalam orde menit. Jadi hanya permainan pikiran yang tersisa dalam domain dari jenis permainan. Masalah lain adalah bahwa kita harus menggunakan salah satu JSR 120 untuk SMS sinkronisasi atau JSR 205 untuk sinkronisasi MMS. Dalam kedua kasus itu akan baik untuk memperingatkan para pemain dari biaya yang terlibat dalam mengirimkan pesan. Satu skenario yang baik di mana pesan dapat dimasukkan adalah menantang pengguna telepon mobile lainnya untuk mengalahkan skor tinggi dari pemain ini. Ketika orang-orang yang telah ditantang mampu terjadilah bahwa skor tinggi SMS atau MMS dikembalikan kembali ke penantang dengan tantangan baru untuk pemain asli. Cara ini bahkan game action dapat dibuat lebih menghibur dengan menggunakan teknologi messaging.

Tidak ada komentar:

Posting Komentar