1. Deskripsi Persyaratan
1. Persyaratan fungsional
Pada tahap analisis persyaratan fungsional, tugas utama kami adalah menentukan layanan mana yang harus disediakan sistem, menentukan fungsi mana yang diselesaikan perangkat lunak, dan memberikannya kepada orang -orang tersebut. Persyaratan fungsional adalah persyaratan dasar pengembangan perangkat lunak dan bagian yang sangat diperlukan dari analisis permintaan. Tank War adalah permainan klasik. Game ini telah mempelajari beberapa pengalaman pendahulunya. Secara keseluruhan, permainan dibagi menjadi kedua sisi musuh dan kita. Tank -tank yang terutama berpartisipasi dalam pertempuran dikendalikan oleh pemain. Tank musuh dapat muncul dengan cerdas dan acak di layar dan bergerak, meluncurkan sejumlah peluru; Pemain dapat memindahkan tank sesuka hati di area yang ditentukan. Ketika peluru mengenai pemain, pemain mati dan permainan berakhir; Tank musuh berlari dengan cerdas. Karena mereka perlu memiliki tingkat kecerdasan tertentu, mereka muncul secara acak di layar, dan berputar dengan bebas, seperti: mengetahui kemudi ketika mereka menghadapi batas; Bullets Run: Tank dikendalikan oleh pemain dan peluru api sesuai dengan posisi tangki yang berbeda. Jika mereka mencapai target, efek ledakan akan diproduksi; Ini juga akan menghilang di layar.
2. Persyaratan Kinerja Sistem
Persyaratan konfigurasi kinerja game berdasarkan sistem komputer adalah untuk memastikan bahwa program dapat berjalan dengan cepat dan stabil dan dapat merespons tepat waktu saat berjalan. Ketika tangki pemain dihancurkan dalam permainan, segera meminta informasi tentang kegagalan permainan dan merespons tepat waktu untuk memenuhi persyaratan aturan permainan. Selain itu, juga perlu untuk memastikan bahwa ukuran jendela utama tidak dapat diubah sesuka hati saat bermain game, memastikan pemutaran.
3. Solusi Fungsional
Tingkat pemanfaatan kode sangat bagus dalam permainan. Lagi pula, ini adalah pekerjaan real-time. Setiap milidetik, akan ada banyak peluru yang ditembakkan, dan pergerakan koordinat banyak tank. Saya membandingkan jumlah peluru yang mengenai tangki berkali -kali, dan peristiwa pemantauan keyboard, menerapkan antarmuka utas, dan menggambar ulang dan menyegarkan; Rasa logika harus kuat, dan tampilan yang berorientasi objek ditampilkan sepenuhnya; Bahkan hubungan di antara mereka tidak jelas, dan mudah untuk memiliki situasi yang tidak terduga; Untuk membuat penambahan kecantikan dan menambahkan ledakan dalam permainan, itu mensyaratkan bahwa ketika tank musuh mati, korsel pendek dan cepat dari gambar -gambar tempat tetap di panel luar untuk mencapai efek ledakan;
Secara umum, fungsi dasar yang harus diselesaikan dalam pertempuran tank meliputi: antarmuka grafis, perbedaan gaya tangki musuh-ke-saya, tank dapat menembakkan peluru untuk menyerang lawan, tetapi tidak dapat menyerang rekan satu tim, dan tank menetapkan titik kesehatan tertentu;
2. Analisis Fungsi Utama
Dalam proses pengembangan game Tank War, fungsi utama disediakan untuk pengguna untuk digunakan, jadi pertama -tama Anda harus menggambar tangki.
1. Gambarlah tangki pemain: Anda perlu mengatur cat () pada panel jpanel dan menggambar perkiraan bentuk tangki dengan sikat;
2. Tank pemain dapat bergerak: jika tank bergerak, mereka perlu mengubah koordinat tangki dan terus -menerus mengecat ulang panel. Namun, ketika tank bergerak, antarmuka mekanisme pemantauan peristiwa (pemantauan keyboard) dapat diimplementasikan di kelas panel. Ketika pemain menekan tombol W/D/S/A, itu dapat bergerak ke atas, ke bawah, kiri dan kanan;
3. dan menggambar tank musuh di cat kertas gambar saya (); Karena tank musuh dan tank pemain berada di antarmuka yang sama, mereka perlu ditarik di papan gambar yang sama;
4. Tank pemain dapat menembakkan peluru: Jika seorang pemain ingin menembakkan peluru, mereka perlu memiliki sumber acara. Ketika pengguna menekan tombol J, pemantauan acara akan segera menembakkan peluru, tetapi perlu ditampilkan di depan mata pengguna untuk melihat efeknya, jadi cat () menggambar peluru pada panel; Karena peluru diluncurkan dan bergerak terus -menerus menuju peluncuran, koordinat peluru harus diubah terus -menerus, dan kecepatan peluru harus sesuai, sehingga perlu diimplementasikan dengan benang dan panel terus digambar ulang untuk melihat efeknya;
5. Pemain dapat menembakkan peluru berturut -turut dan menembak hingga lima: jika pemain ingin mengontrol jumlah peluru, ia perlu mengetahui apakah jumlah peluru yang saat ini bertahan kurang dari 5 ketika pemain menekan tombol J. Ketika kondisinya terpenuhi, satu peluru akan dibuat. Ketika pemain menembakkan lebih dari lima peluru, fungsi api sistem tidak akan lagi dipanggil; Karena meluncurkan peluru tidak hanya menembakkan satu peluru, mengatur satu set peluru untuk menghasilkan satu peluru pada satu waktu untuk mengetahui bahwa peluru mati ketika mereka mengenai batas dan mati;
6. Ketika tank pemain mengenai tank musuh, itu menghilang dan menghasilkan efek ledakan; Pertama, perlu untuk menentukan apakah peluru tank pemain mengenai musuh, jadi ada fungsi untuk terus -menerus menilai musuh. Ketika peluru berjalan di tangki musuh, kehidupan tank perlu berakhir, dan sebuah bom dihasilkan, dan sebuah bom digambar dalam cat ();
7. Tank musuh dapat bergerak dengan cerdas: jika tangki hanya bisa bergerak, ia perlu secara acak menghasilkan arah gerakan. Karena gerakan konstan, metode ini ditulis ke dalam fungsi run utas dan utas dikontrol untuk tidur untuk mencapai masalah kecepatan gerakan;
8. Tank musuh dapat menembakkan peluru: saat menggambar musuh, mengatur tidak aktif di benang untuk menghasilkan peluru dari arah yang berbeda dan jumlah tank yang berbeda, dan mengambil setiap peluru pada panel dan menggambarnya;
9. Ketika peluru musuh memukul pemain, pemain menghilang: terus mengeluarkan setiap peluru musuh dan membandingkannya dengan tank pemain. Ketika peluru menyentuh pemain, ledakan pemain menghilang;
3. Desain Ringkasan
• Pengaturan atribut peran
Tank: Lokasi di mana tangki dihasilkan, warna berbagai jenis tangki, pengidentifikasi kehidupan tangki, kecepatan gerakan tangki, dan tangki dalam arah yang berbeda;
Player Tank: Setelah mewarisi atribut dasar tangki, diwujudkan berdasarkan basis kedua, dan tangki pemain bergerak dengan bebas ke atas dan ke bawah dan kiri dan kanan; dan tangki pemain memiliki fungsi menembakkan dan menembakkan peluru;
Tank musuh: Setelah mewarisi atribut tangki dasar, perlu untuk mewujudkan gerakan cerdas dari tangki musuh, dan pada saat yang sama, ia juga harus meluncurkan benang peluru pada tank dari posisi yang berbeda;
Peluru: Peluru harus memiliki posisi koordinat, kecepatan, kesehatan, dan peluru harus dapat bergerak, dan peluru juga harus menerapkan metode fungsi kematian;
Bom: Koordinat bom, kehidupan, dan fungsi metode efek dari kehidupan yang secara bertahap menghilang;
• Pengaturan properti fungsional
Kertas gambar: Paint () harus menggambar tangki pemain, tangki musuh, dan menampilkan efek ledakan tangki kematian;
Pemantauan Acara: Ketika pengguna menekan WDSA, tangki pemain yang sesuai harus mengubah arah. Ketika pengguna menembakkan J, ada peluru ke arah peluncuran, dan itu harus berjalan sampai mati, kecuali itu mengenai musuh;
Tekan tangki: Ketika peluru menyentuh tangki musuh, ledakan dihasilkan dan ditambahkan ke set ledakan, dan informasi ledakan ditarik di permukaan;
Musuh memukul pemain: Keluarkan musuh yang disebut dalam permainan dan setiap peluru musuh cocok dengan tank saya untuk menentukan apakah akan memukulnya;
Pemain menghantam musuh: Keluarkan setiap peluru pemain, cocokkan setiap tangki musuh untuk menentukan apakah akan memukulnya; dan menempatkan penilaian yang terkait dengan memukul tangki ke dalam run thread () untuk membuat penilaian bersamaan yang berkelanjutan;
Diagram analisis fungsional spesifik adalah sebagai berikut:
• Diagram analisis atribut karakter tangki
Diagram analisis papan gambar fungsional
Diagram Analisis Keseluruhan Tank XMind
Atribut Karakter Tank diagram xMind
Atribut fungsi tangki diagram xmind
Iv. Implementasi Sistem
• anggota.java
//Members.javapackage mytank9; impor java.util.*; Bom kelas {// mendefinisikan koordinat bom int x, y; // Kehidupan bom adalah kehidupan int = 9; boolean isLive = true; bom publik (int x, int y) {this.x = x; this.y = y; } // Kurangi kesehatan public void lifedown () {if (Life> 0) {Life--; } else {this.islive = false; }}} class shot implement runnable {int x; int y; int langsung; Kecepatan int = 1; boolean isLive = true; bidikan publik (int x, int y, int direct) {this.x = x; this.y = y; this.direct = langsung; } public void run () {while (true) {coba {thread.sleep (50); } catch (Exception e) {E.PrintStackTrace (); } switch (Direct) {case 0: y- = speed; merusak; Kasus 1: x+= kecepatan; merusak; Kasus 2: y+= kecepatan; merusak; Kasus 3: x- = kecepatan; merusak; } // Tentukan apakah bidang tersebut mencapai tepi jika (x <0 || x> 400 || y <0 || y> 300) {this.islive = false; merusak; }}}} Tangki kelas {// tangki koordinat horizontal int x = 0; // g koordinat vertikal int y = 0; // arah tangki // 0 menunjukkan atas, 1 menunjukkan kanan, 2 menunjukkan lebih rendah, 3 menunjukkan int int direct = 0; // kecepatan tank int kecepatan = 1; // warna tank int warna; boolean isLive = true; publik int getColor () {return color; } public void setColor (int color) {color = color; } public int getSpeed () {return speed; } public void setSpeed (int speed) {this.speed = speed; } public int getDirect () {return direct; } public void setDirect (int direct) {this.direct = Direct; } Tangki publik (int x, int y) {this.x = x; this.y = y; } public int getX () {return x; } public void setx (int x) {this.x = x; } public int gety () {return y; } public void sety (int y) {this.y = y; }} // Kelas Tank Musuh Musuh Perpanjangan Tank Implement Runnable {int Times = 0; // Tentukan vektor yang dapat menyimpan peluru musuh vektor <sot> ss = vektor baru <tot> (); // musuh menambah peluru setelah tank dan tank musuh baru saja telah diciptakan dan tank musuh telah mati di depan kusut publik. } @Override public void run () {// TODO Metode yang dihasilkan otomatis Stub while (true) {switch (this.direct) {case 0: // menunjukkan bahwa tangki bergerak ke atas untuk (int i = 0; i <30; i ++) {// Tank musuh bergerak dalam kisaran saya jika (y> 0) {y- = speed; } coba {thread.sleep (50); } catch (InterruptedException E) {// TODO Auto-Encanerated Catch Block E.PrintStackTrace (); } } merusak; Kasus 1: untuk (int i = 0; i <30; i ++) {if (x <400) {x+= kecepatan; } coba {thread.sleep (50); } catch (InterruptedException E) {// TODO Auto-Encanerated Catch Block E.PrintStackTrace (); } } merusak; Kasus 2: untuk (int i = 0; i <30; i ++) {if (y <300) {y+= kecepatan; } coba {thread.sleep (50); } catch (InterruptedException E) {// TODO Auto-Encanerated Catch Block E.PrintStackTrace (); } } merusak; Kasus 3: untuk (int i = 0; i <30; i ++) {if (x> 0) {x- = kecepatan; } coba {thread.sleep (50); } catch (InterruptedException E) {// TODO Auto-Encanerated Catch Block E.PrintStackTrace (); } } merusak; } // Tentukan apakah Anda perlu menambahkan peluru baru ke tangki ini. if (kali%2 == 0) {if (isLive) {if (ss.size () <5) {shot s = null; switch (Direct) {case 0: // Buat peluru s = bidikan baru (x+10, y, 0); // Tambahkan peluru ke vektor ss.add (s); merusak; Kasus 1: S = bidikan baru (x+30, y+10, 1); ss.add (s); merusak; Kasus 2: S = bidikan baru (x+10, y+30, 2); ss.add (s); merusak; Kasus 3: S = bidikan baru (x, y+10, 3); ss.add (s); merusak; } // Mulai utas peluru utas t = utas baru; t.start (); }}} // Biarkan tangki secara acak menghasilkan arah baru this.direct = (int) (math.random ()*4); // Periksa apakah tangki musuh mati jika (this.islive == false) {// Setelah membiarkan tangki mati, keluar dari proses istirahat; }}}} // Kelas Tank saya Pahlawan memperluas tank {vektor <Hots> s = vektor baru <ots> (); Tembakan S = null; pahlawan publik (int x, int y) {super (x, y); } // Fire public void shotenemy () {switch (this.direct) {case 0: // Buat peluru s = bidikan baru (x+10, y, 0); // Tambahkan peluru ke vektor ss.add (s); merusak; Kasus 1: S = bidikan baru (x+30, y+10, 1); ss.add (s); merusak; Kasus 2: S = bidikan baru (x+10, y+30, 2); ss.add (s); merusak; Kasus 3: S = bidikan baru (x, y+10, 3); ss.add (s); merusak; } Utas t = utas baru; t.start (); } // tank bergerak ke atas public void moving () {y- = speed; } // Tank Moveright () {x+= kecepatan; } public void dipindahkan () {y+= kecepatan; } public void moveleft () {x- = speed; }} • mytankgame4.java
//Mytankgame4.java/* * Fungsi: Tank Game 2.0 * 1: Gambar tangki * 2: Tank saya dapat bergerak ke atas dan ke bawah * 3: Gambar tangki musuh * 4: Tank saya dapat menembakkan peluru * 5: peluru dapat menembak (hingga lima tembakan; Ledakan: 1 Mempersiapkan tiga gambar terlebih dahulu; 2 Kelas Bom; 3 Masukkan bom saat memukul Tank Musuh Vektor 4 Draw* 7: Tank musuh bergerak dalam kisaran saya yang ditentukan* 8: Tank musuh juga dapat menembakkan peluru* 9: ketika tangki musuh; java.awt.event.*; impor java.io.file; impor java.util.*; kelas publik mytankgame4 memperluas jFrame {mypanel mp = null; null; public mytankame4 mytankame) {// todo auto-method stub mytankgame4 mytankgame4 = mytank4 (mytank4 (mytank4 (mytank4 (mytank4 (mytank4 (mytank4 (mytank4 (mytank4 (mytanke. MP = myPanel baru (); t.start (); this.add (mp); // mendaftar untuk mendengarkan this.addKeyListener (MP); this.setsize (400, 300); this.setDefaultCloseOperation (jframe.exit_on_close); this.setVisible (true); }} kelas mypanel memperluas jpanel mengimplementasikan keylistener, runnable {// mendefinisikan pahlawan tank saya = null; // tentukan vektor tank musuh <suuskank> ets = vektor baru <suzytank> (); // definisikan satu set bom vektor <bom> bomb baru = vektor = vektor baru <) (bomb vektor = bomb baru = vektor = vektor = bomb baru = vektor = vektor = vektor New <bomb> bomb <bomb> bomb baru <) // Tentukan switching tiga gambar untuk membentuk gambar bom gambar1 = null; Gambar gambar2 = null; Image Image3 = null; // Bangun publik mypanel () {hero = new Hero (100.100); // Inisialisasi tangki musuh untuk (int i = 0; i <ensize; i ++) {// Buat objek tangki musuh musuh ET = musuh baru ((i+1)*50, 0); et.setColor (0); ET.SetDirect (2); // Mulai utas tangki musuh t = utas baru (ET); t.start (); // menegosiasikan peluru ke tembakan tank musuh S = tembakan baru (et.x+10, et.y+30,2); et.ss.add (s); Utas T2 = utas baru; t2.start (); // Bergabunglah dengan ets.add (ET); } coba {image1 = imageo.read (file baru ("bomb_1.gif")); Image2 = Imageo.read (file baru ("bomb_2.gif")); Image3 = Imageo.read (file baru ("bomb_3.gif")); } catch (Exception e) {E.PrintStackTrace (); } // Inisialisasi tiga gambar // gambar1 = toolkit.getDefaultToolKit (). GetImage (panel.class.getResource ("/bomb_1.gif")); // image2 = toolkit.getDefaultToolkit (). GetImage (panel.class.getResource (" Toolkit.getDefaultToolKit (). GetImage (panel.class.getResource ("/bomb_3.gif")); } // mengecat cat public void (grafik g) {super.paint (g); g.fillrect (0, 0, 400, 300); // Gambarlah tangki Anda sendiri if (hero.islive == true) {this.drawtank (hero.getx (), hero.gety (), g, this.hero.direct, 1); } // Hapus setiap peluru dari SS dan gambar untuk (int i = 0; i <hero.ss.size (); i ++) {// Keluarkan peluru yang ditembak myshot = hero.ss.get (i); // Gambarlah peluru dan gambar satu peluru. Bagaimana cara menggambar beberapa peluru? traversal if (myshot! = null && myshot.islive == true) {g.draw3drect (myshot.x, myshot.y, 1, 1, false); } if (myshot.islive == false) {// Hapus peluru dari ss vector hero.ss.remove (myshot); }} // Gambar bom untuk (int i = 0; i <bombs.size (); i ++) {bom b = bombs.get (i); if (b.life> 6) {g.drawimage (gambar1, bx, oleh, 30,30, ini); } else if (b.life> 4) {g.drawimage (gambar2, bx, oleh, 30,30, ini); } else {g.drawimage (Image3, BX, oleh, 30,30, ini); } // Kurangi nilai kesehatan B b.lifedown (); // Jika nilai kesehatan bom == 0, tendang jika (b.life == 0) {bombs.remove (b); }} // Gambarlah tangki musuh untuk (int i = 0; i <ets.size (); i ++) {musuh Et = ets.get (i); if (et.islive) {this.drawtank (et.getx (), et.gety (), g, et.getDirect (), 0); // Gambarlah peluru musuh untuk (int j = 0; j <et.ss.size (); j ++) {shot musuh) {shot musuh = et.ss.ss.get (j); if (musemyshot.islive) {g.draw3drect (musuharshot.x, musuh. } else {// Tank musuh mati et.ss.remove (musuh); }}}}}}}}} // Apakah peluru musuh memukul saya public void hitme () {// Lepaskan setiap tangki musuh untuk (int i = 0; i <this.ets.size (); i ++) {// Keluarkan musuh tank musuh musuh ET = ets.get (i); if (et.islive == true) {for (int j = 0; j <et.ss.size (); j ++) {// Keluarkan peluru tembakan musuh = et.ss.get (j); if (musuh. }}}}}}}}} // Apakah peluru saya mengenai tangki musuh public void hitenemytank () {// Tentukan apakah tangki musuh dipukul (int i = 0; i <hero.ss.size (); i ++) {bidikan myshot = hero.ss.get (i); Untuk mengeluarkan setiap tangki dan menilai untuk (int j = 0; j <ets.size (); j ++) {musuh ET = ets.get (j); if (et.islive == true) {this.hittank (myshot, et); }}}}}}}}}}} // Untuk menulis fungsi secara khusus untuk menentukan apakah peluru mengenai tangki public void Hittank (bidikan S, tank ET) {switch (et.direct) {// Jika arah tangki musuh adalah bagian atas atau huruf kecil 0: case 2: if (sx> et.x && s.x <et.x+20 && s.y> et.y && s.y <et.y+30) {// tekan kematian s.islive = false; // tank kematian et.islive = false; // buat bom dan masukkan ke dalam bom vektor b = bom baru (et.x, et.y); bom.add (b); } Kasus 1: Kasus 3: if (sx> et.x && s.x <et.x+30 && s.y> et.y && s.y <et.y+20) {{// tekan kematian s.islive = false; // musuh kematian tank et.islive = false = false; Bom b = bom baru (et.x, et.y); bom.add (b); }}}}}}} // Gambar tangki public void drawTank (int x, int y, grafik g, int langsung, tipe int) {// Tangki tipe switch (type) {case 0: g.setColor (color.cyan); merusak; Kasus 1: G.SetColor (Color.Yellow); merusak; } // Sakelar arah tangki (Direct) {// Up case 0: // Gambarlah tangki di g.fill3drect kiri (x, y, 5, 30, false); // drawline (x+10, y+15, y+15, 5, 30, false); // gambar false g.fill3 (x+5, 10, 10, 10, 10, 10, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+5, y+ y+10, 10, 10); // Gambar garis lurus G.Drawline (x+10, y+15, x+10, y); merusak; Kasus 1: // Di sebelah kanan // Gambarlah persegi panjang atas G.Fill3Drect (x, y, 30, 5, false); // Gambarkan persegi panjang lebih rendah G.Fill3drect (x, y+15, 30, 5, false); // gambar persegi panjang lebih rendah g.fill3drect (x, y+15, 30, 5, false);/ false); merusak; Kasus 2: // Gambarlah tangki di bawah g.fill3drect (x+15, y+10, x+30, y+10); // Gambarlah tangki di g.fill3drect (x+15, y+10, x+30, y+10); // gambar tangki pada g.fill3drect (x+15, y, 5, 30, false); y+5, 10, 20, false); // Gambar persegi panjang g.fill3drect (x+5, y+5, 10, 20, false); // drawline (x+10, y+10, 10, 10); // Gambar garis lurus G.Drawline (x+10, y+15, x+10, y+30); merusak; Kasus 3: // Di sebelah kiri // Gambarlah persegi panjang atas G.Fill3Drect (x, y, 30, 5, false); // Gambar persegi panjang lebih rendah g.fill3drect (x, y+15, 30, 5, false); // gambarkan persegi panjang tengah g.fill3drect (x+5, y+5, 20, 10, false); 10); // Drawline (x+15, y+10, x, y+10); merusak; }} // Tekan tombol dan prosesnya. A kiri S Down D ke kanan W UP. @Override public void keytyped (KeyEvent e) {// TODO Metode yang dihasilkan secara otomatis} @Override public void keypressed (keyevent e) {// TODO Metode yang dihasilkan otomatis Stub if (e.getKeyCode () == keyevent.vk_w) {this.hero.setdirect (0); this.hero.moveup (); } else if (e.getKeyCode () == keyevent.vk_d) {this.hero.setDirect (1); this.hero.moveright (); } else if (e.getKeyCode () == keyevent.vk_s) {this.hero.setDirect (2); this.hero.movedown (); } else if (e.getKeyCode () == keyevent.vk_a) {this.hero.setDirect (3); this.hero.moveleft (); } if (e.getKeyCode () == keyevent.vk_j) {// Tentukan apakah pemain menekan j // fire if (this.hero.ss.size () <= 4 && this.hero.islive == true) {this.hero.shotenemy (); }} // Panel harus dicat ulang ini.repaint (); } @Override public void keyreleased (KeyEvent e) {// TODO Metode yang dihasilkan secara otomatis} public void run () {while (true) {try {thread.sleep (100); } catch (Exception e) {E.PrintStackTrace (); } this.hitenemytank (); // fungsi menentukan apakah peluru musuh memukul saya this.hitme (); this.repaint (); }}}5. Hasil tes
Kuning adalah pemain, tekan pemain
Musuh menembak peluru
Di atas adalah semua konten artikel ini. Saya berharap ini akan membantu untuk pembelajaran semua orang dan saya harap semua orang akan lebih mendukung wulin.com.