Magic

// Nukopinau kas manau bus tau naudingiausia.
// GameManager klase, pagrindine zaidimo logika ir tt. Cia tik map kurimas

    private static final int mapSize = 30;
    private static final int cellSize = 20;
    private static final int numberOfBombs = 100;

    public static boolean gameBegan;

    public static CellData[][] gameMatrix;

public GameManager(){ // Konstruktorius
        gameBegan = false;
        visC = new VisualClass(cellSize, mapSize); // Cia pagrindine vizualizacijos klase. Tesiog sukuriu langa.
        visC.setColors(Color.lightGray, Color.white);
        try{
           if(((mapSize * mapSize) - 5) < numberOfBombs){
               throw new Exception("Too many bombs! Can't proceed as there would be no numbers...");
           }
           if(numberOfBombs <= 0){
               throw new Exception("Number of bombs is invalid...");
           }

        }
        catch (Exception ex) {
            Logger.getLogger(GameManager.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

// Taip kaip mapas kuriamas tik po pirmo paspaudimo,
// todel sitas metodas kvieciamas VisualClass klasejem, po pirmojo paspaudimo.
    public static void generateMap(int clickPosX, int clickPosY){
        MapManager mapMan = new MapManager(mapSize, numberOfBombs); // Mapas generojamas isvis kitoi vietoi, nes ten daug skaiciavimu //atliekama. grubiai tariant, du for'ai ir daug ifu.
        gameMatrix = mapMan.createGameMatrix(clickPosX, clickPosY);
        gameBegan = true;
    }



// VisualClass. Vizualizacijos cia.

public class VisualClass extends ScreenKTU{
    int gridSize;

   int[] lastPaintedPos = new int[2]; // cia skirta animacijai, nekreipk demesio (tas visas animacijas istrinsiu, nes neveikia, dar :D)
    boolean isCurrentlyMarking = false; // sis irgi animacijai

    public VisualClass(int cellSize, int screenSize){
        super(cellSize, cellSize, screenSize, screenSize, ScreenKTU.Grid.ON);
        gridSize = screenSize;
        isCurrentlyMarking = false;
        lastPaintedPos[0] = 0;
        lastPaintedPos[1] = 0;
    }

    @Override
    public void mousePressed(MouseEvent e){
        int[] pos = GameManager.getCellFromScreenCords(e.getX(), e.getY());
        isCurrentlyMarking = true;
        lastPaintedPos = pos;
        if(!GameManager.gameBegan){ // jei pirmas paspaudimas tai sukuria mapa su GameManager.generateMap();
            System.out.print("MOUSE PRESSED! " + e.getX() + " " + e.getY() + "\n");
            paintGridWhite();
            GameManager.generateMap(pos[0], pos[1]);
        }
        if(GameManager.gameMatrix[pos[1]][pos[0]].isOpen == false){
            paintCellDGray(pos); // Nuspalvinu su fillRect ir iskarto sekancioje eiluteje atnaujinu.
            refresh(1);
        }

    }
    @Override
    public void mouseReleased(MouseEvent e){ // cia irgi animacija, lalalalala
        System.out.print("Mouse: " + e.getButton());
        int[] pos = GameManager.getCellFromScreenCords(e.getX(), e.getY());
        if(pos[0] == gridSize){ // Just never underestimate users...  (just in case to not get out of bounds exception
            pos[0] = gridSize - 1;
        }
        if(pos[1] == gridSize){
            pos[1] = gridSize - 1;
        }
        if(e.getButton() == 1){ // LMB
            revealCell(pos);
        }
        if(e.getButton() == 3){ // RMB, NOTICE BUTTON ID = 3
            markCell(pos);
        }
        lastPaintedPos = pos; // Animacijai
        isCurrentlyMarking = false;
    }

    @Override
    public void mouseDragged(MouseEvent e){ // Animacijai
        //System.out.print("MouseMoved method is being called\n");
        int[] pos = GameManager.getCellFromScreenCords(e.getX(), e.getY());
        if(lastPaintedPos != pos){
            // TODO: Magic
        }
    }

// Toliau spalvinimai

    private void paintGridWhite(){ // pradziai viska nuspalvinu baltai
        fillRect(0, 0, gridSize, gridSize, Color.lightGray);
        refresh(1);
    }

    private void paintCellDGray(int posX, int posY){
        fillRect(posY, posX, 1, 1, Color.darkGray);
        refresh(1);
    }

    private void paintCellDGray(int[]pos){
        paintCellDGray(pos[0], pos[1]);
    }

    private void revealCell(int[] pos){
        revealCell(pos[0], pos[1]);
    }

    private void revealCell(int i, int j){
        if(GameManager.gameMatrix[j][i].isOpen == false){
            switch(GameManager.gameMatrix[j][i].value){
                case -1:
                    setColors(Color.pink, Color.black);
                    print(j, i, 'B');
                    break;
                case 0:
                    /*setColors(Color.white, Color.black);
                    print(j, i, '0');*/
                    revealCellWithZero(i, j);
                    break;
                case 1:
                    setColors(Color.white, Color.green);
                    print(j, i,'1');
                    break;
                case 2:
                    setColors(Color.white, Color.cyan);
                    print(j, i, '2');
                    break;
                case 3:
                    setColors(Color.white, Color.blue);
                    print(j, i, '3');
                    break;
                case 4:
                    setColors(Color.white, Color.yellow);
                    print(j, i, '4');
                    break;
                case 5:
                    setColors(Color.white, Color.orange);
                    print(j, i, '5');
                    break;
                case 6:
                    setColors(Color.white, Color.magenta);
                    print(j, i, '6');
                    break;
                case 7:
                    setColors(Color.white, Color.red);
                    print(j, i, '7');
                    break;
                case 8:
                    setColors(Color.white, Color.black);
                    print(j, i, '8');
                    break;
            }
            GameManager.gameMatrix[j][i].isOpen = true;
            refresh(1);
        }
    }

    private void revealCellWithZero(int posX, int posY){
        if(posX >= gridSize || posY >= gridSize ||
                posX < 0 || posY < 0){ return; } // Checking if not out of bounds

        if(GameManager.gameMatrix[posY][posX].isOpen) { return; }

        // If cell is still closed, continues...
        if(GameManager.gameMatrix[posY][posX].value != 0){
            revealCell(posX, posY);
            return;
        }
        // If this cell is "zero"
        setColors(Color.white, Color.black);
        print(posY, posX, '0');
        GameManager.gameMatrix[posY][posX].isOpen = true;
        revealCellWithZero(posX+1, posY); // right
        revealCellWithZero(posX-1, posY); // left
        revealCellWithZero(posX, posY+1); // up
        revealCellWithZero(posX, posY-1); // down

        // not sure about this but my game will have it. (checking corners)
        revealCellWithZero(posX+1, posY+1); // bottom right
        revealCellWithZero(posX+1, posY-1); // top right
        revealCellWithZero(posX-1, posY+1); // bottom left
        revealCellWithZero(posX-1, posY-1); // top left

    }

    private void markCell(int[] pos) {
        markCell(pos[0], pos[1]);
    }

    private void markCell(int posX, int posY){
        setColors(Color.yellow, Color.black);
        print(posY, posX, 'X');
        refresh(1);
    }