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)
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 trying to split my sentence on 'and' but some of the results looks like this
My code
string = 'I am handling it because it is difficult and confusing'
string.split('and')
Results
['I am h', 'ling it because it is difficult ', ' confusing']
I am trying to get this. How do I do it?
['I am handling it because it is difficult ', ' confusing']
Try doing
string.split(" and ")
It will only pick the word.
But if you need spaces, this function/loop will do(tested):
add_spaces(x):
x[0] += ' '
for i in range(1, len(x) - 1):
x[i] = ' ' + x[i]
x[i] += ' '
x[-1] = ' ' + x[-1]
class Board:
array = [[" ", " ", " "],
[" ", " ", " "],
[" ", " ", " "]]
def reset(self):
self.array = [[" ", " ", " "],
[" ", " ", " "],
[" ", " ", " "]]
class AI(Board):
def __init__(self):
self.array[0][0] = "X"
ai = AI()
board = Board()
print(ai.array) # [['X', ' ', ' '], [' ', ' ', ' '], [' ', ' ', ' ']]
print(board.array) # [['X', ' ', ' '], [' ', ' ', ' '], [' ', ' ', ' ']]
ai.reset()
print(ai.array) # [[' ', ' ', ' '], [' ', ' ', ' '], [' ', ' ', ' ']]
print(board.array) # [['X', ' ', ' '], [' ', ' ', ' '], [' ', ' ', ' ']]
My question is why board.array is changed while ai.array was. If they are connected to each other, why both the attributes are not changed together while the method belongs to AI is run.
This can be understood in the following manner:
When you get self.array to use or modify it, as in the expression self.array[0][0] = "X", then
first the instance is checked to see if it has such an attribute;
if it does not, the type of the instance is checked for the attribute.
(this is a simplification of what happens, but its all you need to know for this case)
When you set an instance, as you do in the expression self.array = [...] you are setting the attribute directly on the instance
So in your example code:
print(ai.array) # ai does not have an array, Board.array is returned
print(board.array) # board does not have an array, Board.array is returned
ai.reset() # this adds an attribute to ai
print(ai.array) # ai **does** have an array, it is returned
print(board.array) # board does not have an array, Board.array is returned
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
theBoard = {'top left': ' ', 'top middle': ' ', 'top right': ' ',
'center left': ' ', 'center middle': ' ', 'center right': ' ',
'bottom left': ' ', 'bottom middle': ' ', 'bottom right': ' '}
def printBoard(board):
print(board['top left'] + '|' + board['top middle'] + '|' + board['top right'])
print('-+-+-')
print(board['center left'] + '|' + board['center middle'] + '|' + board['center left'])
print('-+-+-')
print(board['bottom left'] + '|' + board['bottom middle'] + '|' + board['bottom right'])
turn = 'X'
for i in range (9):
printBoard(theBoard)
print('Turn for ' + turn + '.Move on which space?')
move = input()
theBoard[move] = turn
if turn == 'X':
turn = 'O'
else:
turn = 'X'
printBoard(theBoard)
I think you've just got your indentation wrong:
theBoard = {'top left': ' ', 'top middle': ' ', 'top right': ' ',
'center left': ' ', 'center middle': ' ', 'center right': ' ',
'bottom left': ' ', 'bottom middle': ' ', 'bottom right': ' '}
def printBoard(board):
print(board['top left'] + '|' + board['top middle'] + '|' + board['top right'])
print('-+-+-')
print(board['center left'] + '|' + board['center middle'] + '|' + board['center left'])
print('-+-+-')
print(board['bottom left'] + '|' + board['bottom middle'] + '|' + board['bottom right'])
turn = 'X'
for i in range (9):
printBoard(theBoard)
print('Turn for ' + turn + '.Move on which space?')
move = input()
theBoard[move] = turn
if turn == 'X':
turn = 'O'
else:
turn = 'X'
printBoard(theBoard)