I am wondering if I can make a table like shown with nested loops:
A B C D
+---+---+---+---+
1 | | | | |
+---+---+---+---+
2 | | | | |
+---+---+---+---+
3 | | | | |
+---+---+---+---+
4 | | | | |
+---+---+---+---+
This is my current code and results:
total_moves = 1
while total_moves <= 10:
print('Turn {}'.format(total_moves))
map = [ [' ', ' ', ' ', ' '],\
[' ', ' ', ' ', ' '],\
[' ', ' ', ' ', ' '],\
[' ', ' ', ' ', ' '] ]
for i in map:
print('\n' + '+---' * 4 + '+')
for j in i:
print('|{:^3}'.format(j), end = '')
print('|', end = '')
print('\n' + '+---' * 4 + '+')
chara = input('Please enter character to be added into box: ')
position = input('Please enter position where the character will be in: ')
Turn 1
+---+---+---+---+
| | | | |
+---+---+---+---+
| | | | |
+---+---+---+---+
| | | | |
+---+---+---+---+
| | | | |
+---+---+---+---+
Please enter character to be added into box:
Please enter position where the character will be in:
I am having issues with printing the numbers and alphabets, because I am relatively new to nested loops. Tried doing print( A B C D )but am looking for a better way to print it. Thank you!
Here is what I came up so far:
total_moves = 1
while total_moves <= 10:
print('Turn {}'.format(total_moves))
map = [ [' ', ' ', ' ', ' '],\
[' ', ' ', ' ', ' '],\
[' ', ' ', ' ', ' '],\
[' ', ' ', ' ', ' '] ]
columns = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P",\
"Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]
size = len(map)
cols_string = ""
for n in range(size):
cols_string += " {} ".format(columns[n])
print(cols_string, end="")
for idx, i in enumerate(map):
print('\n ' + '+---' * size + '+')
print(idx + 1, end=" ")
for j in i:
print('|{:^3}'.format(j), end = '')
print('|', end = '')
print('\n ' + '+---' * size + '+')
I added the columns list so that it can pick the column names depending on the size of the grid (assuming it won't be larger than 26x26).
Also added the size attribute so the display of the grid also adapts to the data.
I used enumerate to have the index of the line and print it in front of it.
One thing you'll have to figure out is how to properly display the cols_string because I didn't have the time to fix that.
Related
I jumped into some Python courses a little while ago and have gotten to a milestone project to make a simple tic-tac-toe game.
But I am running into a bit of a wall due to an index error that keeps happening and I cannot figure out why.
The code is the following:
#Tic Tac Toe
game_list = [' '] * 10
turn_counter = 0
game_on = True
def show_game(game_list):
print(' | |')
print(' ' + game_list[7] + ' | ' + game_list[8] + ' | ' + game_list[9])
print(' | |')
print('-----------')
print(' | |')
print(' ' + game_list[4] + ' | ' + game_list[5] + ' | ' + game_list[6])
print(' | |')
print('-----------')
print(' | |')
print(' ' + game_list[1] + ' | ' + game_list[2] + ' | ' + game_list[3])
print(' | |')
def choose_position():
# Initial Variables
within_range = False
acceptable_values = [1,2,3,4,5,6,7,8,9]
choice = 'WRONG'
# While loop that keeps asking for input
while choice.isdigit() == False or within_range == False:
choice = input("Please choose a number between 1-9 like a numpad: ")
# DIGIT CHECK
if choice.isdigit() == False:
print("Sorry, that is not a digit!")
# RANGE CHECK
if choice.isdigit() == True:
if int(choice) in acceptable_values:
within_range = True
else:
print("Sorry, you are out of the acceptable range (1-9)")
return int(choice)
def insert_choice(game_list, position, turn_counter):
print(type(position))
print(position)
# Place the character in the game_list
if turn_counter%2 == 0 or turn_counter == 0:
game_list[position] = 'X'
else:
game_list[position] = 'O'
return (game_list, position)
def gameon_choice():
choice = 'wrong'
while choice not in ['Y', 'N']:
choice = input("Keep playing? (Y or N) ")
if choice not in ['Y', 'N', 'R']:
print("sorry, I don't understand, please choose Y or N ")
if choice == 'Y':
return True
else:
return False
while game_on:
show_game(game_list)
position = choose_position()
game_list = insert_choice(game_list,position,turn_counter)
turn_counter += turn_counter
show_game(game_list)
game_on = gameon_choice()
And the error I get is:
Exception has occurred: IndexError
tuple index out of range
File "Desktop/Tictactoe.py", line 9, in show_game
print(' ' + game_list[7] + ' | ' + game_list[8] + ' | ' + game_list[9])
File "Desktop/Tictactoe.py", line 79, in <module>
show_game(game_list)
What I think is happening is that during the assignment in the insert_choice function:
game_list[position] = 'X'
the list is somehow converted to a tuple and the variables are appended instead of assigned, and then when trying to display the list again it only has two elements leading to an index error, but I cannot figure out /why/.
I hope someone can help.
Sincerely,
The insert_choice() method returns a tuple of your game_list and position:
return (game_list, position)
Thus, during your main loop, you store this tuple as the new game_list and try to access indices greater than 1 which leads to this index error.
You can either only return game_list or unpack the returned tuple as:
game_list, position = insert_choice(game_list,position,turn_counter)
Since you don't change the value of position, you probably want to do the former.
I am making a list where i can input items into a grid, but the input will only be accepted if it is beside each other in that list.
this is my current codes:
basket = [ [' ', ' ', ' ', ' '],\
[' ', ' ', ' ', ' '],\
[' ', ' ', ' ', ' '],\
[' ', ' ', ' ', ' '] ]
total_moves = 1
while total_moves <= 16:
columns = ["A", "B", "C", "D"]
cols_string = ""
for n in range(4):
cols_string += " {:2}".format(columns[n])
#printing table
print("",cols_string, end="")
for idx, i in enumerate(basket):
print('\n ' + '+-----' * 4 + '+')
print(idx + 1, end=" ")
for j in i:
print('|{:^5}'.format(j), end = '')
print('|', end = '')
print('\n ' + '+-----' * 4 + '+')
fruit = input('What fruit do you want to place?(APL/BNA/ORG): ')
build_location = input('Build where? ')
#processing build location for exact position
build_location = list(build_location)
if build_location[0] == 'A':
loc = [int(build_location[1])-1, 0]
elif build_location[0] == 'B':
loc = [int(build_location[1])-1, 1]
elif build_location[0] == 'C':
loc = [int(build_location[1])-1, 2]
elif build_location[0] == 'D':
loc = [int(build_location[1])-1, 3]
if build_location[1] == 'A':
loc = [int(build_location[0])-1, 0]
elif build_location[1] == 'B':
loc = [int(build_location[0])-1, 1]
elif build_location[1] == 'C':
loc = [int(build_location[0])-1, 2]
elif build_location[1] == 'D':
loc = [int(build_location[0])-1, 3]
if basket[loc[0]][loc[1]] == ' ':
basket[loc[0]][loc[1]] = fruit
total_moves += 1
else:
print('That slot is taken!')
This is my current print, without keying in any inputs yet:
A B C D
+-----+-----+-----+-----+
1 | | | | |
+-----+-----+-----+-----+
2 | | | | |
+-----+-----+-----+-----+
3 | | | | |
+-----+-----+-----+-----+
4 | | | | |
+-----+-----+-----+-----+
What fruit do you want to place?(APL/BNA/ORG): #input here
Build where? #input here
I am trying to make it such that, if I enter the fruit to be beside each other(for exampleA1 and B1), the fruit will be printed out, but if the fruits are not beside each other(for exampleA1 and B2), the system will printCannot place fruit there!. Can anyone help me with this?
A B C D
+-----+-----+-----+-----+
1 | APL | BNA | | |
+-----+-----+-----+-----+
2 | | ORG | | |
+-----+-----+-----+-----+
3 | | | | |
+-----+-----+-----+-----+
4 | | | | |
+-----+-----+-----+-----+
#code continues to run as the fruits are all connected to each other
A B C D
+-----+-----+-----+-----+
1 | | | | |
+-----+-----+-----+-----+
2 | | ORG | BNA | |
+-----+-----+-----+-----+
3 | | | | |
+-----+-----+-----+-----+
4 | | | | |
+-----+-----+-----+-----+
#code continues to run as fruits are connected
A B C D
+-----+-----+-----+-----+
1 | | | | |
+-----+-----+-----+-----+
2 | | | BNA | |
+-----+-----+-----+-----+
3 | | ORG | | |
+-----+-----+-----+-----+
4 | | | | |
+-----+-----+-----+-----+
#code will not run as BNA and ORG are not beside each other
A B C D
+-----+-----+-----+-----+
1 | APL | BNA | BNA | |
+-----+-----+-----+-----+
2 | | | | ORG |
+-----+-----+-----+-----+
3 | | | | |
+-----+-----+-----+-----+
4 | | | | |
+-----+-----+-----+-----+
#code will not run for ORG's input as ORG is not connected to the rest of the fruits,
so system will print 'Cannot place fruit here!' and ask user to place it again, only
continuing if ORG is at D1 or C2
This means for the first run, the code will accept any inputs, but for the second run onwards the code will only accept inputs which are beside the first input.
Your code seems very neat so far and I really like your idea! Here's the implementation I came up with so far so that fruits can only be placed directly adjacent (not diagonally) to other fruits:
basket = [ [' ', ' ', ' ', ' '],\
[' ', ' ', ' ', ' '],\
[' ', ' ', ' ', ' '],\
[' ', ' ', ' ', ' '] ]
total_moves = 1
placed = [] #new
def valid(build_location, placed): #new
for loc in placed:
if abs(ord(loc[0]) - ord(build_location[0])) == 1 and loc[1] == build_location[1]:
return True
if abs(ord(loc[1]) - ord(build_location[1])) == 1 and loc[0] == build_location[0]:
return True
if len(placed) == 0:
return True
return False
while total_moves <= 16:
columns = ["A", "B", "C", "D"]
cols_string = ""
for n in range(4):
cols_string += " {:2}".format(columns[n])
#printing table
print("",cols_string, end="")
for idx, i in enumerate(basket):
print('\n ' + '+-----' * 4 + '+')
print(idx + 1, end=" ")
for j in i:
print('|{:^5}'.format(j), end = '')
print('|', end = '')
print('\n ' + '+-----' * 4 + '+')
fruit = input('What fruit do you want to place?(APL/BNA/ORG): ')
build_location = input('Build where? ')
#processing build location for exact position
build_location = list(build_location)
if valid(build_location, placed): #new
placed.append(build_location)
if build_location[0] == 'A':
loc = [int(build_location[1])-1, 0]
elif build_location[0] == 'B':
loc = [int(build_location[1])-1, 1]
elif build_location[0] == 'C':
loc = [int(build_location[1])-1, 2]
elif build_location[0] == 'D':
loc = [int(build_location[1])-1, 3]
if build_location[1] == 'A':
loc = [int(build_location[0])-1, 0]
elif build_location[1] == 'B':
loc = [int(build_location[0])-1, 1]
elif build_location[1] == 'C':
loc = [int(build_location[0])-1, 2]
elif build_location[1] == 'D':
loc = [int(build_location[0])-1, 3]
if basket[loc[0]][loc[1]] == ' ':
basket[loc[0]][loc[1]] = fruit
total_moves += 1
else: #new
print('That spot is taken!')
else: #new
print('Can not place fruit there!')
Let me explain the code now:
First, I created an array to store the positions of fruit that have already been placed. For simplicity, I altered the code so that it would only accept positions that are placed like (A1, B2, C2, D4) and not (1A, 2B, 2C, 4D).
Next, I created a function that verifies whether or not the position is valid. This is done by looping through the array and comparing it to other fruits. If the difference in letters is 1 AND the numbers are the same, it is valid. If the difference in numbers is 1 AND the letters are the same, it is valid.
Additionally, there is an if statement at the bottom of the code that makes sure it does not overlap another fruit and gives a separate error message.
Let me know if you have any other questions!
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 2 years ago.
Improve this question
So I am trying to create a dungeon type game for my assignment. But I have no clue how to create a map like that with a nested list? Any help would be appreciated.
Example of the map:
+---+---+---+---+---+---+---+---+
| T | | | | | | | |
+---+---+---+---+---+---+---+---+
| | | | T | | | | |
+---+---+---+---+---+---+---+---+
| | | | | | T | | |
+---+---+---+---+---+---+---+---+
| | T | | | | | | |
+---+---+---+---+---+---+---+---+
| | | | | | | | |
+---+---+---+---+---+---+---+---+
| | | | | | | | |
+---+---+---+---+---+---+---+---+
| | | | | T | | | |
+---+---+---+---+---+---+---+---+
| | | | | | | | K |
+---+---+---+---+---+---+---+---+
The list:
world_map = [['T', ' ', ' ', ' ', ' ', ' ', ' ', ' '],\
[' ', ' ', ' ', 'T', ' ', ' ', ' ', ' '],\
[' ', ' ', ' ', ' ', ' ', 'T', ' ', ' '],\
[' ', 'T', ' ', ' ', ' ', ' ', ' ', ' '],\
[' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '],\
[' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '],\
[' ', ' ', ' ', ' ', 'T', ' ', ' ', ' '],\
[' ', ' ', ' ', ' ', ' ', ' ', ' ', 'K']]
Here what I have:
current_row = 0
current_column = 0
def View_Map():
for i in world_map:
world_map[current_row][current_column] = "H/T"
print(i)
The output I get:
You can use string formatting to print this, you would need to print
for each line in your data a header ('+---+- etc -+---+'))
for each cell in your data a value V ('+ V +')
a end line after all of them ('+---+- etc -+---+'))
Header and cells would need to adapt to the maximal widht of all cell contents to get an even looking map.
You can do it like this:
m = [['T', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
[' ', ' ', ' ', 'T', ' ', ' ', ' ', ' '],
[' ', ' ', ' ', ' ', ' ', 'T', ' ', ' '],
[' ', 'T', ' ', ' ', ' ', ' ', ' ', ' '],
[' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
[' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
[' ', ' ', ' ', ' ', 'T', ' ', ' ', ' '],
[' ', ' ', ' ', ' ', ' ', ' ', ' ', 'K']]
def print_map(data):
"""Prints a list of lists, puts data centered
into each boxand pads other boxes accordingly. """
# max widht of all elelemts to be printed
max_w = max(len(o) for l in data for o in l)
# fitting header
header = f"+-{'-' * max_w}-" * len(data[0]) + "+"
for line in data:
print(header)
print("+", end="")
for char in line:
# center format each "box"
print(f" {char:^{max_w}} +", end="")
print()
print(header)
print_map(m)
Output:
+---+---+---+---+---+---+---+---+
+ T + + + + + + + +
+---+---+---+---+---+---+---+---+
+ + + + T + + + + +
+---+---+---+---+---+---+---+---+
+ + + + + + T + + +
+---+---+---+---+---+---+---+---+
+ + T + + + + + + +
+---+---+---+---+---+---+---+---+
+ + + + + + + + +
+---+---+---+---+---+---+---+---+
+ + + + + T + + + +
+---+---+---+---+---+---+---+---+
+ + + + + + + + K +
+---+---+---+---+---+---+---+---+
If you have a "non-1-character-content" the code will space out the other cells as needed:
+-------+-------+-------+-------+-------+-------+-------+-------+
+ T + + + + + + + +
+-------+-------+-------+-------+-------+-------+-------+-------+
+ + + + TTTTT + + + + +
+-------+-------+-------+-------+-------+-------+-------+-------+
+ + + + + + T + + +
+-------+-------+-------+-------+-------+-------+-------+-------+
+ + T + + + + + + +
+-------+-------+-------+-------+-------+-------+-------+-------+
+ + + + + + + + +
+-------+-------+-------+-------+-------+-------+-------+-------+
+ + + + + + + + +
+-------+-------+-------+-------+-------+-------+-------+-------+
+ + + + + T + + + +
+-------+-------+-------+-------+-------+-------+-------+-------+
+ + + + + + + + K +
+-------+-------+-------+-------+-------+-------+-------+-------+
Lookup string format mini language for centering text
i'm making a small project in python that is tic tac toe game but i'm facing a problem here is my code though it is incomplete
now my problem is while running my code , i'm getting error 'position' is not defined
please solve my problem and thanks in advance !!
def display_board(testboard):
print(' | | ')
print(' '+testboard[1]+' | '+testboard[2]+' | '+testboard[3])
print(' | | ')
print('------------')
print(' | | ')
print(' ' + testboard[4] + ' | ' + testboard[5] + ' | ' +
testboard[6])
print(' | | ')
print('------------')
print(' | | ')
print(' ' + testboard[7] + ' | ' + testboard[8] + ' | ' +
testboard[9])
print(' | | ')
def board_marker():
marker = ' '
while not (marker == 'X' or marker =='O' or marker == 'x' or marker
=='o'):
marker = input('do you want x r o')
if marker.upper() == 'X' :
return ('X','O')
else:
return ('O','X')
def place_marker(board, position, marker):
board[positon] = marker
test_board= ['#','X','O','X','O','X','O','X','O','X','O']
place_marker(test_board, , '$')
display_board(test_board)
Try this:
def display_board(testboard):
print(' | | ')
print(' '+testboard[1]+' | '+testboard[2]+' | '+testboard[3])
print(' | | ')
print('------------')
print(' | | ')
print(' ' + testboard[4] + ' | ' + testboard[5] + ' | ' +
testboard[6])
print(' | | ')
print('------------')
print(' | | ')
print(' ' + testboard[7] + ' | ' + testboard[8] + ' | ' +
testboard[9])
print(' | | ')
def board_marker():
marker = ' '
while not (marker == 'X' or marker =='O' or marker == 'x' or marker =='o'):
marker = input('do you want x r o')
if marker.upper() == 'X' :
return ('X','O')
else:
return ('O','X')
def place_marker(board, position, marker):
board[position] = marker # make it position here from positon as Nicco Haase said
test_board= ['#','X','O','X','O','X','O','X','O','X','O']
place_marker(test_board, 1, '$') # pass a value for position too don't keep it empty
display_board(test_board)
Hope this helps...
Thanks
I am a beginner at python and I am attempting to create a simple game. I am struggling to create a function that is required to take in zero arguments and returns a grid which contains randomly placed explosives.
As a general requirement, there should be a ten percent chance of getting a mine.
This is my code so far, but I'm struggling to figure out where to go from here. I also don't really understand the ten percent chance of placing a mine requirement because I thought there would have to be 10 different boxes? If someone could help push me in the right direction, I'd really appreciate it.
def mines():
gridSize = 3
createGrid = [[' ' for i in range(gridSize)] for i in range(gridSize)]
return createGrid
print(initMines())
All of these answers were really helpful, thanks! :)
Using the random library, you can use randint to get your 1 in 10 chance, and implement via an if statement
import random
GRIDSIZE = 3
CHANCE = 10
def mines():
createGrid = [[("x" if random.randint(0, CHANCE) == 0 else " ") for i in range(GRIDSIZE)] for i in range(GRIDSIZE)]
return createGrid
print(mines())
Output example
[['x', ' ', ' '], [' ', ' ', ' '], [' ', ' ', ' ']]
Edit: I have added global constants for the grid size and chance based on your question, however I would pass these as parameters if I were you.
I'm not most familiar with Python, so sorry if things don't quite work, but from the looks of things you're looking at making a 2d array, and then filling them with either an empty string "" or a mine "x", based on probability.
Based on the first answer here, you're mostly on the right track with initialising the array, though you may have to make the two "i"s different (given they represent "coordinates" in an array I'd suggest x and y)
createGrid = [[' ' for x in range(gridSize)] for y in range(gridSize)]
You then need to populate the array, and the way I'd suggest you do this would be using nested for loops as shown below:
for i in range(gridSize)
for j in range(gridSize)
createGrid[i][j] = //code for mine/empty
This will loop through all values in the array, and then update them based on whether or not it should contain a mine or be empty.
To decide whether or not it should be a mine, your best bet would probably be to import the random module, and use either the randint function or the random function, and then use an if statement to determine whether or not it should be a mine.
(The if statement goes within the for loops, the import happens before anything else in your code)
e.g.
import random
if random.randint(0, 10) <= 1
createGrid[i][j] = "x"
Hope that makes sense and is helpful!
For a 1/10 chance of a mine, you can just use something like (remembering to import random):
opts = "M........."
[[random.choice(opts) for c in range(gridSize)] for r in range(gridSize)]
It just chooses one of the characters from the string, which happens to have a 10% chance of getting a mine.
Using that in a complete program, and making it more configurable:
import random
def mines(gsz, pct):
# Silently enforce int 0-100, create choices, then choose.
pct = max(0, min(100, int(pct)))
opts = "M" * pct + ' ' * (100 - pct)
return [[random.choice(opts) for i in range(gsz)] for i in range(gsz)]
# Test harness. First, create a grid.
sz = 10
grid = mines(sz, 20)
# Then dump it for confirmation.
for line in grid: print(line)
mineCount = sum([cell == 'M' for row in grid for cell in row])
print('\nActual percentage was', 100 * mineCount / sz / sz)
shows it in action:
[' ', ' ', 'M', ' ', ' ', ' ', 'M', ' ', ' ', ' ']
['M', ' ', ' ', ' ', 'M', ' ', ' ', ' ', ' ', ' ']
['M', ' ', ' ', ' ', 'M', 'M', ' ', ' ', ' ', ' ']
[' ', 'M', 'M', ' ', ' ', ' ', ' ', ' ', ' ', ' ']
[' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ']
['M', ' ', ' ', ' ', ' ', 'M', ' ', ' ', ' ', ' ']
['M', ' ', ' ', ' ', ' ', ' ', 'M', 'M', ' ', ' ']
[' ', ' ', 'M', ' ', 'M', ' ', 'M', ' ', ' ', 'M']
[' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ']
[' ', ' ', ' ', ' ', ' ', ' ', 'M', ' ', ' ', ' ']
Actual percentage was 19.0
In case you want guaranteed number of mines you could do this:
import random
def chunks(l, n):
"""Yield successive n-sized chunks from l."""
for i in range(0, len(l), n):
yield l[i:i + n]
size = int(input('Enter length of row: '))
# By default 1/size of cells will be mines.
mines = (size**2)//size
# There is probably a better way to get user input, but this will do.
try:
mines = int(input('Enter number of mines [default=%s]: ' % mines))
except:
mines = (size**2)//size
# Make an one dimensional list of size square.
field_1d = [' ']*(size**2)
# Stick the mines into the list.
for m in range(mines):
field_1d[m] = '*'
# Randomly place the mines.
random.shuffle(field_1d)
# Make a 2D list out of the 1D list.
field = [r for r in chunks(field_1d,size)]
# Display it.
for row in field:
print(row)
Here is the output:
$ ./minesweeper.py
Enter length of row: 3
Enter number of mines [default=3]: 1
[' ', ' ', ' ']
[' ', '*', ' ']
[' ', ' ', ' ']
$ ./minesweeper.py
Enter length of row: 10
Enter number of mines [default=10]:
[' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ']
[' ', ' ', '*', ' ', ' ', '*', ' ', ' ', ' ', ' ']
[' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ']
[' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ']
[' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ']
[' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ']
[' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ']
[' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ']
[' ', '*', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*']
[' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ']
Sorry I could resist. I went ahead and wrote a complete minesweeper game:
import random
class Cell():
def __init__(self,i,j,field):
self.i = i
self.j = j
self.exposed = False
self.field = field
self.value = self.calc_value()
def display(self):
if self.exposed:
return self.value
return '_'
def expose(self):
self.exposed = True
def calc_value(self):
i = self.i
j = self.j
f = self.field
if self.field[i][j] == '*':
return '*'
v=0
try:
if f[i-1][j-1] == '*':
v += 1
except:
pass
try:
if f[i-1][j] == '*':
v += 1
except:
pass
try:
if f[i-1][j+1] == '*':
v += 1
except:
pass
try:
if f[i][j-1] == '*':
v += 1
except:
pass
try:
if f[i][j+1] == '*':
v += 1
except:
pass
try:
if f[i+1][j-1] == '*':
v += 1
except:
pass
try:
if f[i+1][j] == '*':
v += 1
except:
pass
try:
if f[i+1][j+1] == '*':
v += 1
except:
pass
return str(v)
def chunks(l, n):
"""Yield successive n-sized chunks from l."""
for i in range(0, len(l), n):
yield l[i:i + n]
size = int(input('Enter size of field: '))
# 1/10th of cells will be mines.
mines = (size**2)//size
try:
mines = int(input('Enter number of mines [default=%s]: ' % mines))
except:
mines = (size**2)//size
# Make an one dimensional list of size square.
field_1d = [' ']*(size**2)
# Stick the mines into the list.
for m in range(mines):
field_1d[m] = '*'
# Randomly place the mines.
random.shuffle(field_1d)
# Make a 2D list out of the 1D list.
field = [r for r in chunks(field_1d,size)]
# Display it.
for row in field:
print(row)
board_1d = []
for i in range(size):
for j in range(size):
print(i,j)
board_1d.append(Cell(i,j,field))
board = [r for r in chunks(board_1d,size)]
def display(board):
for i in range(size):
for j in range(size):
print(board[i][j].display(), end='|')
print("")
def win(board):
unexposed = 0
for i in range(size):
for j in range(size):
if board[i][j].exposed == False:
unexposed += 1
if unexposed == mines:
print('WINNER!!!!')
return True
return False
gameover = False
while not gameover:
display(board)
I = int(input('Enter I: '))
J = int(input('Enter J: '))
c = board[I][J]
c.expose()
if c.value == '*':
print("BOOM!")
gameover = True
gameover = win(board)
display(board)