'.....',

'..O..',

'.....',

#cause I don't want to pass these around

global WINDOW, REN, SPRITE_FACTORY, SPRITE_RENDERER, MUSIC

SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO)

WINDOW = ext.Window("Tetromino for Idiots", size=(WINDOWWIDTH, WINDOWHEIGHT))

REN = ext.Renderer(WINDOW)

WINDOW.show()

font_file = sysfont.get_font("freesans", sysfont.STYLE_BOLD)

font_manager = ext.FontManager(font_file, size=18)

#fontmanager=font_manager will be default_args passed to every sprite creation method

SPRITE_FACTORY = ext.SpriteFactory(renderer=REN, fontmanager=font_manager, free=True)

SPRITE_RENDERER = SPRITE_FACTORY.create_sprite_render_system(WINDOW)

sdlmixer.Mix_Init(sdlmixer.MIX_INIT_OGG)

sdlmixer.Mix_OpenAudio(22050, sdlmixer.MIX_DEFAULT_FORMAT, 2, 1024)

#BEEP1 = sdlmixer.Mix_LoadWAV(b"beep1.ogg")

showTextScreen("Tetromino for Idiots")

while True:

if random.randint(0, 1) == 0:

MUSIC = sdlmixer.Mix_LoadMUS(b"tetrisb.mid")

else:

MUSIC = sdlmixer.Mix_LoadMUS(b"tetrisc.mid")

sdlmixer.Mix_PlayMusic(MUSIC, -1)

runGame()

sdlmixer.Mix_HaltMusic()

#setup variables for start of game

board = getBlankBoard()

lastMoveDownTime = SDL_GetTicks()

lastMoveSidewaysTime = lastMoveDownTime

lastFallTime = lastMoveDownTime

score = 0

level, fallFreq = calculateLevelAndFallFreq(score)

fallingPiece = None

nextPiece = getNewPiece()

keylen = ctypes.c_int()

kybd_st = SDL_GetKeyboardState(ctypes.byref(keylen))

while True:

starttime = SDL_GetTicks()

if fallingPiece == None:

fallingPiece = nextPiece

nextPiece = getNewPiece()

lastFallTime = SDL_GetTicks()

if not isValidPos(board, fallingPiece):

return

for event in ext.get_events():

if event.type == SDL_QUIT:

shutdown()

elif event.type == SDL_KEYUP:

sc = event.key.keysym.scancode

if sc == SDL_SCANCODE_ESCAPE:

shutdown()

elif sc == SDL_SCANCODE_P:

#Pausing the game

REN.clear(BGCOLOR)

sdlmixer.Mix_PauseMusic()

showTextScreen("Paused") # pause till keypress

sdlmixer.Mix_ResumeMusic()

tmp = SDL_GetTicks()

#reseting these is necessary though lastFallTime might help them a bit

starttime = tmp

lastMoveDownTime = tmp

lastMoveSidewaysTime = tmp

lastFallTime = tmp

#rotate

elif sc == SDL_SCANCODE_UP or sc == SDL_SCANCODE_W:

fallingPiece['rotation'] = (fallingPiece['rotation'] + 1) % len(PIECES[fallingPiece['shape']])

if not isValidPos(board, fallingPiece):

fallingPiece['rotation'] = (fallingPiece['rotation'] - 1) % len(PIECES[fallingPiece['shape']])

#rotate other way

elif sc == SDL_SCANCODE_Q:

fallingPiece['rotation'] = (fallingPiece['rotation'] - 1) % len(PIECES[fallingPiece['shape']])

if not isValidPos(board, fallingPiece):

fallingPiece['rotation'] = (fallingPiece['rotation'] + 1) % len(PIECES[fallingPiece['shape']])

# move piece all the way down

elif sc == SDL_SCANCODE_SPACE:

for i in range(1, BOARDHEIGHT):

if not isValidPos(board, fallingPiece, adj_y=i):

break

fallingPiece['y'] += i-1

if is_moving_left(kybd_st) or is_moving_right(kybd_st) and SDL_GetTicks() - lastMoveSidewaysTime > MOVESIDEWAYSFREQ:

if is_moving_left(kybd_st) and isValidPos(board, fallingPiece, adj_x=-1):

fallingPiece['x'] -= 1

elif is_moving_right(kybd_st) and isValidPos(board, fallingPiece, adj_x=1):

fallingPiece['x'] += 1

lastMoveSidewaysTime = SDL_GetTicks()

if is_moving_down(kybd_st) and SDL_GetTicks() - lastMoveDownTime > MOVEDOWNFREQ and isValidPos(board, fallingPiece, adj_y=1):

fallingPiece['y'] += 1

lastMoveDownTime = SDL_GetTicks()

# let piece fall if it's time to fall

if SDL_GetTicks() - lastFallTime > fallFreq:

# see if piece has landed

if not isValidPos(board, fallingPiece, adj_y=1):

print(fallingPiece)

addToBoard(board, fallingPiece)

score += removeCompleteLines(board)

level, fallFreq = calculateLevelAndFallFreq(score)

fallingPiece = None

else:

fallingPiece['y'] += 1

lastFallTime = SDL_GetTicks() #replace all these calls with variable set at top of loop?

#draw everything

REN.clear(BGCOLOR)

#REN.fill((0,0,WINDOWWIDTH,WINDOWHEIGHT), BGCOLOR)

#REN.fill((XMARGIN - 3, 0, (BOARDWIDTH * BOXSIZE) + 8, WINDOWHEIGHT), BGCOLOR)

drawBoard(board)

if fallingPiece:

drawPiece(fallingPiece)

drawStatus(score, level, nextPiece)

REN.present()

sdlmixer.Mix_CloseAudio()

#ext.quit()

SDL_Quit()

sys.exit()

# This function displays large text in the

# center of the screen until a key is pressed.

# Draw the text drop shadow

shadowtext = SPRITE_FACTORY.from_text(text, size=BIGFONTSIZE, color=TEXTSHADOWCOLOR)

shadowtext.position = WINDOWWIDTH//2 - shadowtext.size[0]//2, WINDOWHEIGHT//2 - shadowtext.size[1]//2

# Draw the text

textsprite = SPRITE_FACTORY.from_text(text, size=BIGFONTSIZE, color=TEXTCOLOR)

textsprite.position = shadowtext.x-2, shadowtext.y-2

# Draw the additional "Press a key to play." text.

presskeysprite = SPRITE_FACTORY.from_text("Press a key to play.", color=TEXTCOLOR)

presskeysprite.position = WINDOWWIDTH//2-presskeysprite.size[0]//2, shadowtext.y + 100

SPRITE_RENDERER.render([shadowtext, textsprite, presskeysprite])

REN.present()

while checkForKeyPress() == None:

pass

for event in ext.get_events():

if event.type == SDL_QUIT:

shutdown()

elif event.type == SDL_KEYUP:

sc = event.key.keysym.scancode

if sc == SDL_SCANCODE_ESCAPE:

shutdown()

# Based on the score, return the level the player is on and

# how many milliseconds pass until a falling piece falls one space.

level = score//10 + 1

fallFreq = 270 - (level * 20)

# return a random new piece in a random rotation and color

shape = random.choice(list(PIECES.keys()))

newPiece = {'shape': shape,

'rotation': random.randint(0, len(PIECES[shape]) - 1),

'x': BOARDWIDTH // 2 - TEMPLATEWIDTH // 2,

'y': -2, # start it above the board (i.e. less than 0)

'color': random.randint(0, len(COLORS)-1)}

# fill in the board based on piece's location, shape, and rotation

for x in range(TEMPLATEWIDTH):

for y in range(TEMPLATEHEIGHT):

if PIECES[piece['shape']][piece['rotation']][y][x] != BLANK:

# create and return a new blank board data structure

board = []

for i in range(BOARDWIDTH):

board.append([BLANK] * BOARDHEIGHT)

# Return True if the piece is within the board and not colliding

for x in range(TEMPLATEWIDTH):

for y in range(TEMPLATEHEIGHT):

isAboveBoard = y + piece['y'] + adj_y < 0

if isAboveBoard or PIECES[piece['shape']][piece['rotation']][y][x] == BLANK:

continue

if not isOnBoard(x + piece['x'] + adj_x, y + piece['y'] + adj_y):

return False

if board[x + piece['x'] + adj_x][y + piece['y'] + adj_y] != BLANK:

return False

# Return True if the line filled with boxes with no gaps.

for x in range(BOARDWIDTH):

if board[x][y] == BLANK:

return False

# Remove any completed lines on the board, move everything above them down, and return the number of complete lines.

numLinesRemoved = 0

y = BOARDHEIGHT - 1 # start y at the bottom of the board

while y >= 0:

if isCompleteLine(board, y):

# Remove the line and pull boxes down by one line.

for pullDownY in range(y, 0, -1):

for x in range(BOARDWIDTH):

board[x][pullDownY] = board[x][pullDownY-1]

# Set very top line to blank.

for x in range(BOARDWIDTH):

board[x][0] = BLANK

numLinesRemoved += 1

# Note on the next iteration of the loop, y is the same.

# This is so that if the line that was pulled down is also

# complete, it will be removed.

else:

y -= 1 # move on to check next row up

# draw a single box (each tetromino piece has four boxes)

# at xy coordinates on the board. Or, if pixelx & pixely

# are specified, draw to the pixel coordinates stored in

# pixelx & pixely (this is used for the "Next" piece).

if color == BLANK:

return

if pixelx == None and pixely == None:

pixelx, pixely = convertToPixelCoords(boxx, boxy)

REN.fill((pixelx+1, pixely+1, BOXSIZE-1, BOXSIZE-1), COLORS[color])

# draw the border around the board (a box 10 pixels wider than playing area)

REN.fill((XMARGIN - 5, TOPMARGIN - 5, (BOARDWIDTH * BOXSIZE) + 10, (BOARDHEIGHT * BOXSIZE) + 10), BORDERCOLOR)

# fill the background of the board

REN.fill((XMARGIN, TOPMARGIN, BOXSIZE * BOARDWIDTH, BOXSIZE * BOARDHEIGHT), BGCOLOR)

# draw the individual boxes on the board

for x in range(BOARDWIDTH):

for y in range(BOARDHEIGHT):

# creote the text sprites

score_sprite = SPRITE_FACTORY.from_text("Score: %s" % score, color=TEXTCOLOR)

score_sprite.position = WINDOWWIDTH - 150, 20

level_sprite = SPRITE_FACTORY.from_text("Level: %s" % level, color=TEXTCOLOR)

level_sprite.position = WINDOWWIDTH-150, 50

next_text = SPRITE_FACTORY.from_text("Next:", color=TEXTCOLOR)

next_text.position = WINDOWWIDTH - 120, 80

drawPiece(piece, pixelx=WINDOWWIDTH-120, pixely=100)

shapeToDraw = PIECES[piece['shape']][piece['rotation']]

if pixelx == None and pixely == None:

# if pixelx & pixely hasn't been specified, use the location stored in the piece data structure

pixelx, pixely = convertToPixelCoords(piece['x'], piece['y'])

# draw each of the boxes that make up the piece

for x in range(TEMPLATEWIDTH):

for y in range(TEMPLATEHEIGHT):

if shapeToDraw[y][x] != BLANK: