def draw(self, window):
font = pygame.font.SysFont(self.font_name, size=self.text_size)
max_img_letter_width, max_img_letter_height = self.get_max_letter_size(
)
#On dessine les lignes qui montrent la position des lettres
for x_i in range(self.n_letter):
underline_width = max_img_letter_width
underline_y = self.pos[1] + self.padding + max_img_letter_height + 3
underline_x = self.pos[
0] + self.padding + x_i * underline_width + x_i * self.space_between_letter
underline_start_pos = (underline_x, underline_y)
underline_end_pos = (underline_x + underline_width, underline_y)
pygame.draw.line(window, self.color, underline_start_pos,
underline_end_pos, 2)
if (x_i == self.n_letter - 1):
box_width = underline_x + underline_width + self.padding - self.space_between_letter
#On dessine les lettres
for i in range(len(self.text)):
letter = self.text[i]
img_letter = font.render(letter, True, self.color)
img_letter_size = img_letter.get_size()
img_x = self.pos[
0] + self.padding + i * max_img_letter_width + max_img_letter_width / 2 - img_letter_size[
0] / 2 + i * self.space_between_letter
img_y = self.pos[
1] + self.padding + max_img_letter_height - img_letter_size[1]
img_letter_rect = (img_x, img_y, max_img_letter_width,
img_letter_size[1])
window.blit(img_letter, img_letter_rect)
if (self.n_letter_max != -1 and i == self.n_letter_max - 1):
break
box_x = self.pos[0]
box_y = self.pos[1]
box_height = 2 * self.padding + max_img_letter_height + 7
box_rect = (box_x, box_y, box_width, box_height)
box = Shape()
box.new_rectangle(window, self.b_color, box_rect, 1)
box.draw()
class Tetris(object):
W = 12 # the width of play board
H = 20 # the height of play board
TILEW = 20 # the pixel width/height of a tile
START = (100, 40) # the playboard lefttop on background
SPACE = 1000 # shape will fall after xxx ms(level 1)
def __init__(self, screen):
self.stat = "game"
self.WIDTH = self.TILEW * self.W
self.HEIGHT = self.TILEW * self.H
self.screen = screen
self.pause = False
# the array save current situation
# same as screen cood
self.board = []
for i in xrange(self.H):
line = [ None ] * self.W
self.board.append(line)
# will display
self.level = 1
self.killed = 0
self.score = 0
# after this time, shape falls
self.time = self.SPACE * 0.9 ** (self.level - 1)
# save the elapsed time after last fail
self.elapsed = 0
# used for judge pressed firstly or for a long time
self.pressing = 0
# the moving shape
self.shape = Shape(self.START,
(self.WIDTH, self.HEIGHT), (self.W, self.H))
self.shape.set_board(self.board)
self.board_image = pygame.Surface((self.WIDTH, self.HEIGHT))
# draw the background once
self.screen.blit(pygame.image.load(
util.file_path("background.jpg")).convert(), (0, 0))
self.display_info()
def update(self, elapse):
for e in pygame.event.get():
if e.type == KEYDOWN:
self.pressing = 1
self.move(e.key == K_UP, e.key == K_DOWN,
e.key == K_LEFT, e.key == K_RIGHT)
if e.key == K_ESCAPE:
self.stat = 'menu'
elif e.key == K_SPACE:
self.pause = not self.pause
elif e.type == KEYUP and self.pressing:
self.pressing = 0
elif e.type == QUIT:
self.stat = 'quit'
if self.pause:
self.draw()
return self.stat
if self.pressing:
pressed = pygame.key.get_pressed()
self.move(pressed[K_UP], pressed[K_DOWN],
pressed[K_LEFT], pressed[K_RIGHT])
self.elapsed += elapse
if self.elapsed >= self.time:
self.next()
self.elapsed = self.elapsed - self.time
self.draw()
return self.stat
def move(self, u, d, l, r):
if not (u or d or l or r):
return
# pressed for the first time
# pressed for a long time
if self.pressing == 1 or self.pressing > 10:
if u: self.shape.rotate()
elif d: self.next() #self.shape.move(0, 1) is bad
elif l: self.shape.move(-1, 0)
elif r: self.shape.move(1, 0)
self.draw()
self.pressing += 1
def check_line(self):
self.add_to_board()
filled = []
for i in xrange(self.H-1, -1, -1):
line = self.board[i]
sum = 0
for t in line:
sum += 1 if t else 0
if sum == self.W:
filled.append(i)
elif sum == 0:
break
if i == 0 and sum !=0:
self.game_over()
self.create_board_image() # used for killing animation
self.kill_line(filled)
self.create_board_image() # used for update
def kill_line(self, filled=[]):
if len(filled) == 0:
return
# play sound effect
play_sound(str(len(filled)))
# play animation
mask = pygame.Surface((self.WIDTH, self.TILEW), SRCALPHA, 32)
for i in xrange(5):
if i % 2 == 0:
mask.fill((255, 255, 255, 100))
else:
mask.fill((255, 255, 255, 200))
self.screen.blit(self.board_image, self.START)
for line in filled:
self.screen.blit(mask, (
self.START[0],
self.START[1] + line * self.TILEW))
pygame.display.update()
pygame.time.wait(80)
# remove filled lines
[self.board.pop(l) for l in sorted(filled, reverse=True)]
# fill with blank lines
[self.board.insert(0, [None] * self.W) for l in filled]
self.get_score(len(filled))
def get_score(self, num):
self.killed += num
self.score += num * num * 10 * self.level
self.level = 1 + self.killed // 10
self.time = self.SPACE * 0.9 ** (self.level - 1)
def add_to_board(self):
for x in xrange(self.shape.SHAPEW):
for y in xrange(self.shape.SHAPEH):
if self.shape.shape[y][x]:
self.board[self.shape.y+y][self.shape.x+x] = Tile(
self.shape.color,self.shape._image[self.shape.index])
def create_board_image(self):
self.board_image.fill((0, 0, 0))
for x in xrange(self.H):
for y in xrange(self.W):
if self.board[x][y]:
rect = pygame.Rect(y * self.TILEW, x * self.TILEW,
self.TILEW, self.TILEW)
self.board_image.blit(self.board[x][y].image, rect)
def next(self):
if self.shape.at_bottom():
play_sound('drop')
self.check_line()
self.shape.new()
self.display_info()
else:
self.shape.move(0, 1)
def draw(self):
self.screen.blit(self.board_image, self.START)
self.shape.draw(self.screen)
if self.pause:
util.myprint(self.screen, "PAUSE",
(self.START[0]+50, self.START[1]+200), "m")
def display_info(self):
self._display_next()
self._display_score()
def _display_score(self):
try:
self._score_board
except AttributeError:
self._score_board = (
self.START[0] + self.WIDTH + 30,
self.START[1] + 100,
200, 260)
self._score_level = (
self._score_board[0] + 10,
self._score_board[1] + 10)
self._score_level_v = (
self._score_board[0] + 30,
self._score_board[1] + 50)
self._score_killed = (
self._score_board[0] + 10,
self._score_board[1] + 90)
self._score_killed_v = (
self._score_board[0] + 30,
self._score_board[1] + 130)
self._score_score = (
self._score_board[0] + 10,
self._score_board[1] + 170)
self._score_score_v = (
self._score_board[0] + 30,
self._score_board[1] + 210)
self.screen.fill((0, 0, 0), self._score_board)
util.myprint(self.screen, 'LEVEL', self._score_level, 'm')
util.myprint(self.screen, self.level, self._score_level_v, 'm')
util.myprint(self.screen, 'LINES', self._score_killed, 'm')
util.myprint(self.screen, self.killed, self._score_killed_v, 'm')
util.myprint(self.screen, 'SCORE', self._score_score, 'm')
util.myprint(self.screen, self.score, self._score_score_v, 'm')
def _display_next(self):
try:
self._next_board
except AttributeError:
self._next_board = (
self.START[0] + self.WIDTH + 30,
self.START[1],
200, 80)
self._next_board_v = (
self.START[0] + self.WIDTH + 30 + 100 - self.TILEW * 2,
self.START[1] + 40 - self.TILEW * 2)
self.screen.fill((0, 0, 0), self._next_board)
self.screen.blit(self.shape.image_next, self._next_board_v)
def game_over(self):
self.stat = "menu"
class Board:
def __init__(self, window, width=10, height=16, xinit=2, yinit=2, tile_width=15):
self.tiles = Tiles(tile_width, window)
self.window = window
self.height = height
self.xinit = xinit
self.yinit = yinit
self.width = width
self.total_lines = 0
self.board = [[0 for j in range(width)] for i in range(height)]
self.shape = None
self._draw()
self.clear()
def add_shape(self):
assert not self.shape
sh, col = random.choice(shape_color)
self.shape = Shape(sh, self.window, col, self.width/2, 0, self.xinit, self.yinit)
if self.collides(self.shape):
raise GameOver()
self.shape.draw()
def eat_shape(self):
self.shape.erase()
for x,y in self.shape.shape:
self.board[y+self.shape.y][x+self.shape.x] = 1
self.shape = None
def frame(self, pressed_keys):
if not self.shape:
return
shapex = self.shape.x
shapey = self.shape.y
shape_shape = deepcopy(self.shape.shape)
self.shape.update_pos(pressed_keys)
if self.collides(self.shape):
self.shape.x = shapex
self.shape.y = shapey
self.shape.shape = shape_shape
else:
self.shape.draw()
def collides(self, shape):
for x,y in shape.shape:
x += shape.x
y += shape.y
if x < 0 or x >= self.width:
return True
if y >= self.height or y < 0:
return True
if self.board[y][x] == 1:
return True
return False
def collides_bottom(self, shape):
for x,y in shape.shape:
x += shape.x
y += shape.y
if y+1 >= self.height:
return True
if self.board[y+1][x]:
return True
return False
def tick(self):
self._erase()
if not self.shape:
self.add_shape()
elif not self.collides_bottom(self.shape):
self.shape.erase()
self.shape.move_down()
self.shape.draw()
elif self.collides_bottom(self.shape):
self.eat_shape()
self.check_lines()
self._draw()
def check_lines(self):
for i in range(self.height):
if self.check_line(self.board[i]):
self.board.pop(i)
self.total_lines += 1
print self.total_lines
self.board = [[0 for i in range(self.width)]] + self.board
def check_line(self, line):
for i in line:
if not i:
return False
return True
def _draw(self, draw_f=Tiles.square):
for y in range(self.height):
for x in range(self.width):
if self.board[y][x]:
draw_f(self.tiles, x+self.xinit, y+self.yinit)
def _erase(self):
self._draw(draw_f=Tiles.erase)
def clear(self):
for y in range(self.height):
for x in range(self.width):
self.tiles.erase(x+self.xinit, y+self.yinit)
class Tetris(object):
W = 12 # the width of play board
H = 20 # the height of play board
TILEW = 20 # the pixel width/height of a tile
START = (100, 40) # the playboard lefttop on background
SPACE = 1000 # shape will fall after xxx ms(level 1)
def __init__(self, screen):
self.stat = "game"
self.WIDTH = self.TILEW * self.W
self.HEIGHT = self.TILEW * self.H
self.screen = screen
self.pause = False
# the array save current situation
# same as screen cood
self.board = []
for i in xrange(self.H):
line = [None] * self.W
self.board.append(line)
# will display
self.level = 1
self.killed = 0
self.score = 0
# after this time, shape falls
self.time = self.SPACE * 0.8**(self.level - 1)
# save the elapsed time after last fail
self.elapsed = 0
# used for judge pressed firstly or for a long time
self.pressing = 0
# the moving shape
self.shape = Shape(self.START, (self.WIDTH, self.HEIGHT),
(self.W, self.H))
self.shape.set_board(self.board)
self.board_image = pygame.Surface((self.WIDTH, self.HEIGHT))
# draw the background once
self.screen.blit(
pygame.image.load(util.file_path("background.jpg")).convert(),
(0, 0))
self.display_info()
def update(self, elapse):
for e in pygame.event.get():
if e.type == KEYDOWN:
self.pressing = 1
self.move(e.key == K_UP, e.key == K_DOWN, e.key == K_LEFT,
e.key == K_RIGHT)
if e.key == K_ESCAPE:
self.stat = 'menu'
elif e.key == K_SPACE:
self.pause = not self.pause
elif e.type == KEYUP and self.pressing:
self.pressing = 0
elif e.type == QUIT:
self.stat = 'quit'
if self.pause:
self.draw()
return self.stat
if self.pressing:
pressed = pygame.key.get_pressed()
self.move(pressed[K_UP], pressed[K_DOWN], pressed[K_LEFT],
pressed[K_RIGHT])
self.elapsed += elapse
if self.elapsed >= self.time:
self.next()
self.elapsed = self.elapsed - self.time
self.draw()
return self.stat
def move(self, u, d, l, r):
if not (u or d or l or r):
return
# pressed for the first time
# pressed for a long time
if self.pressing == 1 or self.pressing > 10:
if u: self.shape.rotate()
elif d: self.next() #self.shape.move(0, 1) is bad
elif l: self.shape.move(-1, 0)
elif r: self.shape.move(1, 0)
self.draw()
self.pressing += 1
def check_line(self):
self.add_to_board()
filled = []
for i in xrange(self.H - 1, -1, -1):
line = self.board[i]
sum = 0
for t in line:
sum += 1 if t else 0
if sum == self.W:
filled.append(i)
elif sum == 0:
break
if i == 0 and sum != 0:
self.game_over()
self.create_board_image() # used for killing animation
self.kill_line(filled)
self.create_board_image() # used for update
def kill_line(self, filled=[]):
if len(filled) == 0:
return
# play sound effect
play_sound(str(len(filled)))
# play animation
mask = pygame.Surface((self.WIDTH, self.TILEW), SRCALPHA, 32)
for i in xrange(5):
if i % 2 == 0:
mask.fill((255, 255, 255, 100))
else:
mask.fill((255, 255, 255, 200))
self.screen.blit(self.board_image, self.START)
for line in filled:
self.screen.blit(
mask, (self.START[0], self.START[1] + line * self.TILEW))
pygame.display.update()
pygame.time.wait(80)
# remove filled lines
[self.board.pop(l) for l in sorted(filled, reverse=True)]
# fill with blank lines
[self.board.insert(0, [None] * self.W) for l in filled]
self.get_score(len(filled))
def get_score(self, num):
self.killed += num
self.score += num * num * 10 * self.level
self.level = 1 + self.killed // 10
self.time = self.SPACE * 0.8**(self.level - 1)
def add_to_board(self):
for x in xrange(self.shape.SHAPEW):
for y in xrange(self.shape.SHAPEH):
if self.shape.shape[y][x]:
self.board[self.shape.y + y][self.shape.x + x] = Tile(
self.shape.color)
def create_board_image(self):
self.board_image.fill((0, 0, 0))
for x in xrange(self.H):
for y in xrange(self.W):
if self.board[x][y]:
rect = pygame.Rect(y * self.TILEW, x * self.TILEW,
self.TILEW, self.TILEW)
self.board_image.fill(self.board[x][y].color, rect)
pygame.draw.rect(self.board_image, (200, 200, 200, 100),
rect, 1)
def next(self):
if self.shape.at_bottom():
play_sound('drop')
self.check_line()
self.shape.new()
self.display_info()
else:
self.shape.move(0, 1)
def draw(self):
self.screen.blit(self.board_image, self.START)
self.shape.draw(self.screen)
if self.pause:
util.myprint(self.screen, "PAUSE",
(self.START[0] + 50, self.START[1] + 200), "m")
def display_info(self):
self._display_next()
self._display_score()
def _display_score(self):
try:
self._score_board
except AttributeError:
self._score_board = (self.START[0] + self.WIDTH + 30,
self.START[1] + 100, 200, 260)
self._score_level = (self._score_board[0] + 10,
self._score_board[1] + 10)
self._score_level_v = (self._score_board[0] + 30,
self._score_board[1] + 50)
self._score_killed = (self._score_board[0] + 10,
self._score_board[1] + 90)
self._score_killed_v = (self._score_board[0] + 30,
self._score_board[1] + 130)
self._score_score = (self._score_board[0] + 10,
self._score_board[1] + 170)
self._score_score_v = (self._score_board[0] + 30,
self._score_board[1] + 210)
self.screen.fill((0, 0, 0), self._score_board)
util.myprint(self.screen, 'LEVEL', self._score_level, 'm')
util.myprint(self.screen, self.level, self._score_level_v, 'm')
util.myprint(self.screen, 'LINES', self._score_killed, 'm')
util.myprint(self.screen, self.killed, self._score_killed_v, 'm')
util.myprint(self.screen, 'SCORE', self._score_score, 'm')
util.myprint(self.screen, self.score, self._score_score_v, 'm')
def _display_next(self):
try:
self._next_board
except AttributeError:
self._next_board = (self.START[0] + self.WIDTH + 30, self.START[1],
200, 80)
self._next_board_v = (self.START[0] + self.WIDTH + 30 + 100 -
self.TILEW * 2,
self.START[1] + 40 - self.TILEW * 2)
self.screen.fill((0, 0, 0), self._next_board)
self.screen.blit(self.shape.image_next, self._next_board_v)
def game_over(self):
self.stat = "menu"
b.moveDown()
b.moveDown()
b.moveDown()
b.moveDown()
b.moveDown()
b.moveDown()
b.moveDown()
b.moveDown()
b.moveDown()
b.moveDown()
b.moveDown()
b.moveDown()
b.moveDown()
s1 = Shape(spawnShape())
'''
print 'before rotate:'
s1.draw(None)
s1.rotate()
print 'after 1st rotate:'
s1.draw(None)
s1.rotate()
print 'after 2nd rotate:'
s1.draw(None)
s1.rotate()
print 'after 3th rotate:'
s1.draw(None)
def draw_game_page(self, window):
case_size = (self.BOARD_SIZE - self.BOARD_PADDING * 2) / 15
interface_width = self.interface.GAME_WINDOW_WIDTH
interface_height = self.interface.GAME_WINDOW_HEIGHT
background_rect = (0, 0, interface_width, interface_height)
pygame.draw.rect(window, (46, 40, 42), background_rect)
#DRAW BOARD
board_x = interface_width / 2 - self.BOARD_SIZE / 2
board_y = 21
window.blit(self.scrabble_board, (board_x, board_y))
game_board = self.game.get_game_board()
for case_x in range(15):
for case_y in range(15):
letter_index = game_board[case_x][case_y]
if (letter_index != -1):
img_letter = self.l_img_letter[letter_index]
img_letter_size = int(case_size)
img_letter = pygame.transform.scale(
img_letter, (img_letter_size, img_letter_size))
img_letter_x = board_x + self.BOARD_PADDING + case_x * case_size + 1
img_letter_y = board_y + self.BOARD_PADDING + case_y * case_size + 2
window.blit(img_letter, (img_letter_x, img_letter_y))
#DRAW EASEL
del self.l_easel_case_rectangle[:]
easel_width = self.BOARD_SIZE / 1.3
easel_height = easel_width / 7
letter_case_size = int(easel_width / 7)
font = pygame.font.SysFont("", size=20)
for i in range(7):
x = interface_width / 2 - easel_width / 2 + (
i * letter_case_size) + (i / 1.88) * 2
y = 585
letter_case_rect = (x, y, letter_case_size, letter_case_size)
letter_case_rectangle = Shape()
letter_case_rectangle.new_rectangle(window, (255, 255, 255),
letter_case_rect, 2)
letter_case_rectangle.draw()
self.l_easel_case_rectangle.append(letter_case_rectangle)
#Pour avoir rapidement la dimension et la position de chaque case du chevalet au moment de gérer les évênements
image_index_letter = font.render(str(i + 1), True, (255, 255, 255))
img_index_letter_size = font.size(str(i + 1))
img_x = x + letter_case_size / 2 - img_index_letter_size[0] / 2
img_y = y + letter_case_size / 2 - img_index_letter_size[1] / 2
window.blit(image_index_letter, (img_x, img_y))
#On affiche les lettres dans les cases
player_turn = self.game.get_player_turn()
if (player_turn != None):
player_easel = player_turn.get_easel()
letter_index = player_easel.get_l_letter()[i]
if (letter_index != -1):
img_letter = self.l_img_letter[letter_index]
img_letter = pygame.transform.scale(
img_letter,
(letter_case_size - 2, letter_case_size - 2))
pygame.draw.rect(window, (0, 0, 0), letter_case_rect, 3)
#On réduit légèrement la taille des lettres pour qu'elles rentrent dans les cases sans effacer les contours
letter_case_rect = (x + 1, y + 1, letter_case_size - 2,
letter_case_size - 2)
window.blit(img_letter, letter_case_rect)
#Si il y a des lettres qui ont été désigné pour être échangé alors on marque ces lettres avec un signe
l_easel_case_to_renew = self.game.get_l_easel_case_to_renew()
if (i in l_easel_case_to_renew):
img_loop_size = int(case_size / 1.8)
img_loop = pygame.transform.scale(
self.img_loop, (img_loop_size, img_loop_size))
img_loop_x = letter_case_rect[0] + letter_case_rect[
3] - img_loop_size - 4
img_loop_y = letter_case_rect[1] + 3
window.blit(img_loop, (img_loop_x, img_loop_y))
#DRAW SCORE
font = pygame.font.SysFont("", size=30)
img_text_score = font.render("Score", True, (255, 255, 255))
window.blit(img_text_score, (865, 150))
font = pygame.font.SysFont("", size=25)
l_player = self.game.get_l_player()
y = 178
for player in l_player:
player_name = player.get_name()
player_score = player.get_score()
txt_score_player = player_name + ": " + str(
player_score) + " points"
img_text_score_player = font.render(txt_score_player, True,
(255, 255, 255))
window.blit(img_text_score_player, (865, y))
y += 25
#DRAW BUTTONS
for button in self.l_button_to_draw_by_page[self.page]:
button.draw(window)
#DRAW GRID MARKS
img_y = 5
x_min = interface_width / 2 - (
self.BOARD_SIZE) / 2 + self.BOARD_PADDING + case_size / 2
for x_i in range(0, 15):
letter = chr(65 + x_i)
font = pygame.font.SysFont("", size=20)
img_grid_mark = font.render(letter, True, (255, 255, 255))
image_size = font.size(letter)
img_x = x_min + x_i * case_size - image_size[0] / 2
window.blit(img_grid_mark, (img_x, img_y))
img_x = x_min - case_size / 2 - 26
y_min = board_y + self.BOARD_PADDING + case_size / 2
for y_i in range(0, 15):
number = str(y_i + 1)
font = pygame.font.SysFont("", size=20)
img_grid_mark = font.render(number, True, (255, 255, 255))
image_size = font.size(number)
img_y = y_min + y_i * case_size - image_size[1] / 2
window.blit(img_grid_mark, (img_x, img_y))
#DRAW TIME
font = pygame.font.SysFont("", size=25)
played_time = self.game.get_played_time()
text_time_played = get_played_time_formatted(played_time)
img_text_time_played = font.render(text_time_played, True,
(255, 255, 255))
window.blit(img_text_time_played, (10, 10))
#DRAW MENU
font = pygame.font.SysFont("", size=26)
img_text_menu = font.render("Menu de jeu", True, (255, 255, 255))
img_text_menu_size = img_text_menu.get_size()
img_text_menu_x = 127 - img_text_menu_size[0] / 2
img_text_menu_y = 258 - img_text_menu_size[1] / 2
window.blit(img_text_menu, (img_text_menu_x, img_text_menu_y))
line_start_pos = (127 - img_text_menu_size[0] / 2, 279)
line_end_pos = (127 + img_text_menu_size[0] / 2, 279)
pygame.draw.line(window, (255, 255, 255), line_start_pos, line_end_pos)
line_start_pos = (127 - img_text_menu_size[0] / 2, 355)
line_end_pos = (127 + img_text_menu_size[0] / 2, 355)
pygame.draw.line(window, (255, 255, 255), line_start_pos, line_end_pos)
menu_outline_rect = (15, 223, 222, 186)
pygame.draw.rect(window, (255, 255, 255), menu_outline_rect, 2)
#DRAW MOVING LETTER
if (self.letter_moving_index != -1):
img_letter_moving = self.l_img_letter[self.letter_moving_index]
img_letter_moving_size = int(case_size)
img_letter_moving = pygame.transform.scale(
img_letter_moving,
(img_letter_moving_size, img_letter_moving_size))
mouse_pos = pygame.mouse.get_pos()
img_letter_moving_x = mouse_pos[0] - img_letter_moving_size / 2
img_letter_moving_y = mouse_pos[1] - img_letter_moving_size / 2
window.blit(img_letter_moving,
(img_letter_moving_x, img_letter_moving_y))
#DRAW JOKER CHOICE
if (self.joker_choice_mode):
space_between_letter = 18
img_letter_size = 35
background_width = img_letter_size * 10 + space_between_letter * 8 + 60
background_x = interface_width / 2 - background_width / 2
pygame.draw.rect(window, (255, 255, 255),
(background_x, 160, background_width, 300))
pygame.draw.rect(window, (0, 0, 0),
(background_x, 160, background_width, 300), 3)
font = pygame.font.SysFont("", size=40)
img_text_choice_joker = font.render("*** Choix du joker ***", True,
(0, 0, 0))
img_text_choice_joker_size = img_text_choice_joker.get_size()
img_text_choice_joker_x = interface_width / 2 - img_text_choice_joker_size[
0] / 2
window.blit(img_text_choice_joker, (img_text_choice_joker_x, 200))
self.l_joker_letter_choice_rect.clear()
y_min = 250
for y_i in range(3):
if (y_i < 2):
line_width = img_letter_size * 10 + space_between_letter * 9
else:
line_width = img_letter_size * 7 + space_between_letter * 6
img_letter_y = y_min + y_i * 60
x_min = interface_width / 2 - line_width / 2
for x_i in range(10):
img_index = y_i * 10 + x_i
if (img_index == 26):
break
img_letter = self.l_img_letter[img_index]
img_letter = pygame.transform.scale(
img_letter, (img_letter_size, img_letter_size))
img_letter_x = x_min + x_i * (space_between_letter +
img_letter_size)
if (y_i == 2):
img_letter_x += img_letter_size
letter_frame_rect = (img_letter_x - 2, img_letter_y - 2,
img_letter_size + 4,
img_letter_size + 4)
letter_frame_srect = Shape()
letter_frame_srect.new_rectangle(window, (0, 0, 0),
letter_frame_rect, 2)
letter_frame_srect.draw()
self.l_joker_letter_choice_rect.append(letter_frame_srect)
window.blit(img_letter, (img_letter_x, img_letter_y))
#DRAW PART PLAYER TURN
player_turn = self.game.get_player_turn()
if (player_turn != None):
font = pygame.font.SysFont("", size=25)
txt_player_turn = "C'est à " + player_turn.get_name(
) + " de jouer !"
img_txt_player_turn = font.render(txt_player_turn, True,
(255, 255, 255))
image_size = img_txt_player_turn.get_size()
window.blit(img_txt_player_turn, (970 - image_size[0] / 2, 600))
for message in self.l_message:
message.draw(window)
#Pour le debug
'''for x in range(0, 15):
if i == 6: shape.color = Colors["WHITE"] # BUTTON 7: White
if i == 7: shape.color = Colors["GRAY"] # BUTTON 8: White
if i == 8: shape.color = Colors["BLACK"] # BUTTON 9: White
if i == 9: shape.color = Colors["RED"] # BUTTON 10: White
if i == 10:
shape.color = Colors["ORANGE"] # BUTTON 11: White
if i == 11:
shape.color = Colors["YELLOW"] # BUTTON 12: White
if i == 12:
shape.color = Colors["GREEN"] # BUTTON 12: White
if i == 13:
shape.color = Colors["BLUE"] # BUTTON 12: White
if i == 14:
shape.color = Colors["PURPLE"] # BUTTON 12: White
# CLEAR SCREEN
if i == 15: window.fill(Colors["BLACK"])
# CONTINUOUS EVENT. (Other than 'if event.type == pygame.MOUSEBUTTONDOWN:')
if pygame.mouse.get_pressed()[0]:
# Draw shape
shape.draw()
# DRAW OBJECTS: 'i' is synced up with ALL button images, as all have a unique image to display.
for i in range(len(button)):
button[i].draw(i)
# UPDATE
pygame.display.update()
