A few days ago someone posted a clever bubble-wrap “mini-game” on Discord.

Bubble Wrap

It was posted on a private server and my spouse ask me to forward that to them, but it worked with Discord’s spoiler-tag feature and if I waned to copy-paste it, the content I get was the content without spoiler-tags.

No problem, I’m an engineer. In seconds I crafted a quick python script that’s able to generate an NxN bubble-wrap for Discord.

print("Anyone want some bubble wrap?")
size = 8
print("\n".join(["||pop||" * size] * size))

The first line is important because The first line is always contains the display name of the user who sent the message so it would look terrible without the initial “spam text”.

We can do more

A few minutes later someone wrote

Popping this feels like playing Minesweeper without hitting a bomb xD

And, that’s it, it was something, something interesting. What do we need?

First of all, we need math and random, because we want to place mines on random positions and if we want to determine the number of mines based on a given percentage of the grid, we have to use one of them: round, ceil, floor.

Obviously, we need a function that can wrap a string in spoiler-tags (on Discord it’s ||hide me||).

import math
import random

def hide(content):
    return f'||{content}||'

Next thing to build is the grid itself and place some mines on in.

BOMB_MARK = 'X'
size = 8
number_of_bombs = math.ceil(size*size * 0.2)
grid = " " * size * size

bombs = set()
while len(bombs) < number_of_bombs:
    bombs.add(random.randint(0, size*size - 1))

for i in bombs:
    grid = grid[:i] + BOMB_MARK + grid[i+1:]

That’s it, we have a size * size grid with 20% mines on it. We used set so while we generate random numbers, we can store them in the bombs set and we don’t have to care about duplications. It’s an easy way to generate N random numbers without duplications.

What next? We have to update all cells without a mine with a number that reflects how many adjacent mines it has.

So if our grid looks like this:

___
__B
B__

We want to update all cells to look like this:

_11
12B
B21

First real problem we just met, how to count them. Because we are using a single string to represent the while grid, the easiest way is to simply check all possible adjacent cells. For that (for readability) we can use a simple matrix-like array with all the possible cells relative to a given cell.

# (x, y)
search_matrix = [
        (-1, -1), (-1, 0), (-1, 1),
        ( 0, -1),          ( 0, 1),
        ( 1, -1), ( 1, 0), ( 1, 1)
        ]

Now we can simply iterate through our grid and we can calculate position with:

  • x2 = index + x1
  • y2 = index + y1 * size
for i, c in enumerate(grid):
  # if it's a bomb, we can skip
  if c == BOMB_MARK:
    continue
  mines_around = [grid[i+p+(q*size)] == BOMB_MARK for (p, q) in search_matrix]

It seems logical, but we will get a huge error when we are trying to reach indexes out of range, so we have to check if a given index is possible at all or not. We can introduce a simple function to check if it’s possible or not:

def possible(grid, i, p, q):
    v = i+p+(q*size)

    if v < 0 or v >= len(grid):
        return False

    return True

With this new function, we can fix out problem. At the same time we can convert our results to numbers:

for i, c in enumerate(grid):
  # if it's a bomb, we can skip
  if c == BOMB_MARK:
    continue
  mines_around = len(list(filter(None, [
      grid[i+p+(q*size)] == BOMB_MARK
          for (p, q) in search_matrix
          if possible(grid, i, p, q)])))
  # Update the cell if it's not 0
  if mines_around > 0:
      grid = grid[:i] + str(mines_around) + grid[i+1:]

It’s not obvious first, but this code still have a small bug. It counts adjacent cells through new-line, which is not the case we want, fortunately we can extend our possible function with a simple logic that checks if the calculated row is in the same row as our target row.

def possible(grid, i, p, q):
    v = i+p+(q*size)

    if v < 0 or v >= len(grid):
        return False

    return (v // size) == ((i + (q*size)) // size)

And now, we are ready to render our grid.

for i in range(0, len(grid), size):
    print("".join([hide(c) for c in grid[i:i+size]]))

Characters have no fixed width, we have to find something with fixed width. What can we use? Emojis:

  • bomb for a mine
  • white_large_square for an empty cell
  • one -> eight for numbers
# This function is here only because
# Hugo has no ability to disable emoji conversion per page
# and I did not find a better solution to write ": bomb :"
# without spaces and without auto-convert it to "💣"
def wrap(s):
  return f':{s}:'

def to_emoji(char):
    if char == BOMB_MARK:
        return wrap("bomb")
    if char == " ":
        return wrap("white_large_square")
    numbers = [
            "one", "two", "three",
            "four", "five", "six",
            "seven", "eight"
            ]
    return wrap(numbers[int(char)-1])

We are ready to render the final grid, and now we add a spam-text line too, to be sure it’s not messed up when we post it on Discord.

print("Shall we play a game?")

for i in range(0, len(grid), size):
    print("".join([hide(to_emoji(c)) for c in grid[i:i+size]]))

Minesweeper results

Full Source

import math
import random

def hide(content):
    return f'||{content}||'

def possible(grid, i, p, q):
    v = i+p+(q*size)

    if v < 0 or v >= len(grid):
        return False

    return (v // size) == ((i + (q*size)) // size)

# This function is here only because
# Hugo has no ability to disable emoji conversion per page
# and I did not find a better solution to write ": bomb :"
# without spaces and without auto-convert it to "💣"
def wrap(s):
  return f':{s}:'

def to_emoji(char):
    if char == BOMB_MARK:
        return wrap("bomb")
    if char == " ":
        return wrap("white_large_square")
    numbers = [
            "one", "two", "three",
            "four", "five", "six",
            "seven", "eight"
            ]
    return wrap(numbers[int(char)-1])

BOMB_MARK = 'X'
size = 8
number_of_bombs = math.ceil(size*size * 0.2)
grid = " " * size * size

bombs = set()
while len(bombs) < number_of_bombs:
    bombs.add(random.randint(0, size*size - 1))

for i in bombs:
    grid = grid[:i] + BOMB_MARK + grid[i+1:]

# (x, y)
search_matrix = [
        (-1, -1), (-1, 0), (-1, 1),
        ( 0, -1),          ( 0, 1),
        ( 1, -1), ( 1, 0), ( 1, 1)
        ]

for i, c in enumerate(grid):
    # if it's a bomb, we can skip
  if c == BOMB_MARK:
      continue
  mines_around = len(list(filter(None, [
      grid[i+p+(q*size)] == BOMB_MARK
      for (p, q) in search_matrix
      if possible(grid, i, p, q)])))
  # Update the cell if it's not 0
  if mines_around > 0:
      grid = grid[:i] + str(mines_around) + grid[i+1:]

print("Shall we play a game?")

for i in range(0, len(grid), size):
    print("".join([hide(to_emoji(c)) for c in grid[i:i+size]]))