fork download
copy 
  1. #include <stdio.h>
  2. #include <stdbool.h>
  3. #include <stdlib.h>
  4. #include <time.h>
  5. #include <string.h>
  6.  
  7. //akan digunakan untuk memberikan warna ke suatu teks
  8. #define GREEN "\033[0;32m"
  9. #define RED "\033[0;31m"
  10. #define RESET "\033[0m"
  11.  
  12. int n ; // variabel untuk baris, kolom, dan jumlah bom 
  13. int jumlah_kotak_menang ; // vaariabel untuk menyimpan jumlah kotak yang harus dibuka untuk menang
  14. bool grid1 [15] [15] ; // matrix untuk menentukan sebuah kotak sudah terbuka atau belum
  15. int grid2 [15] [15] ; // matrix untuk menyimpan jumlah bom disekitar di setiap kotak
  16.  
  17. char border [] = "=====================================" ;
  18. int nyawa ;
  19. int hint ;
  20.  
  21. // fungsi untuk membersihkan terminal
  22. void clear_screen ()
  23. {
  24. #ifdef _WIN32
  25.     system("cls") ;
  26. #else
  27.     system("clear") ;
  28. #endif
  29. }
  30.  
  31. //fungsi awal untuk menentukan tingkat kesulitan
  32. void intro ()
  33. {
  34.     int input_level ;
  35.     clear_screen() ;
  36.  
  37.     printf ("%s\n", border) ;
  38.     printf ("==========TINGKAT KESULITAN==========\n") ;
  39.     printf ("%s\n", border) ;
  40.     printf ("1. Easy\n") ;
  41.     printf ("2. Medium\n") ;
  42.     printf ("3. Hard\n") ;
  43.  
  44.     printf ("Pilih Tingkat Kesulitan Yang Anda Inginkan: ") ;
  45.     scanf ("%d", &input_level) ; // meminta input tingkat kesulitan yang diinginkan
  46.  
  47.     // menentukan tingkat kesulitan dari input yang diberikan menggunakan switch
  48.     switch (input_level)
  49.     {
  50.     case 1:
  51.         n = 5;
  52.         nyawa = 2;
  53.         hint = 2;
  54.         break;
  55.     case 2:
  56.         n = 7;
  57.         nyawa = 5;
  58.         hint = 5;
  59.         break;
  60.     case 3:
  61.         n = 9;
  62.         nyawa = 7;
  63.         hint = 7;
  64.         break;
  65.     }
  66.  
  67.     //setelah baris, kolom, dan jumlah bom sudah ditentukan
  68.     //harus melakukan perhitungan jumlah kotak (bukan berisi bom) yang harus dibuka untuk menang
  69.     jumlah_kotak_menang = ( n * n ) - n ; 
  70. }
  71.  
  72. // fungsi yang bertujuan untuk menjelaskan cara bermain
  73. void rules ()
  74. {
  75.     clear_screen() ;
  76.     printf ("%s\n", border) ;
  77.     printf ("================RULES================\n") ;
  78.     printf ("%s\n", border) ;
  79.     printf ("1. Buka semua kotak tanpa menyentuh bom.\n") ;
  80.     printf ("2. Kotak hijau = belum dibuka.\n") ;
  81.     printf ("3. Kotak angka = jumlah bom di sekitar.\n") ;
  82.     printf ("4. Ketik nomor kotak untuk membuka.\n") ;
  83.     printf ("5. Kamu punya sejumlah nyawa tergantung level.\n") ;
  84.     printf ("6. Kamu punya sejumlah hint tergantung level.\n") ;
  85.     printf ("7. Ketik 0 untuk memakai hint.\n") ;
  86.     printf ("%s\n", border) ;
  87.  
  88.     // memastikan pemain ingin melanjutkan permainan setelah membaca rules
  89.     char lanjut;
  90.     printf ("Lanjut ke permainan? [y/n] : ") ;
  91.     scanf (" %c", &lanjut) ;
  92.  
  93.     //jika input pemain adalah n maka program berahir
  94.     if (lanjut == 'n') {
  95.         clear_screen() ;
  96.         exit(0); //program berahir, seperti return(0)
  97.     }
  98. }
  99.  
  100. // fungsi untuk menghitung jumlah bom di sekitar kotak baris ke i kolom ke j
  101. int cek_sekitar (int i, int j)
  102. {
  103.     //memeriksa apakah kotak berisi bom
  104.     //jika iya maka tidak perlu menghitung jumlah bom di sekitar
  105.     if (grid2[ i] [j] == -1) return -1 ;
  106.     int ans = 0 ; //variabel untuk menyimpan jumlah bom yang mula mula jml bom = 0 
  107.  
  108.     // memeriksa kotak-kotak di sekitarnya, jika ada bom maka jumlah bertambah
  109.     if (grid2 [i] [j+1] == -1 )ans++ ;      // memeriksa bagian samping kanan 
  110. 	if (grid2 [i+1] [j+1] == -1 )ans++ ;    // memeriksa bagian kanan bawah
  111. 	if (grid2 [i+1] [j] == -1 )ans++ ;      // memeriksa bagian bawah
  112. 	if (grid2 [i+1] [j-1] == -1 )ans++ ;    // memeriksa bagian kiri bawah
  113. 	if (grid2 [i] [j-1] == -1 )ans++ ;      // memeriksa bagian samping kiri
  114. 	if (grid2 [i-1] [j-1] == -1 )ans++ ;    // memeriksa bagian kiri atas
  115. 	if (grid2 [i-1] [j] == -1 )ans++ ;      // memeriksa bagian atas
  116. 	if (grid2 [i-1] [j+1] == -1 )ans++ ;    // memeriksa bagian kanan atas
  117.  
  118.     //mengembalikan jumlah bom disekitar kotak
  119.     return ans ;
  120. }
  121.  
  122. // fungsi untuk menyimpan jumlah bom di sekitar setiap kotak
  123. void inisialisasi_grid2 ()
  124. {
  125.     for (int i = 1; i <= n; i++) {
  126.         for (int j = 1; j <= n; j++) {
  127.             grid2 [i] [j] = cek_sekitar(i, j) ; 
  128.         }
  129.     }
  130. }
  131.  
  132. // mencetak pengumuman bahwa pemain kalah
  133. void game_over ()
  134. {
  135.     printf ("\n%s\n", border) ;
  136.     printf ("==============GAME OVER==============\n") ;
  137.     printf ("%s\n", border) ;
  138. }
  139.  
  140. // mencetak pengumuman bahwa pemain menang
  141. void menang ()
  142. {
  143.     printf ("\n%s\n", border) ;
  144.     printf ("=========SELAMAT ANDA MENANG=========\n") ;
  145.     printf ("%s\n", border) ;
  146. }
  147.  
  148. //fungsi untuk mencetak seluruh kotak, sisa hint, dan sisa nyawa selama permainan berlangsung
  149. void cetak ()
  150. {
  151.     int no_kotak = 1 ; //variabel untuk memberi nomor kotak dari paling kiri atas ke paling kanan bawah
  152.  
  153.     //cetak kotak satu per satu
  154.     for (int i = 1; i <= n; i++) {
  155.         for (int j = 1; j <= n; j++) {   
  156.  
  157.             //memeriksa apakah kotak sudah dibuka
  158.             if (!grid1 [i] [j]) //belum dibuka
  159.                 printf (GREEN "%3d " RESET, no_kotak) ; //akan menghasilkan no kotak berwarna hijau (belum dibuka)
  160.             else { 
  161.                 if (grid2 [i] [j] == -1)
  162.                     printf (RED "  X " RESET) ; //akan menghasilkan X yang berarti bom
  163.                 else
  164.                     printf ("%3d ", grid2 [i] [j]) ; // akan menghasilkan jumlah bom yang ada di sekitarnya
  165.             }
  166.             no_kotak++ ; 
  167.         }
  168.         printf("\n") ;
  169.     }
  170.     printf ("%s\n", border) ;
  171.     printf ("Nyawa: %d | Hint tersisa: %d\n", nyawa, hint) ;
  172.     printf ("%s\n", border) ;
  173. }
  174.  
  175. // fungsi untuk menyimpan nilai kotak yang akan dibuka
  176. // dan memeriksa apakah kotak yang dibuka berisi bom
  177. void buka (int x)
  178. {
  179.     int no_kotak = 1 ;
  180.     for (int i = 1; i <= n; i++) {
  181.         for (int j = 1; j <= n; j++) {
  182.  
  183.             // memeriksa apakah no kotak sekarang sudah sesuai dengan no kotak yang ingin dibuka dan kondisi kotak tidak boleh terbuka 
  184.             if (no_kotak == x && grid1 [i] [j] == false) {
  185.                 grid1 [i] [j] = true ; // menandakan kotak sudah dibuka
  186.  
  187.                 //jika kotak yang dibuka berisi bom maka nyawa akan berkurang dan akan game over jika nyawa sudah habis
  188.                 //jika tidak jumlah kotak yang harus dibuka agar menang akan berkurang
  189.                 if (grid2 [i] [j] == -1) {
  190.                     nyawa-- ;
  191.                     printf (RED "Kamu menyentuh bom! Nyawa berkurang jadi %d.\n" RESET, nyawa) ;
  192.  
  193.                     //jika nyawa habis maka game over dan program berhenti
  194.                     if (nyawa <= 0) {
  195.                         game_over() ;
  196.                         for(int i=1; i<=8e8; i++) ;
  197.                         clear_screen() ;
  198.                         exit(0) ;
  199.                     }
  200.                 }else {
  201.                     jumlah_kotak_menang-- ;
  202.                 }
  203.             }
  204.             no_kotak++ ;
  205.         }
  206.     }
  207. }
  208.  
  209. //fungsi untuk memberi pemain kotak yang bukan berisi bom
  210. //caranya dengan memeriksa kotak yg belum dibuka sesuai urutan nomor 
  211. //dan nomor kotak pertama yang ditemukan aman akan dicetak
  212. void pakai_hint ()
  213. {
  214.     //periksa apakah masih ada kesempatan hint
  215.     if (hint <= 0) {
  216.         printf (RED "Hint sudah habis!\n" RESET) ;
  217.         return ; // mengahiri fungsi dan kembali ke fungsi pemanggil
  218.     }
  219.  
  220.     int aman ; // variabel untuk menyimpan nomor kotak yang aman
  221.     int no_kotak = 1 ;
  222.  
  223.     for (int i = 1; i <= n; i++) {
  224.         for (int j = 1; j <= n; j++) {   
  225.             //memeriksa apakah kotak belum dibuka dan apakah kotak bukan berisi bom
  226.             if (!grid1 [i] [j] && grid2 [i] [j] != -1) {
  227.                 aman = no_kotak ;
  228.                 break ;
  229.             }
  230.             no_kotak++ ;
  231.         }
  232.         if (aman != -1) break ;
  233.     }
  234.  
  235.     // cetak no kotak aman yang ditemukan
  236.     printf (GREEN "Hint: Kotak nomor %d tidak ada bom!\n" RESET, aman) ;
  237.     hint-- ;
  238. }
  239.  
  240. // fungsi untuk membaca dan mengatur apa yang akan dilakukan
  241. // dari input yang diberikan pemain ketika game sudah dimulai
  242. void mainn ()
  243. {
  244.     int kotak_berapa ;
  245.     printf ("Masukkan Kotak yang dipilih (0 = hint): ") ;
  246.     scanf ("%d", &kotak_berapa) ; //untuk membaca kotak berapa yang ingin dibuka atau ingin menggunakan hint
  247.  
  248.     // memeriksa jika pemain meminta hint
  249.     if (kotak_berapa == 0) {
  250.         pakai_hint() ;
  251.         return ; // mengahiri fungsi dan kembali ke fungsi pemanggil
  252.     }
  253.  
  254.     //buka kotak yang dipilih
  255.     buka(kotak_berapa) ;
  256.  
  257.     //menampilkan seluruh kotak setelah kotak yang dipilih terbuka
  258.     clear_screen() ;
  259.     cetak() ;
  260. }
  261.  
  262. // fungsi untuk mengatur alur game dari awal hingga akhir
  263. // kenapa tidak di int main () ? 
  264. // jika pemain ingin bermain lagi setelah sebuah game selesai maka tinggal memanggil fungsi ini saja
  265. void main1 ()
  266. {
  267.     intro() ;
  268.     rules() ;
  269.     clear_screen() ;
  270.  
  271.     memset (grid1, 0, sizeof(grid1)) ; //memberi nilai 0 atau false yang artinya tertutup 
  272.     memset (grid2, 0, sizeof(grid2)) ; //memberi nilai 0
  273.  
  274.     // tanam bom secara acak
  275.     for (int i = 1; i <= n; i++){
  276.         int a = rand() % n + 1 ;
  277.         int b = rand() % n + 1 ;
  278.  
  279.         //memeriksa apakah kotak yang ingin ditanam bom sudah tertanam sebuah bom atau belum
  280.         if (grid2 [a] [b] == -1)
  281.         {
  282.             i-- ; //agar i tidak bertambah di selanjutnya
  283.             continue ;
  284.         }
  285.         grid2[a][b] = -1 ;
  286.     }
  287.  
  288.     //setelah bom ditentukan inisialisasi seluruh kotak dengan jumlah bom di sekitar
  289.     inisialisasi_grid2() ;
  290.  
  291.     // cetak seluruh kotak
  292.     cetak() ;
  293.  
  294.  
  295.     while (true){
  296.         mainn() ; //
  297.         //memeriksa jika semua kotak yang bukan berisi bom sudah dibuka maka pemain menang
  298.         if(jumlah_kotak_menang == 0) {
  299.             menang() ;
  300.             break ; 
  301.         }
  302.     }
  303.  
  304.     //menanyakan ke pemain apakah ingin bermain lagi dan pemain membrikan input y atau n
  305.     char x ;
  306.     printf ("Ingin bermain lagi? [y/n] : ") ;
  307.     scanf (" %c", &x) ;
  308.  
  309.     //jika pemain ingin bermain lagi maka akan mengulangi fungsi ini dari awal
  310.     //jika tidak maka program berahir
  311.     if (x == 'y') main1() ;
  312. }
  313.  
  314. int main ()
  315. {
  316.     //inisialisasi serangkaian angka secara acak
  317.     srand(time(NULL)) ;
  318.  
  319.     //masuk ke fungsi game
  320.     main1() ;
  321.  
  322.     //membersiihkan terminal ketika selesai bermain
  323.     clear_screen() ;
  324. }
Success #stdin #stdout #stderr 0.01s 5280KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
=====================================
==========TINGKAT KESULITAN==========
=====================================
1. Easy
2. Medium
3. Hard
Pilih Tingkat Kesulitan Yang Anda Inginkan: =====================================
================RULES================
=====================================
1. Buka semua kotak tanpa menyentuh bom.
2. Kotak hijau = belum dibuka.
3. Kotak angka = jumlah bom di sekitar.
4. Ketik nomor kotak untuk membuka.
5. Kamu punya sejumlah nyawa tergantung level.
6. Kamu punya sejumlah hint tergantung level.
7. Ketik 0 untuk memakai hint.
=====================================
Lanjut ke permainan? [y/n] : =====================================
Nyawa: 0 | Hint tersisa: 0
=====================================
Masukkan Kotak yang dipilih (0 = hint): =====================================
Nyawa: 0 | Hint tersisa: 0
=====================================

=====================================
=========SELAMAT ANDA MENANG=========
=====================================
Ingin bermain lagi? [y/n] :
stderr
copy 
TERM environment variable not set.
TERM environment variable not set.
TERM environment variable not set.
TERM environment variable not set.
TERM environment variable not set.
https://ideone.com/Su5DGy
MINESWEEPER
language:
C (gcc 8.3)
created:
2 days ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!