Minesweeper game with three objects

Processing Coding Questions
1

Hello,

Im trying to make a kind of minesweeper game, but with 3 objects the player can find on the gameboard. I now have the code working to load 1 object into the game board. But i need all three objects placed on the gameboard. The object is loaded into the gameboard by void plaatsObjecten right now. The other objects are defined in the class Vakje. How can i fix that the three objects are placed into the game board without overlap each other?

Thank you!

int speelveldPosX, speelveldPosY;
int speelveldSizeX, speelveldSizeY;
int vakSize;
int gatSize;
int speelveldWidth, speelveldHeight;
Vakje[][] vakjes;
int legevakjes;
boolean lost, win;
int objecten;
//int aantalSpeelvakX;


void speelSchermStart() {
  spelerAanDeBeurt = 0;
  spelPauze = 0;
  //aantalSpeelvakX = aantalSpeelvak * 2;
  //speelveldSizeX = aantalSpeelvakX + 1;
  speelveldSizeX = aantalSpeelvak;
  speelveldSizeY = aantalSpeelvak;
  vakSize = schermSchaal/3;
  gatSize = 2;
  
  lost = false;
  win = false;

  speelveldWidth = speelveldSizeX * (vakSize + gatSize) - gatSize;
  speelveldHeight = speelveldSizeY * (vakSize + gatSize) - gatSize;

  maakVakjes();
}

void speelSchermMaken() {
    for (int j = 0; j < speelveldSizeY; j++) {
    for (int i = 0; i < speelveldSizeX; i++) {
      vakjes[i][j].show();
    }
    }
 
  if (spelPauze>0) {
    if (spelPauze==1) {
      eindeBeurt(speelveldSizeY, speelveldSizeX);
    }
    spelPauze--;
  }
  
  if (lost || win) {
    speelSchermRunning = false;
  }
}


void weergeven(int x, int y) {
  if (x < 0 || y < 0 || x >= speelveldSizeX || y >= speelveldSizeY) {
    return;
  }
  if (vakjes[x][y].isClicked()) {
    return;
  }
  
  vakjes[x][y].reveal();
  
  if(vakjes[x][y].getValue() == -1) {
    
    lost = true;
  } else {
    legevakjes--;
    if (legevakjes == 0) {
      win = true;
    }
  }
}

void maakVakjes() {
  vakjes = new Vakje[speelveldSizeX][speelveldSizeY];

  speelveldPosX = (int)(width / 2 - speelveldWidth / 2.0);
  speelveldPosY = (int)(height / 2 - speelveldHeight / 2.0);
  int x = speelveldPosX;
  int y = speelveldPosY;

  for (int j = 0; j < speelveldSizeY; j++) {
    for (int i = 0; i < speelveldSizeX; i++) {
      vakjes[i][j] = new Vakje(x, y, vakSize, vakSize);
      x += vakSize + gatSize;
    }
    x = speelveldPosX;
    y += vakSize + gatSize;
  }
  plaatsObjecten();
}

void plaatsObjecten() {
  objecten = (aantalDepots + aantalSchatten) + koning;
  legevakjes = (speelveldSizeX * speelveldSizeY) - objecten;
  int objectengeplaatst = 0;
  
  while(objectengeplaatst < objecten){
  int x = (int)random(speelveldSizeX);
  int y = (int)random(speelveldSizeY);
      if (vakjes[x][y].getValue() >= 0) {
        vakjes[x][y].plantObjecten();
        increaseNeighborValues(x, y);
        objectengeplaatst++;
      }
    }
}

void increaseNeighborValues(int x, int y) {
  for (int i = x - 1; i < x + 2; i++) {
    for (int j = y - 1; j < y + 2; j++) {
      if ( !(i == x && j == y) && i >= 0 && i < speelveldSizeX && j >= 0 && j < speelveldSizeY) {
        vakjes[i][j].increaseValue();
      }
    }
  }
}

class Vakje {
  private int x, y, breedte, hoogte;
  private int value; // -1 : bomb, 0 - 8 : number of adjacent bomb
  private boolean geklikt;
//  private boolean middle;

  Vakje (int x, int y, int w, int h) {
    this.x = x;
    this.y = y;
    breedte = w;
    hoogte = h;
    value = 0;
    geklikt = false;
  }

  void show() {
    noStroke();

    if (geklikt) {
      if (value == -1) {
        fill(kleurKoning); // -1 = de koning
        rect(x, y, breedte, hoogte);
        fill(200);
        textAlign(CENTER);
        textSize(hoogte * 0.9);
        text("K", x + breedte / 2, y + (hoogte / 2) + (0.73 * textAscent() / 2));
      } else if (value == -2){ // -2 =  schat
        aantalGevondenSchatten++;
        fill(kleurSchat);
        rect(x, y, breedte, hoogte);
        fill(200);
        textAlign(CENTER);
        textSize(hoogte * 0.9);
        text("S", x + breedte / 2, y + (hoogte / 2) + (0.73 * textAscent() / 2));
      } else if (value == -3) { // -3 = bommendepots
        aantalBommen++;
        fill(kleurDepot);
        rect(x, y, breedte, hoogte);
        fill(200);
        textAlign(CENTER);
        textSize(hoogte * 0.9);
        text("D", x + breedte / 2, y + (hoogte / 2) + (0.73 * textAscent() / 2));
      } else {
        aantalBommen--;
        fill(kleurLeegvak); // leeg vakje
        rect(x, y, breedte, hoogte);
      } 
    } else {
      fill(120);
      rect(x, y, breedte, hoogte);
      //fill(#0000CD);
      //rect(735, y, breedte, hoogte);
    }
  }
  
  
  boolean isClicked() {
    return geklikt;
  }
  
  //boolean isMiddle() {
  //  return middle;
  //}
  
  void reveal() {
    geklikt = true;
    //return value;
  }
  
  int getValue() {
    return value;
  }
  
  void plantObjecten() {
    value = -2;
  }
  
  void increaseValue() {
    if (value == -1) {
      return;
    }
    value += 1;
  }
}

//Berekent de speelscherm hoogt
int berekenSpeelSchermHoogte(int aantalVakjes) {
  int speelveldbreedte = width-schermSchaal*2;
  int spelbreedte;
  speelveldHoogte = aantalSpeelvak;
  do {
    speelveldHoogte++;
    speelvakSize = int(float(schermSchaal*3)/float(speelveldHoogte));
    spelbreedte = speelvakSize*(aantalVakjes/speelveldHoogte);
  } while (spelbreedte>speelveldbreedte);
  return speelveldHoogte;
}
2

what about something like

int gridCellSize;
int gridColumns;
int gridRows;
int[] grid;

void setup() {
  size(256, 256);
  gridCellSize = 32;  
  gridColumns = width / gridCellSize;
  gridRows = height / gridCellSize;
  grid = new int[gridColumns * gridRows];
  
  //assuming 0 is blank or standard or something like that
  int amountOfA = 10;
  int amountOfB = 5;
  int amountOfC = 25;
  int amountOfItems = amountOfA + amountOfB + amountOfC;
  for(int i = 0; i < amountOfItems; i++) {
    grid[i] = i < amountOfA ? 1 : i < amountOfA + amountOfB ? 2 : 3;
  }
  shuffleGrid();
}

void shuffleGrid() {
  int i, j, n;
  for (i = grid.length - 1; i > 0; i--) {
        j = floor(random(i + 1));
        n = grid[i];
        grid[i] = grid[j];
        grid[j] = n;
  }
}

void draw() {
 for(int y = 0; y < gridRows; y++) {
   for(int x = 0; x < gridColumns; x++) {
     text(grid[x + y * gridColumns], x * gridCellSize + gridCellSize / 2, y * gridCellSize + gridCellSize / 2);
   }
 }
}

i was just thinking about this you probably want to ensure that the amountOfItems doesn’t exceed the grid size. i didn’t do any checking for that.

1 Like