Video Code

The video version of the game.

Author: educ8s

block.py

@@ -1,6 +1,6 @@
 from colors import Colors
-from position import Position
 import pygame
+from position import Position
 
 class Block:
 	def __init__(self, id):
@@ -9,33 +9,34 @@ def __init__(self, id):
 		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_cell_colors()
+
+	def move(self, rows, columns):
+		self.row_offset += rows
+		self.column_offset += columns
 
-	def get_cells_positions(self):
+	def get_cell_positions(self):
 		tiles = self.cells[self.rotation_state]
 		moved_tiles = []
 		for position in 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.row_offset += rows
-		self.column_offset += columns
-
 	def rotate(self):
 		self.rotation_state += 1
 		if self.rotation_state == len(self.cells):
 			self.rotation_state = 0
 
 	def undo_rotation(self):
 		self.rotation_state -= 1
-		if self.rotation_state == -1:
+		if self.rotation_state == 0:
 			self.rotation_state = len(self.cells) - 1
 
 	def draw(self, screen, offset_x, offset_y):
-		tiles = self.get_cells_positions()
+		tiles = self.get_cell_positions()
 		for tile in tiles:
-			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)
+			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)

blocks.py

@@ -2,15 +2,15 @@
 from position import Position
 
 class LBlock(Block):
-    def __init__(self):
-        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)
+	def __init__(self):
+		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):
@@ -23,7 +23,6 @@ def __init__(self):
         }
         self.move(0, 3)
 
-
 class IBlock(Block):
     def __init__(self):
         super().__init__(id = 3)
@@ -39,9 +38,9 @@ class OBlock(Block):
     def __init__(self):
         super().__init__(id = 4)
         self.cells = {
-            0: [Position(0, 0), Position(0, 1), Position(1, 0), Position(1, 1)],
+            0: [Position(0, 0), Position(0, 1), Position(1, 0), Position(1, 1)]
         }
-        self.move(0, 4)       
+        self.move(0, 4)
 
 class SBlock(Block):
     def __init__(self):

colors.py

@@ -1,10 +1,10 @@
 class Colors:
 	dark_grey = (26, 31, 40)
 	green = (47, 230, 23)
-	orange = (226, 116, 17)
 	red = (232, 18, 18)
-	purple = (166, 0, 247)
+	orange = (226, 116, 17)
 	yellow = (237, 234, 4)
+	purple = (166, 0, 247)
 	cyan = (21, 204, 209)
 	blue = (13, 64, 216)
 	white = (255, 255, 255)
@@ -13,4 +13,4 @@ class Colors:
 
 	@classmethod
 	def get_cell_colors(cls):
-		return [cls.dark_grey, cls.green, cls.orange, cls.red, cls.purple, cls.yellow, cls.cyan, cls.blue]
+		return [cls.dark_grey, cls.green, cls.red, cls.orange, cls.yellow, cls.purple, cls.cyan, cls.blue]

game.py

@@ -1,6 +1,7 @@
 from grid import Grid
 from blocks import *
-import random, pygame
+import random
+import pygame
 
 class Game:
 	def __init__(self):
@@ -10,42 +11,28 @@ def __init__(self):
 		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')
-		pygame.mixer.music.load('Sounds/music.ogg')
+		self.rotate_sound = pygame.mixer.Sound("Sounds/rotate.ogg")
+		self.clear_sound = pygame.mixer.Sound("Sounds/clear.ogg")
+
+		pygame.mixer.music.load("Sounds/music.ogg")
 		pygame.mixer.music.play(-1)
 
+	def update_score(self, lines_cleared, move_down_points):
+		if lines_cleared == 1:
+			self.score += 100
+		elif lines_cleared == 2:
+			self.score += 300
+		elif lines_cleared == 3:
+			self.score += 500
+		self.score += move_down_points
+
 	def get_random_block(self):
-		if len(self.blocks)==0:
+		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 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 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_inside() == False or self.block_fits() == False:
@@ -62,40 +49,54 @@ def move_down(self):
 			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()
+		tiles = self.current_block.get_cell_positions()
 		for position in tiles:
 			self.grid.grid[position.row][position.column] = self.current_block.id
+		self.current_block = self.next_block
+		self.next_block = self.get_random_block()
 		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
 
-	def update_score(self, lines_cleared, move_down_points):
-
-		if lines_cleared == 1:
-			self.score += 100
-		elif lines_cleared == 2:
-			self.score += 300
-		elif lines_cleared == 3:
-			self.score += 500
-
-		self.score += move_down_points
-
 	def reset(self):
 		self.grid.reset()
 		self.blocks = [IBlock(), JBlock(), LBlock(), OBlock(), SBlock(), TBlock(), ZBlock()]
 		self.current_block = self.get_random_block()
 		self.next_block = self.get_random_block()
-		self.score = 0
+		self.score = 0
+
+	def block_fits(self):
+		tiles = self.current_block.get_cell_positions()
+		for tile in tiles:
+			if self.grid.is_empty(tile.row, tile.column) == False:
+				return False
+		return True
+
+	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 block_inside(self):
+		tiles = self.current_block.get_cell_positions()
+		for tile in tiles:
+			if self.grid.is_inside(tile.row, tile.column) == False:
+				return False
+		return True
+
+	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)

grid.py

@@ -4,19 +4,19 @@
 class Grid:
 	def __init__(self):
 		self.num_rows = 20
-		self.num_columns = 10
+		self.num_cols = 10
 		self.cell_size = 30
-		self.grid = [[0 for j in range(self.num_columns)] for i in range(self.num_rows)]
+		self.grid = [[0 for j in range(self.num_cols)] for i in range(self.num_rows)]
 		self.colors = Colors.get_cell_colors()
 
 	def print_grid(self):
 		for row in range(self.num_rows):
-			for column in range(self.num_columns):
-				print(self.grid[row][column], end=' ')
+			for column in range(self.num_cols):
+				print(self.grid[row][column], end = " ")
 			print()
 
 	def is_inside(self, row, column):
-		if row >= 0 and row < self.num_rows and column >= 0 and column < self.num_columns:
+		if row >= 0 and row < self.num_rows and column >= 0 and column < self.num_cols:
 			return True
 		return False
 
@@ -26,18 +26,18 @@ def is_empty(self, row, column):
 		return False
 
 	def is_row_full(self, row):
-		for column in range(self.num_columns):
+		for column in range(self.num_cols):
 			if self.grid[row][column] == 0:
 				return False
 		return True
 
-	def move_row_down(self, row, num_rows):
-		for column in range(self.num_columns):
-			self.grid[row+num_rows] [column] = self.grid[row][column]
+	def clear_row(self, row):
+		for column in range(self.num_cols):
 			self.grid[row][column] = 0
 
-	def clear_row(self, row):
-		for column in range(self.num_columns):
+	def move_row_down(self, row, num_rows):
+		for column in range(self.num_cols):
+			self.grid[row+num_rows][column] = self.grid[row][column]
 			self.grid[row][column] = 0
 
 	def clear_full_rows(self):
@@ -49,15 +49,16 @@ def clear_full_rows(self):
 			elif completed > 0:
 				self.move_row_down(row, completed)
 		return completed
-    
+
+	def reset(self):
+		for row in range(self.num_rows):
+			for column in range(self.num_cols):
+				self.grid[row][column] = 0
+
 	def draw(self, screen):
 		for row in range(self.num_rows):
-			for column in range(self.num_columns):
+			for column in range(self.num_cols):
 				cell_value = self.grid[row][column]
-				cell_rect = pygame.Rect(11 + column*self.cell_size, 11 + row*self.cell_size, self.cell_size -1 , self.cell_size - 1)
+				cell_rect = pygame.Rect(column*self.cell_size + 11, row*self.cell_size + 11,
+				self.cell_size -1, self.cell_size -1)
 				pygame.draw.rect(screen, self.colors[cell_value], cell_rect)
-
-	def reset(self):
-		for row in range(self.num_rows):
-			for column in range(self.num_columns):
-				self.grid[row][column] = 0