Stan44
1a6ef4f3c4
it is now settings.py settings handles loading the json file for the particles and imports, and potentially other things such as actual settings that are saveable and more
210 lines
8.6 KiB
Python
210 lines
8.6 KiB
Python
#File Name: rendering.py
|
|
|
|
from settings import pygame, json, random, particle_properties
|
|
|
|
class Rendering:
|
|
|
|
def __init__(self, width, height):
|
|
self.screen = pygame.display.set_mode((width, height))
|
|
self.background = pygame.Surface((width, height))
|
|
self.background.fill((0, 0, 0))
|
|
self.width = width
|
|
self.height = height
|
|
self.particle_surface = pygame.Surface((width, height), pygame.SRCALPHA)
|
|
self.particle_colors = {}
|
|
self.button_width, self.button_height = 30, 30
|
|
self.particle_properties = particle_properties
|
|
self.buttons = {}
|
|
self.clear_screen_button = pygame.Rect(915, 10, 50, 30)
|
|
self.load_buttons() # Load buttons dynamically
|
|
self.particle_colors = {}
|
|
for name, properties in particle_properties.items():
|
|
if 'color' in properties:
|
|
self.particle_colors[name.lower()] = properties['color']
|
|
self.categories = {
|
|
'Solids': [],
|
|
'Liquids': [],
|
|
'Gases': [],
|
|
'Special': []
|
|
}
|
|
for particle_name, properties in self.particle_properties.items():
|
|
if properties.get('is_gas'):
|
|
self.categories['Gases'].append(particle_name)
|
|
elif properties.get('liquid'):
|
|
self.categories['Liquids'].append(particle_name)
|
|
elif properties.get('solid'):
|
|
self.categories['Solids'].append(particle_name)
|
|
else:
|
|
self.categories['Special'].append(particle_name)
|
|
|
|
self.current_category = 'Solids'
|
|
self.category_buttons = {}
|
|
self.setup_category_menu()
|
|
|
|
|
|
def setup_category_menu(self):
|
|
# Category buttons at the top
|
|
x_offset = self.width - 350
|
|
y_offset = 10
|
|
for category in self.categories:
|
|
button_rect = pygame.Rect(x_offset, y_offset, 80, 25)
|
|
self.category_buttons[category] = button_rect
|
|
x_offset += 90
|
|
|
|
|
|
def load_buttons(self):
|
|
x_offset = 10
|
|
y_offset = 10
|
|
|
|
for particle_type, properties in self.particle_properties.items():
|
|
if 'color' in properties:
|
|
button_rect = pygame.Rect(x_offset, y_offset, self.button_width, self.button_height)
|
|
self.buttons[particle_type.lower()] = button_rect
|
|
x_offset += self.button_width + 10 # Add spacing between buttons
|
|
|
|
|
|
def draw_particles(self, particles, active_particles, particle_size, particle_colors):
|
|
self.particle_surface = pygame.Surface((self.width, self.height), pygame.SRCALPHA)
|
|
self.particle_surface.fill((0, 0, 0, 0))
|
|
|
|
for x, y in active_particles:
|
|
particle = particles[x][y]
|
|
if not particle:
|
|
continue
|
|
|
|
base_color = particle_colors.get(particle.particle_type, (255, 255, 255))
|
|
color = list(base_color)
|
|
|
|
if particle.is_gas:
|
|
# Enhanced gas visibility
|
|
alpha = random.randint(128, 200)
|
|
color = list(color)
|
|
if len(color) < 4:
|
|
color.append(alpha)
|
|
else:
|
|
color[3] = alpha
|
|
|
|
# Add subtle movement effect
|
|
offset_x = random.randint(-1, 1)
|
|
offset_y = random.randint(-1, 1)
|
|
rect = (x * particle_size + offset_x, y * particle_size + offset_y,
|
|
particle_size, particle_size)
|
|
else:
|
|
rect = (x * particle_size, y * particle_size,
|
|
particle_size, particle_size)
|
|
|
|
pygame.draw.rect(self.particle_surface, color, rect)
|
|
|
|
self.screen.blit(self.background, (0, 0))
|
|
self.screen.blit(self.particle_surface, (0, 0))
|
|
|
|
|
|
def draw_debug_overlay(self, fps, particles):
|
|
# Get mouse position and convert to grid coordinates
|
|
mouse_x, mouse_y = pygame.mouse.get_pos()
|
|
grid_x = mouse_x // 3
|
|
grid_y = mouse_y // 3
|
|
|
|
# Get particle info under cursor
|
|
particle_info = "None"
|
|
if 0 <= grid_x < len(particles) and 0 <= grid_y < len(particles[0]):
|
|
particle = particles[grid_x][grid_y]
|
|
if particle:
|
|
# Include more detailed particle information
|
|
particle_info = f"Type: {particle.particle_type}"
|
|
if hasattr(particle, 'temperature'):
|
|
particle_info += f" | Temp: {particle.temperature}°C"
|
|
if hasattr(particle, 'liquid'):
|
|
particle_info += f" | Liquid: {particle.liquid}"
|
|
if hasattr(particle, 'is_gas'):
|
|
particle_info += f" | Gas: {particle.is_gas}"
|
|
if hasattr(particle, 'solid'):
|
|
particle_info += f" | Solid: {particle.solid}"
|
|
if hasattr(particle, 'mass'):
|
|
particle_info += f" | Mass: {particle.mass}"
|
|
if hasattr(particle, 'velocity'):
|
|
particle_info += f" | Velocity: {particle.velocity}"
|
|
if hasattr(particle, 'friction'):
|
|
particle_info += f" | Friction: {particle.friction}"
|
|
|
|
# Draw debug information
|
|
font = pygame.font.SysFont(None, 24)
|
|
debug_info = [
|
|
f"FPS: {int(fps)}",
|
|
f"Mouse: ({mouse_x}, {mouse_y})",
|
|
f"Grid: ({grid_x}, {grid_y})",
|
|
f"Particle: {particle_info}"
|
|
]
|
|
|
|
y_offset = 10
|
|
for info in debug_info:
|
|
debug_text = font.render(info, True, (255, 255, 255))
|
|
self.screen.blit(debug_text, (10, y_offset))
|
|
y_offset += 25
|
|
|
|
|
|
def draw_buttons(self):
|
|
self.buttons = {}
|
|
|
|
# Draw category buttons vertically on right
|
|
x_offset = self.width - 100
|
|
y_offset = 10
|
|
for category, button in self.category_buttons.items():
|
|
color = (200, 200, 200) if category == self.current_category else (150, 150, 150)
|
|
pygame.draw.rect(self.screen, color, button)
|
|
font = pygame.font.SysFont(None, 20)
|
|
label = font.render(category, True, (0, 0, 0))
|
|
self.screen.blit(label, (button.x + 5, button.y + 5))
|
|
|
|
# Draw particle buttons for current category
|
|
y_offset = 150 # Start particle buttons below categories
|
|
for particle_type in self.categories[self.current_category]:
|
|
if particle_type in self.particle_properties:
|
|
color = self.particle_properties[particle_type].get('color', (255, 255, 255))
|
|
button_rect = pygame.Rect(x_offset, y_offset, 80, 25)
|
|
self.buttons[particle_type] = button_rect
|
|
|
|
pygame.draw.rect(self.screen, color, button_rect)
|
|
pygame.draw.rect(self.screen, (0, 0, 0), button_rect, 2)
|
|
|
|
font = pygame.font.SysFont(None, 20)
|
|
label = font.render(particle_type, True, (0, 0, 0))
|
|
self.screen.blit(label, (x_offset + 5, y_offset + 5))
|
|
|
|
y_offset += 30 # Stack buttons vertically
|
|
|
|
# Draw clear screen button
|
|
self.clear_screen_button = pygame.Rect(x_offset, y_offset + 10, 80, 25)
|
|
pygame.draw.rect(self.screen, (255, 0, 0), self.clear_screen_button)
|
|
font = pygame.font.SysFont(None, 24)
|
|
label = font.render("Clear", True, (255, 255, 255))
|
|
self.screen.blit(label, (self.clear_screen_button.x + 5, self.clear_screen_button.y + 5))
|
|
|
|
|
|
def render_brush_curser(self, x, y, radius):
|
|
# Draw a circle cursor for brushsize
|
|
pygame.draw.circle(self.screen, (255, 255, 255), (x, y), radius)
|
|
|
|
|
|
def draw_brush_size_slider(self, brush_size):
|
|
# Draw the slider for brush size
|
|
pygame.draw.rect(self.screen, (255, 255, 255), (500, 10, 100, 20))
|
|
pygame.draw.rect(self.screen, (0, 0, 0), (500, 10, 100, 20), 2)
|
|
pygame.draw.rect(self.screen, (255, 0, 0), (500 + brush_size, 10, 100 - brush_size * 2, 20))
|
|
label = pygame.font.SysFont(None, 24).render(f"Brush Size: {brush_size}", True, (255, 255, 255))
|
|
self.screen.blit(label, (500, 10))
|
|
|
|
|
|
def clear_screen(self, sim):
|
|
# Store current particle type
|
|
current_type = sim.current_particle_type
|
|
|
|
# Reset simulation grid while preserving particle type
|
|
sim.particles = [[None for _ in range(sim.height)] for _ in range(sim.width)]
|
|
sim.active_particles.clear()
|
|
sim.current_particle_type = current_type
|
|
|
|
# Clear display surfaces
|
|
self.background.fill((0, 0, 0))
|
|
self.particle_surface.fill((0, 0, 0, 0))
|