Python Forum

Hello,

I'm just starting coding and I had a syntax error that I don't understand. I'm copying from a book and I checked the code in different code checker online. I checked the indentation and I checked on the internet but I can't find an answer.

Here's the code

#Memory




import random, pygame, sys
from pygame.locals import *

FPS = 30
WINDOWWIDTH = 640
WINDOWHEIGHT = 480
REVEALSPEED = 8
BOXSIZE = 40
GAPSIZE = 10
BOARDWIDTH = 10
BOARDHEIGHT = 7
assert(BOARDWIDTH * BOARDHEIGHT) % 2 == 0, 'Board needs to have an even number of boxes for pairs of matches.'
XMARGIN = int((WINDOWWIDTH - (BOARDWIDTH * (BOXSIZE + GAPSIZE))) / 2)
YMARGIN = int((WINDOWHEIGHT - (BOARDHEIGHT * (BOXSIZE + GAPSIZE))) / 2)


GRAY = ( 100, 100, 100)
NAVYBLUE = ( 60, 60, 100)
WHITE = ( 255, 255, 255)
RED = ( 255, 0, 0)
GREEN = ( 0, 255, 0)
BLUE = ( 0, 0, 255)
YELLOW = ( 255, 255, 0)
ORANGE = ( 255, 128, 0)
PURPLE = ( 255, 0, 255)
CYAN = ( 0, 255, 255)

BGCOLOR = NAVYBLUE
LIGHTBGCOLOR = GRAY
BOXCOLOR = WHITE
HIGHLIGHTCOLOR = BLUE

DONUT = 'donut'
SQUARE = 'square'
DIAMOND = 'diamond'
LINES = 'lines'
OVAL = 'oval'

ALLCOLORS = (RED, GREEN, BLUE, YELLOW, ORANGE, PURPLE, CYAN)
ALLSHAPES = (DONUT, SQUARE, DIAMOND, LINES, OVAL)
assert len(ALLCOLORS) * len(ALLSHAPES) * 2 >= BOARDWIDTH * BOARDHEIGHT, "Board is too big for the number of shapes/colors defined."

def main():
	global FPSCLOCK, DISPLAYSURF
	pygame.init()
	FPSCLOCK = pygame.time.Clock()
	DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))
	
	mousex = 0
	mousey = 0
	pygame.display.set_caption('Memory Game')
	mainBoard = getRandomizedBoard()
	revealedBoxes = generateRevealedBoxesData(False)
	
	mainBoard = [[(DONUT, BLUE), (LINES, BLUE), (SQUARE, ORANGE)], [(SQUARE, GREEN), (DONUT, BLUE), (DIAMOND, YELLOW)], [(SQUARE, GREEN), (OVAL, YELLOW), (SQUARE, ORANGE)], [(DIAMOND, YELLOW), (LINES, BLUE), (OVAL, YELLOW)]]
	firstSelection = NONE
	
	DISPLAYSURF.fill(BGCOLOR)
	startGameAnimation(mainBoard)
	
	while TRUE:
		mouseClicked = False
		
		DISPLAYSURF.fill(BGCOLOR)
		drawBoard(mainBoard, revealedBoxes)
		
		for event in pygame.event.get():
			if event.type ==QUIT or (event.type == KEYUP and event.key == K_ESCAPE):
				pygame.quit()
				sys.exit()
			elif event.type == MOUSEMOTION:
				mousex, mousey = event.pos
			elif event.type == MOUSEBUTTONUP:
				mousex, mousey = event.pos
				mouseClicked = True
	boxx, boxy = getBoxAtPixel(mousex, mousey)
	if boxx != None and boxy !=None:
		if not revealedBoxes[boxx][boxy]:
			drawHighlightBox(boxx, boxy)
			if not revealedBoxes[boxx][boxy] and mouseClicked:
				revealBoxesAnimation(mainBoard,[(boxx, boxy)])
				revealedBoxes[boxx][boxy] = True
				
				
				if firstSelection == None:
					firstSelection = (boxx, boxy)
				else:
					icon1shape, icon1color = getShapeAndColor(mainBoard, firstSelection[0], firstSelection[1])
					icon2shape,icon2color = getShapeAndColor(mainBoard, boxx, boxy)
					
					if iconshape != icon2shape or icon1color != icon2color:
					
						pygame.time.wait(1000)
						coverBoxesAnimation(mainBoard,[(firstSelection[0], firstSelection[1]), (boxx, boxy)])
						revealedBoxes[firstSelection[0]][firstSelection[1]] = False
						revealedBoxes[boxx][boxy] = False
					
					elif hasWon(revealedBoxes):
						gameWonAnimation(mainBoard)
						pygame.time.wait(2000)
						
						
						mainBoard = getRandomizedBoard()
						revealedBoxes = generateRevealedboxesData(False)
						
						
						drawBoard(mainBoard, revealedBoxes)
						pygame.display.update()
						pygame.time.wait(1000)
						
						
						startGameAnimation(mainBoard)
					firstSelection = None
					
	pygame.display.update()
	FPSCLOCK.tick(FPS)



def generateRevealedBoxesData(val):
	revealedBoxes = []
	for i in range(BOARDWIDTH):
		revealedBoxes.append([val] * BOARDHEIGHT)
	return revealedBoxes
	

def getrandomizedBoard():

	icons = []
	for color in ALLCOLORS:
		for shape in ALLSHAPES:
			icons.append((shape, color))
	random.shuffle(icons)
	numIconsUsed = int(BOARDWIDTH * BOARDHEIGHT/2)
	icons = icons[:numIconsUsed] * 2
	random.shuffle(icons)
	
	
	
	board = []
	for x in range(BOARDWIDTH):
		column = []
		for y in range(BOARDHEIGHT):
			column.append(icons[0])
			del icons[0]
		board.append(column)
	return board
	

def splitIntoGroupsOf(groupSize, theList):

	result = []
	for i in range(0, len(theList), groupSize):
		result.append(theList[i:i + groupSize])
	return result



def leftTopCoordsOfBox(boxx, boxy):

	left = boxx * (BOXSIZE + GAPSIZE) + XMARGIN
	top = Boxy * (BOXSIZE + GAPSIZE) + YMARGIN
	return(left, top)
	
	
def getBoxAtPixel(x, y):
	for boxx in range(BOARDWIDTH):
		for boxy in range(BOARDHEIGHT):
			left, top = leftTopCoordsOfBox(boxx, boxy)
			boxRect = pygame.Rect(left, top, BOXSIZE, BOXESIZE)
			if boxRect.collidepoint(x, y):
				return (boxx, boxy)
	return (None, None)
	
	
def drawIcon(shape, color, boxx, boxy):
	quarter = int(BOXSIZE * 0.25)
	half = int(BOXSIZE * 0.5)
	
	left, top = leftTopCoordsOfBox(boxx, boxy)
	
	if shape == DONUT:
		pygame.draw.circle(DISPLAYSURF, color, (left + half, top+ half), half = 5)
		pygame.draw.circle(DISPLAYSURF, BGCOLOR, (left + half, top + half), quarter - 5)
	elif shape == SQUARE:
		pygame.draw.rect(DISPLAYSURF, color, (left + quarter, top + quarter, BOXSIZE - half, BOXSIZE - half))
	elif shape == DIAMOND:
		pygame.draw.polygone(DISPLAYSURF, color, ((left + half, top), (left + BOXSIZE - 1, top + half), (left + half, top + BOXSIZE - 1), (left, top + half)))
	elif shape == LINES:
		for i in range(0, BOXSIZE, 4):
			pygame.draw.line(DISPLAYSURF, color, (left, top + i), (left + i, top))
			pygame.draw.line(DISPLAYSURF, color, (left + i, top + BOXSIZE - 1), (Left + BOXSIZE - 1, top + i))
	elif shape == OVAL:
		pygame.draw.ellipse(DISPLAYSURF, color, (left, top + quarter, BOXSIZE, half))
		
		
def getShapeAndColor(board, boxx, boxy):


	return board[boxx][boxy[0], board[boxx][boxy][1]
	

def drawBoxCovers(board, boxes, coverage):
	
	
	for box in boxes:
		left, top = leftTopCoordsOfBox(box[0], box[1])
		pygame.draw.rect(DISPLAYSURF, BGCOLOR, (left, top, BOXSIZE, BOXSIZE))
		shape, color = getShapeAndColor(board, box[0], box[1])
		drawIcon(shape, color, box[0], box[1])
		if coverage > 0:
			pygame.draw.rect(DISPLAYSURF, BOXCOLOR, (left, top, coverage, BOXSIZE))
	pygame.display.update()
	FPSCLOCK.tick(FPS)

def revealBoxesAnimation(board, boxesToReveal):

	for coverage in range(BOXSIZE, (-REVEALSPEED) -1, -REVEALSPEED):
		drawBoxCovers(board, boxesToReveal, coverage)

def coverBoxesAnimation(board, boxesToCover):

	for coverage in range(0, BOXSIZE + REVEALSPEED, REVEALSPEED):
		drawBoxCovers(board, boxesToCover, coverage)	
	
def drawBoard(board, revealed):

	for boxx in range(BOARDWIDTH):
		for boxy in range(BOXHEIGHT):
			left, top = leftTopCoordsOfBox(boxx, boxy)
			if not revealed[boxx][boxy]:
				pygame.draw.rect(DISPLAYSURF, BOXCOLOR, (left, top, BOXSIZE, BOXSIZE))
			else:
				shape, color = getShapeAndColor(board, boxx, boxy)
				drawIcon(shape, color, boxx, boxy)
				
def drawHighlightBox(boxx, boxy):
	left, top = leftTopCoordsOfBox(boxx, boxy)
	pygame.draw.rect(DISPLAYSURF, HIGHLIGHTCOLOR, (left -5, top - 5, BOXSIZE + 10, BOXSIZE + 10), 4)
	
def startgameAnimation(board):

	coveredBoxes = generateRevealedBoxesData(False)
	boxes = []
	for x in range(BOARDWIDTH):
		for y in range(BOARDHEIGHT);
			boxes.append((x, y))
	random.shuffle(boxes)
	boxeGroups = splitIntoGroupsOf(8, boxes)
	drawBoard(board, coveredBoxes)
	for boxgroup in boxGroups:
		revealBoxesAnimation(board, boxGroup)
		coverBoxesAnimation(board, boxgroup)
		
def gameWonAnimation(board):

	coveredBoxes = generateRevealedBoxesData(True)
	color1 = LIGHTBGCOLOR
	color2-BGCOLOR
	
	do i in range(13):
		color1, color2 = color2, color1
		DISPLAYSURF.fill(color1)
		drawBoard(board, coveredBoxes)
		pygame.display.update()
		pygame.time.wait(300)
		
def hasWon(revealedBoxes):

	for i in revealedBoxes:
		if False in i:
			return False
	return True

if __name__ == '__main__':
	main()

And this is the error I have

Error:
File "memory.py", line 208
    def drawBoxCovers(board, boxes, coverage):
    ^
SyntaxError: invalid syntax

I'm working on Python 3.8.5 (default, Jul 28 2020, 12:59:40)
[GCC 9.3.0] on linux

Keep in mind that I have been coding for only a month

thanks for your time

If you don't see any problem on that specific line, look at the code before it. In this case you don't have balanced brackets on the previous line.

return board[boxx][boxy^[0], board[boxx][boxy][1]
Missing "]" where indicated.

maybe you forgot a bracket in Line 205?

return board[boxx][boxy][0], board[boxx][boxy][1]

Thanks! but I have another problem...

Error:
Traceback (most recent call last):
  File "memory.py", line 280, in <module>
    main()
  File "memory.py", line 64, in main
    startGameAnimation(mainBoard)
  File "memory.py", line 256, in startGameAnimation
    revealBoxesAnimation(board, boxGroup)
  File "memory.py", line 223, in revealBoxesAnimation
    drawBoxCovers(board, boxesToReveal, coverage)
  File "memory.py", line 213, in drawBoxCovers
    shape, color = getShapeAndColor(board, box[0], box[1])
  File "memory.py", line 205, in getShapeAndColor
    return board[boxx][boxy][0], board[boxx][boxy][1]
IndexError: list index out of range

I went through the code and can't find anything that's wrong???

Can you help again?

Output:
return board[boxx][boxy][0], board[boxx][boxy][1]
IndexError: list index out of range

I think the len of board[boxx][boxy] is < 2 or has no values

I'm guessing that boxx or boxy are out of range. I would add some print statements to help find the error.

def getShapeAndColor(board, boxx, boxy):
    if boxx >= len(board) or boxy >= len(board[boxx]):
        print(f'getShapeAndColor(board, {boxx}, {boxy})')
        y_dimensions = [len(y) for y in board]
        print(f'board = {len(board)}x{y_dimensions}')
        return DONUT, BLUE
    if len(board[boxx][boxy]) < 2:
        print(f'getShapeAndColor(board, {boxx}, {boxy}) = {board[boxx][boxy]}')
        return DONUT, ORANGE
    return board[boxx][boxy][0], board[boxx][boxy][1]

I added the code you suggested(which I don't totally comprehend) and I received this error in return:

Error:
getShapeAndColor(board, 1, 6)
board = 4x[3, 3, 3, 3]
Traceback (most recent call last):
  File "memory.py", line 289, in <module>
    main()
  File "memory.py", line 64, in main
    startGameAnimation(mainBoard)
  File "memory.py", line 265, in startGameAnimation
    revealBoxesAnimation(board, boxGroup)
  File "memory.py", line 232, in revealBoxesAnimation
    drawBoxCovers(board, boxesToReveal, coverage)
  File "memory.py", line 223, in drawBoxCovers
    drawIcon(shape, color, box[0], box[1])
  File "memory.py", line 188, in drawIcon
    pygame.draw.circle(DISPLAYSURF, color, (left + half, top+ half), half = 5)
TypeError: function missing required argument 'radius' (pos 4)

Now like I said, I've just been coding for a couple of months. My understanding is pretty basic and I don't know what to do with this new information:

getShapeAndColor(board, 1, 6)
board = 4x[3, 3, 3, 3]

It means you have an error in your code.

print(f'getShapeAndColor(board, {boxx}, {boxy})')

is printing out

Output:
getShapeAndColor(board, 1, 6)

which means boxx == 1 and boxy == 6

We also know from this

Output:
board = 4x[3, 3, 3, 3]

That boxx can be in the range 0..3 but boxy can only be in the range 0..2.

Now you get to debug your code and find out where boxy is being set to an invalid index.

I am glad that Python provides a traceback when an exception is thrown, but for me at least the line that throws the exception is not where the error occurred. Most errors occur long before they result in something that causes your program to crash. I have a feeling that this is the case for your error. You'll have to follow the code backward, find where you are setting boxy, and determine how boxy is getting set to an invalid index.