335 lines
13 KiB
Python
335 lines
13 KiB
Python
"""
|
|
#File Name: sandpypi.py
|
|
# Sandpypi by Stanton.
|
|
# Project name is a placeholder.
|
|
# This has been a multimonth or year project i have time blindness sorta.
|
|
# This is my most functional system for falling sand in python yet i took some things i learned in JS.
|
|
# This needs further optimizations to core performance sections.
|
|
|
|
The main function to run the Sandpypi program.
|
|
|
|
This function initializes the Pygame environment, creates the simulation and rendering objects, and enters the main event loop.
|
|
It handles user input events such as mouse clicks, mouse wheel scrolling, and keyboard presses.
|
|
It also updates the simulation, draws the particles, buttons, and other UI elements, and manages the settings menu.
|
|
The main loop runs at a target frame rate of 60 FPS, with the actual frame rate displayed in the debug overlay.
|
|
"""
|
|
import cProfile
|
|
import pstats
|
|
from settings import pygame, engine_settings
|
|
from rendering import Rendering
|
|
"""
|
|
This is for the future physics engine until i figure out a better method used for testing right now.
|
|
#import os
|
|
#import sys
|
|
#sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
|
"""
|
|
from sim import Simulation
|
|
|
|
def update_simulation(sim, dt, engine_settings):
|
|
"""Update simulation state"""
|
|
sim.simulate_step(dt, engine_settings)
|
|
|
|
def render_frame(rendering, sim, mouse_pos):
|
|
"""Render all visual elements"""
|
|
# Draw particles
|
|
rendering.draw_particles(sim.particles, sim.active_particles, sim.particle_size, rendering.particle_colors)
|
|
|
|
# Draw UI elements
|
|
rendering.draw_buttons()
|
|
rendering.draw_brush_size_slider(sim.brush_size)
|
|
|
|
# Draw brush cursor
|
|
mouse_x, mouse_y = mouse_pos
|
|
rendering.render_brush_cursor(mouse_x, mouse_y, sim.brush_size * sim.particle_size)
|
|
|
|
def handle_input(event, sim, rendering, settings_visible, zoom_active, zoom_locked, zoom_pos):
|
|
"""Handle all input events"""
|
|
if event.type == pygame.MOUSEBUTTONDOWN:
|
|
return handle_mouse_down(event, sim, rendering, settings_visible, zoom_active)
|
|
elif event.type == pygame.MOUSEBUTTONUP:
|
|
return handle_mouse_up(event)
|
|
elif event.type == pygame.KEYDOWN:
|
|
return handle_key_press(event, rendering, sim)
|
|
return None
|
|
|
|
def handle_mouse_down(event, sim, rendering, settings_visible, zoom_active):
|
|
"""Handle mouse button down events"""
|
|
mouse_pos = pygame.mouse.get_pos()
|
|
in_settings_area = False
|
|
|
|
if settings_visible:
|
|
settings_rect = pygame.Rect(rendering.width - 320, 100, 300, 400)
|
|
in_settings_area = settings_rect.collidepoint(mouse_pos)
|
|
|
|
if event.button == 4: # Mouse wheel up
|
|
sim.brush_size = min(sim.brush_size + 1, sim.max_brush_size)
|
|
elif event.button == 5: # Mouse wheel down
|
|
sim.brush_size = max(sim.brush_size - 1, 1)
|
|
elif event.button == 1: # Left click
|
|
return handle_left_click(mouse_pos, sim, rendering, settings_visible, in_settings_area, zoom_active)
|
|
elif event.button == 3: # Right click
|
|
return {'mouse_down_right': True}
|
|
elif event.button == 2: # Middle click
|
|
return {'mouse_down_middle': True}
|
|
return {}
|
|
|
|
def handle_left_click(mouse_pos, sim, rendering, settings_visible, in_settings_area, zoom_active):
|
|
"""Handle left click interactions"""
|
|
result = {'mouse_down_left': False, 'settings_visible': settings_visible, 'over_button': False}
|
|
|
|
if rendering.settings_button.collidepoint(mouse_pos):
|
|
result['settings_visible'] = not settings_visible
|
|
result['over_button'] = True
|
|
return result
|
|
|
|
if zoom_active:
|
|
result['zoom_locked'] = not result.get('zoom_locked', False)
|
|
if result['zoom_locked']:
|
|
result['zoom_pos'] = mouse_pos
|
|
return result
|
|
|
|
if settings_visible and in_settings_area:
|
|
handle_settings_click(mouse_pos, sim)
|
|
result['over_button'] = True
|
|
return result
|
|
|
|
if not in_settings_area:
|
|
if handle_ui_click(mouse_pos, sim, rendering):
|
|
result['over_button'] = True
|
|
else:
|
|
result['mouse_down_left'] = True
|
|
|
|
return result
|
|
|
|
def handle_settings_click(mouse_pos, sim):
|
|
"""Handle clicks in settings menu"""
|
|
settings_menu_y = 100
|
|
relative_y = mouse_pos[1] - settings_menu_y
|
|
setting_index = relative_y // 30
|
|
if 0 <= setting_index < len(engine_settings):
|
|
setting_name = list(engine_settings.keys())[setting_index]
|
|
engine_settings[setting_name] = not engine_settings[setting_name]
|
|
|
|
def handle_ui_click(mouse_pos, sim, rendering):
|
|
"""Handle clicks on UI elements"""
|
|
for category, button in rendering.category_buttons.items():
|
|
if button.collidepoint(mouse_pos):
|
|
rendering.current_category = category
|
|
return True
|
|
|
|
for particle_type, button in rendering.buttons.items():
|
|
if button.collidepoint(mouse_pos):
|
|
sim.current_particle_type = particle_type
|
|
return True
|
|
|
|
if rendering.clear_screen_button.collidepoint(mouse_pos):
|
|
rendering.clear_screen(sim)
|
|
return True
|
|
|
|
return False
|
|
|
|
def handle_mouse_up(event):
|
|
"""Handle mouse button up events"""
|
|
if event.button == 1:
|
|
return {'mouse_down_left': False}
|
|
elif event.button == 3:
|
|
return {'mouse_down_right': False}
|
|
elif event.button == 2:
|
|
return {'mouse_down_middle': False}
|
|
return {}
|
|
|
|
def handle_key_press(event, rendering, sim):
|
|
"""Handle keyboard press events"""
|
|
if event.key == pygame.K_ESCAPE:
|
|
print("Escape button pressed")
|
|
print(f"Exiting Program {__file__}")
|
|
return {'running': False}
|
|
elif event.key == pygame.K_SPACE:
|
|
engine_settings['pause_sim'] = not engine_settings['pause_sim']
|
|
elif event.key == pygame.K_c:
|
|
rendering.clear_screen(sim)
|
|
sim.reset_particle_count()
|
|
elif event.key == pygame.K_z:
|
|
return {'zoom_active': True, 'zoom_locked': False, 'zoom_pos': pygame.mouse.get_pos()}
|
|
return {}
|
|
|
|
def main():
|
|
pygame.init()
|
|
clock = pygame.time.Clock()
|
|
width = 1024
|
|
height = 768
|
|
screen = pygame.display.set_mode((width, height), pygame.HWSURFACE | pygame.DOUBLEBUF)
|
|
sim = Simulation(width, height)
|
|
rendering = Rendering(width, height)
|
|
|
|
# State variables
|
|
mouse_down_left = False
|
|
mouse_down_right = False
|
|
mouse_down_middle = False
|
|
over_button = False
|
|
zoom_active = False
|
|
zoom_locked = False
|
|
zoom_pos = None
|
|
settings_visible = False
|
|
running = True
|
|
|
|
while running:
|
|
# Clear screen at start of frame
|
|
screen.fill((0, 0, 0))
|
|
|
|
fps = clock.get_fps()
|
|
dt = clock.tick(1000) / 1000
|
|
keys = pygame.key.get_pressed()
|
|
mouse_pos = pygame.mouse.get_pos()
|
|
zoom_active = keys[pygame.K_z]
|
|
|
|
# Handle events
|
|
for event in pygame.event.get():
|
|
if event.type == pygame.QUIT:
|
|
running = False
|
|
continue
|
|
|
|
if event.type == pygame.MOUSEBUTTONDOWN:
|
|
mouse_pos = pygame.mouse.get_pos()
|
|
in_settings_area = False
|
|
|
|
if settings_visible:
|
|
settings_rect = pygame.Rect(rendering.width - 320, 100, 300, 400)
|
|
in_settings_area = settings_rect.collidepoint(mouse_pos)
|
|
|
|
if event.button == 4: # Mouse wheel up
|
|
sim.brush_size = min(sim.brush_size + 1, sim.max_brush_size)
|
|
elif event.button == 5: # Mouse wheel down
|
|
sim.brush_size = max(sim.brush_size - 1, 1)
|
|
elif event.button == 1: # Left click
|
|
over_button = False
|
|
|
|
# Check settings button first
|
|
if rendering.settings_button.collidepoint(mouse_pos):
|
|
settings_visible = not settings_visible
|
|
over_button = True
|
|
|
|
elif zoom_active:
|
|
zoom_locked = not zoom_locked
|
|
if zoom_locked:
|
|
zoom_pos = mouse_pos
|
|
|
|
# Handle settings menu interactions
|
|
elif settings_visible and in_settings_area:
|
|
relative_y = mouse_pos[1] - 100 # settings_menu_y
|
|
setting_index = relative_y // 30
|
|
if 0 <= setting_index < len(engine_settings):
|
|
setting_name = list(engine_settings.keys())[setting_index]
|
|
engine_settings[setting_name] = not engine_settings[setting_name]
|
|
over_button = True
|
|
|
|
elif not in_settings_area:
|
|
# Check category buttons
|
|
for category, button in rendering.category_buttons.items():
|
|
if button.collidepoint(mouse_pos):
|
|
rendering.current_category = category
|
|
over_button = True
|
|
break
|
|
|
|
# Check particle buttons
|
|
if not over_button:
|
|
for particle_type, button in rendering.buttons.items():
|
|
if button.collidepoint(mouse_pos):
|
|
sim.current_particle_type = particle_type
|
|
over_button = True
|
|
break
|
|
|
|
# Check clear screen button
|
|
if rendering.clear_screen_button.collidepoint(mouse_pos):
|
|
rendering.clear_screen(sim)
|
|
particle_count = 0
|
|
over_button = True
|
|
|
|
if not over_button and not in_settings_area:
|
|
mouse_down_left = True
|
|
|
|
elif event.button == 3: # Right click
|
|
mouse_down_right = True
|
|
elif event.button == 2: # Middle click
|
|
mouse_down_middle = True
|
|
|
|
elif event.type == pygame.MOUSEBUTTONUP:
|
|
if event.button == 1:
|
|
mouse_down_left = False
|
|
elif event.button == 3:
|
|
mouse_down_right = False
|
|
elif event.button == 2:
|
|
mouse_down_middle = False
|
|
|
|
elif event.type == pygame.KEYDOWN:
|
|
if event.key == pygame.K_ESCAPE:
|
|
running = False
|
|
elif event.key == pygame.K_SPACE:
|
|
engine_settings['pause_sim'] = not engine_settings['pause_sim']
|
|
elif event.key == pygame.K_c:
|
|
rendering.clear_screen(sim)
|
|
elif event.key == pygame.K_z:
|
|
zoom_active = True
|
|
zoom_locked = False
|
|
zoom_pos = pygame.mouse.get_pos()
|
|
|
|
# Update simulation if not paused
|
|
if not engine_settings['pause_sim']:
|
|
sim.simulate_step(dt, engine_settings)
|
|
|
|
# Handle continuous mouse input
|
|
if mouse_down_left and not over_button:
|
|
x, y = mouse_pos
|
|
if sim.current_particle_type not in ['wind', 'air']:
|
|
sim.create_particle_circle(x, y)
|
|
else:
|
|
sim.add_wind_zone(x, y)
|
|
|
|
if mouse_down_right:
|
|
x, y = mouse_pos
|
|
sim.clear_particles_circle(x, y)
|
|
|
|
if mouse_down_middle:
|
|
x, y = mouse_pos
|
|
sim.create_particle(x, y)
|
|
|
|
# Draw everything in correct order
|
|
rendering.draw_particles(sim.particles, sim.active_particles, sim.particle_size, rendering.particle_colors)
|
|
rendering.draw_buttons()
|
|
rendering.draw_brush_size_slider(sim.brush_size)
|
|
rendering.render_brush_cursor(mouse_pos[0], mouse_pos[1], sim.brush_size * sim.particle_size)
|
|
|
|
# Handle zoom window
|
|
if zoom_active or zoom_locked:
|
|
current_zoom_pos = zoom_pos if zoom_locked else mouse_pos
|
|
zoom_surface = rendering.draw_zoom_window(sim.particles, sim.particle_size,
|
|
rendering.particle_colors, current_zoom_pos)
|
|
zoom_x = 10 if current_zoom_pos[0] > width/2 else width - 110
|
|
zoom_y = 10 if current_zoom_pos[1] > height/2 else height - 110
|
|
screen.blit(zoom_surface, (zoom_x, zoom_y))
|
|
|
|
# Draw settings and debug overlay last
|
|
if settings_visible:
|
|
settings_menu = rendering.draw_settings_menu()
|
|
rendering.screen.blit(settings_menu, (rendering.width - 320, 100))
|
|
|
|
rendering.draw_debug_overlay(fps, sim)
|
|
pygame.display.flip()
|
|
|
|
pygame.quit()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
# Profile the application
|
|
profiler = cProfile.Profile()
|
|
profiler.enable()
|
|
|
|
main()
|
|
|
|
profiler.disable()
|
|
# Write profiling results to file
|
|
with open('profile_results.log', 'w') as f:
|
|
stats = pstats.Stats(profiler, stream=f)
|
|
stats.sort_stats('cumulative')
|
|
stats.print_stats()
|