1.0

Added sound

Author: educ8s

Sounds/clear.ogg

@@ -1,55 +1,41 @@
-import pygame
-from position import Position
 from colors import Colors
+from position import Position
+import pygame
 
-class Block():
-def __init__(self, start_offset, id ):
-self.start_off_x = start_offset.row
-self.start_off_y = start_offset.column
-self.offset = start_offset
-self.tiles = {}
+class Block:
+def __init__(self, id):
 self.id = id
+self.cells = {}
+self.cell_size = 30
+self.row_offset = 0
+self.column_offset = 0
+self.colors = Colors.get_cell_colors()
 self.rotation_state = 0
-self.colors = Colors.get_tile_colors()
 
-def tile_positions(self):
-tiles = self.tiles[self.rotation_state]
-new_tiles = []
+def get_cells_positions(self):
+tiles = self.cells[self.rotation_state]
+moved_tiles = []
 for position in tiles:
-position = Position(position.row + self.offset.row, position.column + self.offset.column)
-new_tiles.append(position)
-return new_tiles
-
-def rotate(self):
-self.rotation_state = (self.rotation_state + 1) % len(self.tiles)
-
-def undo_rotate(self):
-self.rotation_state = (self.rotation_state -1) % len(self.tiles)
+position = Position(position.row + self.row_offset, position.column + self.column_offset)
+moved_tiles.append(position)
+return moved_tiles
 
 def move(self, rows, columns):
-self.offset.row += rows
-self.offset.column += columns
+self.row_offset += rows
+self.column_offset += columns
 
-def reset(self):
-self.rotation_state = 0
-self.offset.row = self.start_off_x
-self.offset.column = self.start_off_y
+def rotate(self):
+self.rotation_state += 1
+if self.rotation_state == len(self.cells):
+self.rotation_state = 0
 
-def draw(self, screen):
-tiles = self.tile_positions()
-for tile in tiles:
-tile_rect = pygame.Rect(10 + (tile.column) * 25 + 1, 10 + tile.row* 25 +1, 24, 24)
-pygame.draw.rect(screen, self.colors[self.id], tile_rect)
+def undo_rotation(self):
+self.rotation_state -= 1
+if self.rotation_state == -1:
+self.rotation_state = len(self.cells) - 1
 
-def draw_small_icon(self, screen):
-tiles = self.tile_positions()
+def draw(self, screen, offset_x, offset_y):
+tiles = self.get_cells_positions()
 for tile in tiles:
-offset_x = 0
-offset_y = 0
-if self.id == 2:
-offset_y = 15
-offset_x = -8
-elif self.id == 4:
-offset_x = -10
-tile_rect = pygame.Rect(offset_x + 240 + (tile.column) * 20 , offset_y + 230 + tile.row* 20, 19, 19)
+tile_rect = pygame.Rect(offset_x + tile.column * self.cell_size, offset_y + tile.row * self.cell_size, self.cell_size - 1, self.cell_size -1)
 pygame.draw.rect(screen, self.colors[self.id], tile_rect)

Sounds/music.ogg

@@ -3,77 +3,75 @@
 
 class LBlock(Block):
  def __init__(self):
- super().__init__(Position(0, 3), id=0)
- self.tiles = {
+ super().__init__ ( id = 1)
+ self.cells = {
  0: [Position(0, 2), Position(1, 0), Position(1, 1), Position(1, 2)],
  1: [Position(0, 1), Position(1, 1), Position(2, 1), Position(2, 2)],
  2: [Position(1, 0), Position(1, 1), Position(1, 2), Position(2, 0)],
  3: [Position(0, 0), Position(0, 1), Position(1, 1), Position(2, 1)]
  }
+ self.move(0, 3)
 
 class JBlock(Block):
  def __init__(self):
- super().__init__(Position(0,3), id=1)
- self.tiles = {
+ super().__init__(id = 2)
+ self.cells = {
  0: [Position(0, 0), Position(1, 0), Position(1, 1), Position(1, 2)],
  1: [Position(0, 1), Position(0, 2), Position(1, 1), Position(2, 1)],
  2: [Position(1, 0), Position(1, 1), Position(1, 2), Position(2, 2)],
  3: [Position(0, 1), Position(1, 1), Position(2, 0), Position(2, 1)]
  }
+ self.move(0, 3)
+
 
 class IBlock(Block):
  def __init__(self):
- super().__init__(Position(-1, 3), id=2)
- self.tiles = {
+ super().__init__(id = 3)
+ self.cells = {
  0: [Position(1, 0), Position(1, 1), Position(1, 2), Position(1, 3)],
  1: [Position(0, 2), Position(1, 2), Position(2, 2), Position(3, 2)],
  2: [Position(2, 0), Position(2, 1), Position(2, 2), Position(2, 3)],
  3: [Position(0, 1), Position(1, 1), Position(2, 1), Position(3, 1)]
  }
-
-class LBlock(Block):
- def __init__(self):
- super().__init__(Position(0, 3), id=3)
- self.tiles = {
- 0: [Position(0, 2), Position(1, 0), Position(1, 1), Position(1, 2)],
- 1: [Position(0, 1), Position(1, 1), Position(2, 1), Position(2, 2)],
- 2: [Position(1, 0), Position(1, 1), Position(1, 2), Position(2, 0)],
- 3: [Position(0, 0), Position(0, 1), Position(1, 1), Position(2, 1)]
- }
+ self.move(-1, 3)
 
 class OBlock(Block):
  def __init__(self):
- super().__init__(Position(0, 4), id = 4)
- self.tiles = {
+ super().__init__(id = 4)
+ self.cells = {
  0: [Position(0, 0), Position(0, 1), Position(1, 0), Position(1, 1)],
  }
+ self.move(0, 4) 
 
 class SBlock(Block):
  def __init__(self):
- super().__init__(Position(0, 3), id=5)
- self.tiles = {
+ super().__init__(id = 5)
+ self.cells = {
  0: [Position(0, 1), Position(0, 2), Position(1, 0), Position(1, 1)],
  1: [Position(0, 1), Position(1, 1), Position(1, 2), Position(2, 2)],
  2: [Position(1, 1), Position(1, 2), Position(2, 0), Position(2, 1)],
  3: [Position(0, 0), Position(1, 0), Position(1, 1), Position(2, 1)]
  }
+ self.move(0, 3)
 
 class TBlock(Block):
  def __init__(self):
- super().__init__(Position(0, 3), id=6)
- self.tiles = {
+ super().__init__(id = 6)
+ self.cells = {
  0: [Position(0, 1), Position(1, 0), Position(1, 1), Position(1, 2)],
  1: [Position(0, 1), Position(1, 1), Position(1, 2), Position(2, 1)],
  2: [Position(1, 0), Position(1, 1), Position(1, 2), Position(2, 1)],
  3: [Position(0, 1), Position(1, 0), Position(1, 1), Position(2, 1)]
  }
+ self.move(0, 3)
 
 class ZBlock(Block):
  def __init__(self):
- super().__init__(Position(0, 3), id=7)
- self.tiles = {
+ super().__init__(id = 7)
+ self.cells = {
  0: [Position(0, 0), Position(0, 1), Position(1, 1), Position(1, 2)],
  1: [Position(0, 2), Position(1, 1), Position(1, 2), Position(2, 1)],
  2: [Position(1, 0), Position(1, 1), Position(2, 1), Position(2, 2)],
  3: [Position(0, 1), Position(1, 0), Position(1, 1), Position(2, 0)]
- }
+ }
+ self.move(0, 3)

Sounds/rotate.ogg

@@ -1,18 +1,16 @@
 class Colors:
- empty = (26, 31, 40)
- green = (47, 230, 23)
- orange = (226, 116, 17)
- red = (232, 18, 18)
- purple = (166, 0, 247)
- yellow = (237, 234, 4)
- cyan = (21, 204, 209)
- blue = (13, 64, 216)
- white = (255, 255, 255)
- black = (0, 0, 0)
- grey = (15, 15, 15)
- dark_blue = (44, 44, 127)
- light_blue = (59, 85, 162)
+dark_grey = (26, 31, 40)
+green = (47, 230, 23)
+orange = (226, 116, 17)
+red = (232, 18, 18)
+purple = (166, 0, 247)
+yellow = (237, 234, 4)
+cyan = (21, 204, 209)
+blue = (13, 64, 216)
+white = (255, 255, 255)
+dark_blue = (44, 44, 127)
+light_blue = (59, 85, 162)
 
- @classmethod
- def get_tile_colors(cls):
- return [cls.empty, cls.green, cls.orange, cls.red, cls.purple, cls.yellow, cls.cyan, cls.blue]
+@classmethod
+def get_cell_colors(cls):
+return [cls.dark_grey, cls.green, cls.orange, cls.red, cls.purple, cls.yellow, cls.cyan, cls.blue]

block.py

@@ -1,83 +1,103 @@
-from game_grid import GameGrid
-import random
+from grid import Grid
 from blocks import *
+import random, pygame
 
 class Game:
 def __init__(self):
-self.grid = GameGrid(20, 10)
+self.grid = Grid()
 self.blocks = [IBlock(), JBlock(), LBlock(), OBlock(), SBlock(), TBlock(), ZBlock()]
 self.current_block = self.get_random_block()
 self.next_block = self.get_random_block()
 self.game_over = False
 self.score = 0
+self.rotate_sound = pygame.mixer.Sound('Sounds/rotate.ogg')
+self.clear_sound = pygame.mixer.Sound('Sounds/clear.ogg')
+self.rotate_sound.set_volume(0.1)
+self.clear_sound.set_volume(0.3)
+pygame.mixer.music.load('Sounds/music.ogg')
+pygame.mixer.music.play(-1)
 
-def block_fits(self):
-tiles = self.current_block.tile_positions()
-for position in tiles:
-if self.grid.is_empty(position.row, position.column) == False :
+def get_random_block(self):
+if len(self.blocks)==0:
+self.blocks = [IBlock(), JBlock(), LBlock(), OBlock(), SBlock(), TBlock(), ZBlock()]
+block = random.choice(self.blocks)
+self.blocks.remove(block)
+return block
+
+def block_inside(self):
+tiles = self.current_block.get_cells_positions()
+for tile in tiles:
+if self.grid.is_inside(tile.row, tile.column) == False:
 return False
 return True
 
-def rotate_block_cw(self):
-self.current_block.rotate()
-if self.block_fits() == False: 
-self.current_block.undo_rotate()
+def block_fits(self):
+tiles = self.current_block.get_cells_positions()
+for tile in tiles:
+if self.grid.is_empty(tile.row, tile.column) == False:
+return False
+return True
 
-def set_current_block(self):
-self.current_block = self.next_block
-self.current_block.reset()
-self.next_block = self.get_random_block()
-self.next_block.reset()
+def draw(self, screen):
+self.grid.draw(screen)
+self.current_block.draw(screen, 11, 11)
+if self.next_block.id == 3:
+self.next_block.draw(screen, 255, 290)
+elif self.next_block.id == 4:
+self.next_block.draw(screen, 255, 280)
+else:
+self.next_block.draw(screen, 270, 270)
 
 def move_left(self):
 self.current_block.move(0, -1)
-if self.block_fits() == False:
+if self.block_inside() == False or self.block_fits() == False:
 self.current_block.move(0, 1)
 
 def move_right(self):
 self.current_block.move(0, 1)
-if self.block_fits() == False:
+if self.block_inside() == False or self.block_fits() == False:
 self.current_block.move(0, -1)
 
-def place_block(self):
-tiles = self.current_block.tile_positions()
+def move_down(self):
+self.current_block.move(1, 0)
+if self.block_inside() == False or self.block_fits() == False:
+self.current_block.move(-1, 0)
+self.lock_block()
+
+def rotate(self):
+self.current_block.rotate()
+if self.block_inside() == False or self.block_fits() == False:
+self.current_block.undo_rotation()
+else:
+self.rotate_sound.play()
+
+def lock_block(self):
+tiles = self.current_block.get_cells_positions()
 for position in tiles:
 self.grid.grid[position.row][position.column] = self.current_block.id
-cleared_rows = self.grid.clear_full_rows()
+rows_cleared = self.grid.clear_full_rows()
+if rows_cleared > 0:
+self.clear_sound.play()
+self.update_score(rows_cleared, 0)
+self.current_block = self.next_block
+self.next_block = self.get_random_block()
+if self.block_fits() == False:
+self.game_over = True
 
-if cleared_rows == 1:
-self.score += 40
-elif cleared_rows == 2:
+def update_score(self, lines_cleared, move_down_points):
+
+if lines_cleared == 1:
 self.score += 100
-elif cleared_rows == 3:
+elif lines_cleared == 2:
 self.score += 300
-elif cleared_rows == 4:
-self.score += 1200
-
-self.set_current_block()
+elif lines_cleared == 3:
+self.score += 500
 
-def move_down(self):
-self.current_block.move(1,0)
-if self.block_fits() == False:
-for tile in self.current_block.tile_positions():
-if tile.row == 1:
-self.game_over = True
-self.current_block.move(-1, 0)
-self.place_block()
-self.score += 4
+self.score += move_down_points
 
 def reset(self):
 self.grid.reset()
-self.set_current_block()
-self.score = 0
-self.game_over = False
 self.blocks = [IBlock(), JBlock(), LBlock(), OBlock(), SBlock(), TBlock(), ZBlock()]
 self.current_block = self.get_random_block()
 self.next_block = self.get_random_block()
-
-def get_random_block(self):
-if len(self.blocks) != 0:
-return self.blocks.pop(random.randrange(len(self.blocks)))
-else:
-self.blocks = [IBlock(), JBlock(), LBlock(), OBlock(), SBlock(), TBlock(), ZBlock()]
-return self.blocks.pop(random.randrange(len(self.blocks)))
+self.score = 0