video code

Author: educ8s

grid.py

@@ -1,47 +1,46 @@
 import pygame
-from particle import SandParticle
-from particle import RockParticle
 
 class Grid:
 	def __init__(self, width, height, cell_size):
 		self.rows = height // cell_size
 		self.columns = width // cell_size
 		self.cell_size = cell_size
 		self.cells = [[None for _ in range(self.columns)] for _ in range(self.rows)]
-	
+
 	def draw(self, window):
-		for row in range(self.rows): 
+		for row in range(self.rows):
 			for column in range(self.columns):
 				particle = self.cells[row][column]
 				if particle is not None:
 					color = particle.color
-					pygame.draw.rect(window, color, (column * self.cell_size, row * self.cell_size, self.cell_size, self.cell_size))
+					pygame.draw.rect(window, color, 
+					(column * self.cell_size, row * self.cell_size, self.cell_size, self.cell_size))
 
 	def add_particle(self, row, column, particle_type):
 		if 0 <= row < self.rows and 0 <= column < self.columns and self.is_cell_empty(row, column):
-		 	self.cells[row][column] = particle_type()
+			self.cells[row][column] = particle_type()
 
-	def set_cell(self, row, column, particle):
+	def remove_particle(self, row, column):
 		if 0 <= row < self.rows and 0 <= column < self.columns:
-		 	self.cells[row][column] = particle
+			self.cells[row][column] = None
 
 	def is_cell_empty(self, row, column):
 		if 0 <= row < self.rows and 0 <= column < self.columns:
 			if self.cells[row][column] is None:
 				return True
 		return False
 
-	def clear(self):
-		for row in range(self.rows):
-			for column in range(self.columns):
-				self.set_cell(row, column, None)
+	def set_cell(self, row, column, particle):
+		if not(0 <= row < self.rows and 0 <= column < self.columns):
+			return
+		self.cells[row][column] = particle
 
-	def remove_particle(self, row, column):
+	def get_cell(self, row, column):
 		if 0 <= row < self.rows and 0 <= column < self.columns:
-			self.cells[row][column] = None
+			return self.cells[row][column]
+		return None
 
-	def get_cell(self, row, column):
-	    if 0 <= row < self.rows and 0 <= column < self.columns:
-	        return self.cells[row][column]  # Return the cell content
-	    return None
- 
+	def clear(self):
+		for row in range(self.rows):
+			for column in range(self.columns):
+				self.remove_particle(row, column)

main.py

@@ -1,31 +1,31 @@
-import pygame, sys
+import pygame
 from simulation import Simulation
-from particle import SandParticle
 
-GREY = (29, 29, 29)
+pygame.init()
+pygame.mouse.set_visible(False)
+
 WINDOW_WIDTH = 800
 WINDOW_HEIGHT = 600
 CELL_SIZE = 6
-
 FPS = 120
-pygame.init()
-pygame.mouse.set_visible(False)
+GREY = (29, 29, 29)
 
 window = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
 pygame.display.set_caption("Falling Sand")
 
 clock = pygame.time.Clock()
 simulation = Simulation(WINDOW_WIDTH, WINDOW_HEIGHT, CELL_SIZE)
 
-# main loop
+#Simulation Loop
 while True:
-	#1. Event Handling
+
+	# 1. Event Handling
 	simulation.handle_controls()
 
-	#2. Updating State
+	# 2. Updating State
 	simulation.update()
 
-	#3. Drawing
+	# 3. Drawing
 	window.fill(GREY)
 	simulation.draw(window)
 

particle.py

@@ -1,29 +1,30 @@
-import random, colorsys
+import random
+import colorsys
 
 class SandParticle:
 	def __init__(self):
 		self.color = random_color((0.1, 0.12), (0.5, 0.7), (0.7, 0.9))
 
 	def update(self, grid, row, column):
-	    if grid.is_cell_empty(row + 1, column):
-	        return row + 1, column
-	    
-	    offsets = [1, -1]
-	    random.shuffle(offsets)
-	    for offset in offsets:
-	        new_column = column + offset
-	        if grid.is_cell_empty(row + 1, new_column):  # Check diagonal cells
-	            return row + 1, new_column
+		if grid.is_cell_empty(row + 1, column):
+			return row + 1, column
+		else:
+			offsets = [-1, 1]
+			random.shuffle(offsets)
+			for offset in offsets:
+				new_column = column + offset
+				if grid.is_cell_empty(row +1, new_column):
+					return row + 1, new_column
 
-	    return row, column
+		return row, column
 
 class RockParticle:
 	def __init__(self):
 		self.color = random_color((0.0, 0.1), (0.1, 0.3), (0.3, 0.5))
 
 def random_color(hue_range, saturation_range, value_range):
-		hue = random.uniform(*hue_range) 
-		saturation = random.uniform(*saturation_range)
-		value = random.uniform(*value_range)
-		r, g, b = colorsys.hsv_to_rgb(hue, saturation, value)
-		return int(r * 255), int(g * 255), int(b * 255)
+	hue = random.uniform(*hue_range)
+	saturation = random.uniform(*saturation_range)
+	value = random.uniform(*value_range)
+	r, g, b = colorsys.hsv_to_rgb(hue, saturation, value)
+	return int(r * 255), int(g * 255), int(b * 255)

simulation.py

@@ -5,8 +5,8 @@
 
 class Simulation:
 	def __init__(self, width, height, cell_size):
-		self.cell_size = cell_size
 		self.grid = Grid(width, height, cell_size)
+		self.cell_size = cell_size
 		self.mode = "sand"
 		self.brush_size = 3
 
@@ -15,66 +15,63 @@ def draw(self, window):
 		self.draw_brush(window)
 
 	def add_particle(self, row, column):
-	    if self.mode == "sand":
-	        if random.random() < 0.2:
-	            particle = SandParticle
-	            self.grid.add_particle(row, column, particle)
-	    elif self.mode == "rock":
-	        particle = RockParticle
-	        self.grid.add_particle(row, column, particle)
+		if self.mode == "sand":
+			if random.random() < 0.15:
+				self.grid.add_particle(row, column, SandParticle)
+		elif self.mode == "rock":
+			self.grid.add_particle(row, column, RockParticle)
+
+	def remove_particle(self, row, column):
+		self.grid.remove_particle(row, column)
 
 	def update(self):
-		orientation = random.randint(0, 1)	
-		for row in range(self.grid.rows - 1, -1, -1):  # Start from the bottom		
-			if orientation == 0:
-				for column in range(self.grid.columns - 1, -1, -1):
-					self.process_particle(row, column)
+		for row in range(self.grid.rows - 2, -1, -1):
+			if row % 2 == 0:
+				column_range = range(self.grid.columns)
 			else:
-				for column in range(self.grid.columns):
-					self.process_particle(row, column)
+				column_range = reversed(range(self.grid.columns))
 
-	def process_particle(self, row, column):
-		particle = self.grid.get_cell(row, column)
-		if isinstance(particle, SandParticle):
-			new_pos = particle.update(self.grid, row, column)
-			if new_pos != (row, column):
-				self.grid.set_cell(new_pos[0], new_pos[1], particle)
-				self.grid.set_cell(row, column, None)
+			for column in column_range:
+				particle = self.grid.get_cell(row, column)
+				if isinstance(particle, SandParticle):
+					new_pos = particle.update(self.grid, row, column)
+					if new_pos != (row, column):
+						self.grid.set_cell(new_pos[0], new_pos[1], particle)
+						self.grid.remove_particle(row, column)
 
 	def restart(self):
 		self.grid.clear()
 
-	def remove_particle(self, row, column):
-		self.grid.remove_particle(row, column)
-
 	def handle_controls(self):
 		for event in pygame.event.get():
 			if event.type == pygame.QUIT:
 				pygame.quit()
 				sys.exit()
-
 			if event.type == pygame.KEYDOWN:
 				self.handle_key(event)
-		
+
 		self.handle_mouse()
 
 	def handle_key(self, event):
-		if event.type == pygame.KEYDOWN:
-			if event.key == pygame.K_SPACE:
-				self.restart()
-			elif event.key == pygame.K_s:
-				self.mode = "sand"
-			elif event.key == pygame.K_r:
-				self.mode = "rock"
-			elif event.key == pygame.K_e:
-				self.mode = "erase"
+		if event.key == pygame.K_SPACE:
+			self.restart()
+		elif event.key == pygame.K_s:
+			print("Sand Mode")
+			self.mode = "sand"
+		elif event.key == pygame.K_r:
+			print("Rock Mode")
+			self.mode = "rock"
+		elif event.key == pygame.K_e:
+			print("Eraser Mode")
+			self.mode = "erase"
 
 	def handle_mouse(self):
 		buttons = pygame.mouse.get_pressed()
 		if buttons[0]:
 			pos = pygame.mouse.get_pos()
 			row = pos[1] // self.cell_size
 			column = pos[0] // self.cell_size
+			
 			self.apply_brush(row, column)
 
 	def apply_brush(self, row, column):
@@ -89,23 +86,18 @@ def apply_brush(self, row, column):
 					self.add_particle(current_row, current_col)
 
 	def draw_brush(self, window):
-
 		mouse_pos = pygame.mouse.get_pos()
 		column = mouse_pos[0] // self.cell_size
 		row = mouse_pos[1] // self.cell_size
-		
-		cursor_size = self.brush_size * self.cell_size
+
+		brush_visual_size = self.brush_size * self.cell_size
 		color = (255, 255, 255)
 
 		if self.mode == "rock":
-			color = (100, 100, 100) 
+			color = (100, 100, 100)
 		elif self.mode == "sand":
-			color = (185, 142, 66)  
+			color = (185, 142, 66)
 		elif self.mode == "erase":
-			color = (255, 105, 180) 
+			color = (255, 105, 180)
 
-		pygame.draw.rect(
-			window,
-			color,
-			(column * self.cell_size, row * self.cell_size, cursor_size, cursor_size),
-		)
+		pygame.draw.rect(window, color, (column * self.cell_size, row * self.cell_size, brush_visual_size, brush_visual_size))