#!/usr/bin/env python
"tetris -- a brand new game written in python by Alfe"
import sys, random, time, select, os, termios
width = 10
height = 22
blocks = [ [ (0,0), (0,1), (0,-1), (1,0) ], # T
[ (0,0), (0,1), (0,2), (0,-1) ], # I
[ (0,0), (0,1), (1,1), (-1,0) ], # S
[ (0,0), (0,-1), (1,-1), (-1,0) ], # Z
[ (0,0), (0,1), (1,1), (1,0) ], # O
[ (0,0), (-1,1), (-1,0), (1,0) ], # L
[ (0,0), (1,1), (-1,0), (1,0) ], # J
]
inverted = '\033[7;1m'
blue = '\033[7;34m'
normal = '\033[0m'
clear_screen = '\033[2J' # clear the screen
home = '\033[H' # goto top left corner of the screen
# (the latter two were found using 'clear | od -c')
empty = ' '
black = inverted + ' ' + normal # two inverted spaces
blue = blue + ' ' + normal # two inverted spaces
floor = '=='
left = 'left'
right = 'right'
turn = 'turn'
down = 'down'
quit = 'quit'
shaft = None
def play_tetris():
initialize_shaft()
while True: # until game is lost
block = get_random_block()
coordinates = (width/2-1, 1) # in the middle at the top
if not place_block(block, coordinates, blue): # collision already?
return # game is lost!
next_fall_time = time.time() + fall_delay()
# ^^^ this is the time when the block will fall automatically
# one line down
while True: # until block is placed fixedly
print_shaft()
remove_block(block, coordinates)
x, y = coordinates
try:
try:
command = get_command(next_fall_time)
except Timeout: # no command given
raise Fall()
else: # no exception, so process command:
if command == left:
new_coordinates = (x-1, y)
new_block = block
elif command == right:
new_coordinates = (x+1, y)
new_block = block
elif command == turn:
new_coordinates = (x, y)
new_block = turn_block(block)
elif command == down:
raise Fall()
elif command == quit:
return
else:
raise Exception("internal error: %r" % command)
if place_block(new_block, new_coordinates,
blue): # command ok?
# execute the command:
block = new_block
coordinates = new_coordinates
else:
place_block(block, coordinates, blue)
# ignore the command which could not be executed
# maybe beep here or something ;->
except Fall:
# make the block fall automatically:
new_coordinates = (x, y+1)
next_fall_time = time.time() + fall_delay()
if place_block(block, new_coordinates, blue): # can be placed?
coordinates = new_coordinates
else:
place_block(block, coordinates,
black) # place block there again
break # and bail out
remove_full_lines()
class Timeout(Exception): pass
class Fall(Exception): pass
def remove_full_lines():
global shaft, width, height
def line_full(line):
global width
for x in range(width):
if line[x] == empty:
return False
return True
def remove_line(y):
global shaft, width
del shaft[y] # cut out line
shaft.insert(0, [ empty ] * width) # fill up with an empty line
for y in range(height):
if line_full(shaft[y]):
remove_line(y)
def fall_delay():
return 1.3 # cheap version; implement raising difficulty here
def turn_block(block):
"return a turned copy(!) of the given block"
result = []
for x, y in block:
result.append((y, -x))
return result
def get_command(next_fall_time):
"if a command is entered, return it; otherwise raise the exception Timeout"
while True: # until a timeout occurs or a command is found:
timeout = next_fall_time - time.time()
if timeout > 0.0:
(r, w, e) = select.select([ sys.stdin ], [], [], timeout)
else:
raise Timeout()
if sys.stdin not in r: # not input on stdin?
raise Timeout()
key = os.read(sys.stdin.fileno(), 1)
if key == 'j':
return left
elif key == 'l':
return right
elif key == 'k':
return turn
elif key == ' ':
return down
elif key == 'q':
return quit
else: # any other key: ignore
pass
def place_block(block, coordinates, color):
"if the given block can be placed in the shaft at the given coordinates"\
" then place it there and return True; return False otherwise and do not"\
" place anything"
global shaft, width, height
block_x, block_y = coordinates
for stone_x, stone_y in block:
x = block_x + stone_x
y = block_y + stone_y
if (x < 0 or x >= width or
y < 0 or y >= height or # border collision?
shaft[y][x] != empty): # block collision?
return False # cannot be placed there
# reached here? ==> can be placed there
# now really place it:
for stone_x, stone_y in block:
x = block_x + stone_x
y = block_y + stone_y
shaft[y][x] = color
return True
def remove_block(block, coordinates):
global shaft
block_x, block_y = coordinates
for stone_x, stone_y in block:
x = block_x + stone_x
y = block_y + stone_y
shaft[y][x] = empty
def get_random_block():
if random.randint(1, 10) == 1:
return perfect_block() or random.choice(blocks)
return random.choice(blocks)
def perfect_block():
result = []
for y in range(height):
if filter(lambda b: b != empty, shaft[y]): # found summit
random_order = range(width)
random.shuffle(random_order)
for x in random_order:
if shaft[y][x] == empty: # found space besides summit
for x_ in range(width-x): # fill to the right
if shaft[y][x+x_] != empty:
break
for y_ in range(height-y):
if shaft[y+y_][x+x_] == empty:
result.append((x_, y_))
else:
break
for x_ in range(-1, -x-1, -1): # fill to the left
if shaft[y][x+x_] != empty:
break
for y_ in range(height-y):
if shaft[y+y_][x+x_] == empty:
result.append((x_, y_))
else:
break
# shift block in x direction to center it:
xmin = min(map(lambda v: v[0], result))
xmax = max(map(lambda v: v[0], result))
return map(lambda v: (v[0]-(xmax+xmin)/2, v[1]), result)
return None
def initialize_shaft():
global width, height, shaft, empty
shaft = [ None ] * height
for y in range(height):
shaft[y] = [ empty ] * width
def print_shaft():
# cursor-goto top left corner:
sys.stdout.write(home)
for y in range(height):
if y > 3: # does this line have a border? (the topmost ones do not)
sys.stdout.write(']')
else:
sys.stdout.write(' ')
for x in range(width):
sys.stdout.write(shaft[y][x])
if y > 3: # does this line have a border? (the topmost ones do not)
sys.stdout.write('[\n')
else:
sys.stdout.write('\n')
# print bottom:
sys.stdout.write(']' + floor * width + '[\n')
def prepare_tty():
"set the terminal in char mode (return each keyboard press at once) and"\
" switch off echoing of this input; return the original settings"
stdin_fd = sys.stdin.fileno() # will most likely be 0 ;->
old_stdin_config = termios.tcgetattr(stdin_fd)
[ iflag, oflag, cflag, lflag, ispeed, ospeed, cc ] = \
termios.tcgetattr(stdin_fd)
cc[termios.VTIME] = 1
cc[termios.VMIN] = 1
iflag = iflag & ~(termios.IGNBRK |
termios.BRKINT |
termios.PARMRK |
termios.ISTRIP |
termios.INLCR |
termios.IGNCR |
#termios.ICRNL |
termios.IXON)
# oflag = oflag & ~termios.OPOST
cflag = cflag | termios.CS8
lflag = lflag & ~(termios.ECHO |
termios.ECHONL |
termios.ICANON |
# termios.ISIG |
termios.IEXTEN)
termios.tcsetattr(stdin_fd, termios.TCSANOW,
[ iflag, oflag, cflag, lflag, ispeed, ospeed, cc ])
return (stdin_fd, old_stdin_config)
def cleanup_tty(original_tty_settings):
"restore the original terminal settings"
stdin_fd, old_stdin_config = original_tty_settings
termios.tcsetattr(stdin_fd, termios.TCSADRAIN, old_stdin_config)
original_tty_settings = prepare_tty() # switch off line buffering etc.
sys.stdout.write(clear_screen)
try: # ensure that tty will be reset in the end
play_tetris()
finally:
cleanup_tty(original_tty_settings)
