minezj.java

Go to the documentation of this file.

import java.applet.Applet;
import java.util.Random;
import java.awt.*;

public class minezj extends java.applet.Applet
{
        private Image buffer;           
        private Graphics screen;        

        private byte[] pground;         
        private Image[] img;            
        private boolean fl_done;        
        private int screen_x;           
        private int screen_y;           
        private int bgcolor = 0xE0E0E0; 
        private int nr_mines = 85;      
        private int size_x = 30;        
        private int size_y = 15;        
        private int nr_uncovered = 0;   

        private final byte F_MINE = 9;          
        private final byte B_UNCOVERED = 0x10;  
        private final byte B_MARKED = 0x20;     
        private final byte COUNT_MASK = 0x0F;   
        private final byte C_SIZE = 15; 

        public String getAppletInfo ()
        {
                return "minezj 1.0\r\nOndra Havel <xohavel@fd.cvut.cz>\r\n";
        }
        
        public void init ()
        {
                String opt;

                screen_x = getSize().width;
                screen_y = getSize().height;

                try {
                        buffer = createImage (screen_x, screen_y);
                        screen = buffer.getGraphics ();
                } catch (Exception e) {
                        screen = null;
                }

                pground = new byte[size_x * size_y];

                opt = getParameter("bgcolor");
                if(opt!=null)
                        bgcolor = Integer.parseInt(opt);
                        
                img = new Image[13];
                for (int i = 0; i < 13; i++)
                        img[i] = getImage (getCodeBase (), "./gfx/" + (i) + ".gif");
        }

        public void reset_game ()
        {
                Random a;
                int todo, fields, mns = nr_mines, i, j, r, cnt;

                fl_done = false;
                nr_uncovered = 0;
                
                a = new Random ();
                todo = fields = size_y * size_x;

/*  clear the mine-field */
                for (i = 0; i < todo; i++)
                        pground[i] = 0;

                while(mns>0) {
                        mns--;
                        r = (int)(todo * a.nextDouble());
                        i = 0;
                        cnt = 0;
                        while (i<fields) {
                                if(pground[i]==0) {
                                        if(cnt == r) {
                                                pground[i] = F_MINE;
                                                break;
                                        }
                                        cnt++;
                                }       
                                i++;
                        }
                }

/*  count values for non-mine fields     */
                for(i=0;i<fields;i++) {
                        if(pground[i]==0) {
                                int y=i/size_x, x=i % size_x;
                                /*  up */
                                if(y!=0) {
                                        if(pground[i-size_x] == F_MINE)
                                                pground[i]++;
                                        /*  and left */
                                        if(x-1>=0 && pground[i - size_x - 1] == F_MINE)
                                                pground[i]++;
                                        /*  and right */
                                        if(x+1<size_x && pground[i-size_x+1] == F_MINE)
                                                pground[i]++;   
                                }

                        /* down */
                        if(y!=size_y-1) {
                                if(pground[i+size_x]==F_MINE)
                                        pground[i]++;
                                /* and left */
                                if(x-1>=0 && pground[i+size_x-1] == F_MINE)
                                        pground[i]++;
                                /* and right */
                                if(x+1<size_x && pground[i+size_x+1]==F_MINE)
                                        pground[i]++;
                                }
                                
                                /* left */
                                if(x!=0 && pground[i-1]==F_MINE)
                                        pground[i]++;
                                        
                                        /* right */
                                        if(x!=size_x-1&&pground[i+1]==F_MINE)
                                                pground[i]++;
                        }
                }
        }

        public void start ()
        {
                reset_game ();
                repaint ();
        }

        private boolean is_empty(int x, int y)
        {
                return(pground[x + y * size_x] == 0);
        }

        private void revealcount(int x, int y)
        {
                if((pground[x+y*size_x] & B_UNCOVERED)==0 && (pground[x+y*size_x] & COUNT_MASK)!=0) {
                        nr_uncovered++;
                        pground[x+y*size_x] |= B_UNCOVERED;
                }
        }

        private void zeroafter909(int x, int y)
        {
                pground[x+y*size_x] = B_UNCOVERED;
                nr_uncovered++;
                if(x>0) {
                        /*  left */
                        if(is_empty(x - 1,y)) {
                                zeroafter909(x - 1,y);
                        } else {
                                revealcount(x-1,y);
                                if(y>0)
                                        revealcount(x-1,y-1);
                                if(y<size_y-1)  
                                        revealcount(x-1,y+1);
                        }
                }
                if(x<size_x-1) {
                        /*  right */
                        if(is_empty(x+1,y)) {
                                zeroafter909(x+1,y);
                        } else {
                                revealcount(x+1,y);
                                if(y>0)
                                        revealcount(x+1,y-1);
                                if(y<size_y-1)  
                                        revealcount(x+1,y+1);
                        }
                }
                if(y>0) {
                        /*  up */
                        if(is_empty(x,y-1)) {
                                zeroafter909(x,y-1);
                        } else {
                                revealcount(x,y-1);
                        }
                }
                if(y<size_y-1)  {
                        /* down */
                        if(is_empty(x,y+1)) {
                                zeroafter909(x,y+1);
                        } else {
                                revealcount(x,y+1);
                        }
                }
        }

        public boolean mouseDown (Event e, int x, int y)
        {
                int cell_x = x / C_SIZE, cell_y = y / C_SIZE;
                int off = cell_x + cell_y * size_x;
                
/*  start new game if old already ended */
                if (fl_done) {
                        reset_game ();
                        repaint ();
                        return (true);
                }

/*  tide is high */
                if(cell_x > size_x || cell_y > size_y)
                        return (true);

/*  uncovered field, do nothing */
                if((pground[off] & B_UNCOVERED)!=0)
                        return (true);

/*  right click? tag/mark/untag/unmark it... */
                if ((e.modifiers & Event.META_MASK) == Event.META_MASK) {
                        pground[off] ^= B_MARKED;       /*  toggle the mark bit */
                        repaint();
                        return (true);
                }

/*  Covered empty field, look around. Here may lay surrounding mines */
/*  which ought to be 'automatically' uncovered, zeroafter909 does */
/*  this job. */
                if(pground[off]==0) {
                        zeroafter909(cell_x, cell_y);
                        repaint();
                        return (true);
                }

/*  do uncover if everything else failed...       */
                if((pground[off] & COUNT_MASK)==F_MINE) {
                        fl_done = true;
                } else {
                        pground[off] |= B_UNCOVERED;
                        nr_uncovered++;
                        if (nr_mines == size_x * size_y - nr_uncovered)
                                fl_done = true;
                }

                repaint ();

                return (true);
        }

        public void paint (Graphics g)
        {
                update (g);
        }

        public synchronized void update (Graphics g)
        {
                if (screen != null) {
                        do_draw (screen);
                        g.drawImage (buffer, 0, 0, this);
                } else {
                        do_draw (g);
                }
        }

        private void do_draw (Graphics g)
        {
                int i, pic_nr, val, count;

                g.setColor (new Color (bgcolor));
                g.fillRect (0, 0, screen_x, screen_y);

                for (i = 0; i < size_x * size_y; i++) {
                        val = pground[i];
                        count = val & COUNT_MASK;

/*  check whether you are already dead or not */
                        if((val & B_UNCOVERED)!=0 && count==F_MINE)
                                        fl_done = true;

/*  already done? well, unhide everything and show mistakes */
                        if (fl_done) {
                                if ((val & B_MARKED)!=0) { /* marked? */
                                        if(count!=F_MINE) {     /*  invalid mark */
                                                pic_nr = 12;
                                        } else {
                                                pic_nr = 11;    /*  common mark */
                                        }
                                } else {
                                        pic_nr = count;
                                }
                        } else {        /*  still staying alive */
                                if((val & B_UNCOVERED) == 0) {  /*  covered? :] */
                                        if((val & B_MARKED)!=0) {       /*  marked? */
                                                pic_nr = 11;
                                        } else {
                                                pic_nr = 10;
                                        }
                                } else {
                                        pic_nr = count;
                                }
                        }

                        if (img[pic_nr] != null)
                                g.drawImage (img[pic_nr], (i % size_x) * C_SIZE,
                                (i / size_x) * C_SIZE, this);
                }

/*     g.setFont (getFont()); */
                g.setColor (Color.black);
                g.drawString ("nr_uncovered=" + nr_uncovered, 0, size_y * C_SIZE + 16);
                
                if(fl_done) {
                        if (nr_mines == size_x * size_y - nr_uncovered) {
                g.drawString ("You have won!", (size_x * C_SIZE) >> 1, size_y * C_SIZE + 16);
                        } else {
                        g.drawString ("You have lost the match!", (size_x * C_SIZE) >> 1, size_y * C_SIZE + 16);
                        }
                }
        }
}

---