stan44/sandpypi
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ititial commit

Browse Source 
fixed .gitignore as well.
This commit is contained in:
Stan44 2024-12-26 04:13:14 -06:00
parent 73470225d0
commit 1f11016180
4 changed files with 165 additions and 11796 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

165
.gitignore vendored Normal file
View File

@ -0,0 +1,165 @@
# ---> Python
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
# C extensions
*.so
# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
share/python-wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
# Unit test / coverage reports
htmlcov/
.tox/
.nox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
*.py,cover
.hypothesis/
.pytest_cache/
cover/
# Translations
*.mo
*.pot
# Django stuff:
*.log
local_settings.py
db.sqlite3
db.sqlite3-journal
# Flask stuff:
instance/
.webassets-cache
# Scrapy stuff:
.scrapy
# Sphinx documentation
docs/_build/
# PyBuilder
.pybuilder/
target/
# Jupyter Notebook
.ipynb_checkpoints
# IPython
profile_default/
ipython_config.py
# pyenv
# For a library or package, you might want to ignore these files since the code is
# intended to run in multiple environments; otherwise, check them in:
# .python-version
# pipenv
# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
# However, in case of collaboration, if having platform-specific dependencies or dependencies
# having no cross-platform support, pipenv may install dependencies that don't work, or not
# install all needed dependencies.
#Pipfile.lock
# poetry
# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
# This is especially recommended for binary packages to ensure reproducibility, and is more
# commonly ignored for libraries.
# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
#poetry.lock
# pdm
# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
#pdm.lock
# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
# in version control.
# https://pdm.fming.dev/#use-with-ide
.pdm.toml
# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
__pypackages__/
# Celery stuff
celerybeat-schedule
celerybeat.pid
# SageMath parsed files
*.sage.py
# Environments
.env
.venv
env/
venv/
ENV/
env.bak/
venv.bak/
# Spyder project settings
.spyderproject
.spyproject
# Rope project settings
.ropeproject
# mkdocs documentation
/site
# mypy
.mypy_cache/
.dmypy.json
dmypy.json
# Pyre type checker
.pyre/
# pytype static type analyzer
.pytype/
# Cython debug symbols
cython_debug/
# PyCharm
# JetBrains specific template is maintained in a separate JetBrains.gitignore that can
# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
# and can be added to the global gitignore or merged into this file. For a more nuclear
# option (not recommended) you can uncomment the following to ignore the entire idea folder.
#.idea/
current_stations.html
forecast_data.json
openapi.json

11458
simulation_core.c
View File

File diff suppressed because it is too large Load Diff

BIN
simulation_core.cp312-win_amd64.pyd
View File

Binary file not shown.

338
testcode.py
View File

@ -1,338 +0,0 @@
#File Name: sim.py
#Load the imports. Pygame is what makes this even work and so simple may consider other engines for performance depends on learning curve.
from imports import json, random
# Load particle properties from json so we know what particles we got and how they should be simulated.
try:
with open('sandpypi/particles.json') as f:
particle_properties = json.load(f)
except (FileNotFoundError, json.JSONDecodeError):
print("Error loading particles.json")
particle_properties = {}
class Particle:
def __init__(self, position, velocity, mass, particle_type, properties, temperature=20):
self.position = position # (x, y)
self.velocity = velocity # (vx, vy)
self.mass = mass
self.particle_type = particle_type
self.temperature = temperature
# Initialize additional properties from the dictionary
self.flamability = properties.get("flamability", 0.0)
self.viscosity = properties.get("viscosity", 1.0)
self.is_gas = properties.get("is_gas", False)
self.electric_charge = properties.get("electric_charge", 0)
@classmethod
def from_type(cls, position, particle_type, properties):
default_velocity = [0, 0]
default_mass = properties.get("mass", 1.0)
return cls(position, default_velocity, default_mass, particle_type, properties)
class Simulation:
# the main class of the simulation.
def __init__(self, width, height, x=0, y=0):
self.x = x
self.y = y
self.new_x = 0
self.new_y = 0
self.width = width
self.height = height
self.particle_size = 3
self.particles = [[None for _ in range(height)] for _ in range(width)]
self.active_particles = set()
self.cell_size = 32
self.spatial_grid = {}
self.brush_size = 1
self.max_brush_size = 20
self.particle_properties = particle_properties
self.current_particle_type = 'sand'
self.gravity = 9.8 # m/s^2, adjustable based on the scale of simulation
self.wind = [0.0, 0.0] # Global wind vector (x, y)
def calculate_forces(self, particle, x, y):
"""Calculate net forces acting on a particle."""
fx, fy = 0.0, particle.mass * self.gravity # Start with gravity
# Apply wind force
fx += self.wind[0] * (1.0 if not particle.is_gas else 0.5) # Gases affected less
fy += self.wind[1] * (1.0 if not particle.is_gas else 0.5)
# Apply drag force (opposes velocity)
drag = particle.viscosity * -1
fx += drag * particle.velocity[0]
fy += drag * particle.velocity[1]
# Interactions with neighbors
for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
nx, ny = x + dx, y + dy
if 0 <= nx < self.width and 0 <= ny < self.height:
neighbor = self.particles[nx][ny]
if neighbor:
if neighbor.temperature > particle.temperature:
fy += (neighbor.temperature - particle.temperature) * 0.1
if neighbor.is_gas and not particle.is_gas:
fx += dx * 0.1
fy += dy * 0.1
return fx, fy
def ignite_particle(self, particle):
"""Handle ignition and burning of flammable particles."""
if particle.flamability > 0.5 and particle.temperature > 150: #threshold
particle.type = 'fire'
particle.temperature += 200
def spread_fire(self):
"""Spread fire to neighboring particles."""
for x, y in list(self.active_particles):
particle = self.particles[x][y]
if particle and particle.type == 'fire':
for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
nx, ny = x + dx, y + dy
if 0 <= nx < self.width and 0 <= ny < self.height:
neighbor = self.particles[nx][ny]
if neighbor and neighbor.flamability > 0:
self.ignite_particle(neighbor)
def simulate_step(self, dt):
"""Run a single step of the simulation."""
self.apply_physics(dt)
self.spread_fire()
def get_cell_key(self, x, y):
# Convert coordinates to grid cell
cell_x = x // self.cell_size
cell_y = y // self.cell_size
return (cell_x, cell_y)
def add_to_spatial_grid(self, particle, x, y):
cell_key = self.get_cell_key(x, y)
if cell_key not in self.spatial_grid:
self.spatial_grid[cell_key] = set()
self.spatial_grid[cell_key].add((x, y))
def remove_from_spatial_grid(self, x, y):
cell_key = self.get_cell_key(x, y)
if cell_key in self.spatial_grid:
self.spatial_grid[cell_key].discard((x, y))
def create_particle_circle(self, center_x, center_y):
brush_size = int(self.brush_size)
for dx in range(-brush_size, brush_size + 1):
for dy in range(-brush_size, brush_size + 1):
if dx*dx + dy*dy <= brush_size*brush_size: # Circle check
self.create_particle(center_x + dx * self.particle_size,
center_y + dy * self.particle_size)
def create_particle(self, x, y):
print(f"Creating particle at ({x}, {y})")
particle_type = self.current_particle_type.lower()
if particle_type in self.particle_properties:
grid_x = x // self.particle_size
grid_y = y // self.particle_size
if 0 <= grid_x < self.width and 0 <= grid_y < self.height:
properties = self.particle_properties[particle_type]
new_particle = type('Particle', (), {})
new_particle.x = grid_x
new_particle.y = grid_y
new_particle.type = particle_type
velocity_scalar = properties.get('velocity', 0)
new_particle.velocity = [0, velocity_scalar]
new_particle.acceleration = [0, self.gravity]
for key, value in properties.items():
if key != 'velocity':
setattr(new_particle, key, value)
if 0 <= grid_x < len(self.particles) and 0 <= grid_y < len(self.particles[0]):
self.particles[grid_x][grid_y] = new_particle
self.active_particles.add((grid_x, grid_y))
def apply_gravity(self, dt):
# Simplfied gravity which has enabled us to have a working system need improvement/more physics simulations.
self.spatial_grid.clear()
# Populate spatial grid
for x, y in self.active_particles:
self.add_to_spatial_grid(self.particles[x][y], x, y)
# Now we only check particles in nearby cells
for x, y in list(self.active_particles):
cell_key = self.get_cell_key(x, y)
nearby_cells = [
(cell_key[0] + dx, cell_key[1] + dy)
for dx in [-1, 0, 1]
for dy in [-1, 0, 1]
]
for x, y in list(self.active_particles):
particle = self.particles[x][y]
if not particle:
self.active_particles.discard((x, y))
continue
if particle.type == 'wall':
continue
new_x, new_y = x, y + 1
# Add boundary check before accessing array. This doesn't check the outer boundariers of the grid but instead boundaries in programming to ensure smooth run
# There does need to be a Boundary check system perfably something that can be enabled or disabled in a settings menu for the simulation.
# that system would be to ensure particles do not leave the boundaries of the grid
if not (0 <= new_x < self.width and 0 <= new_y < self.height):
continue
particle.velocity[1] += self.gravity * dt
if hasattr(particle, 'liquid') and particle.liquid:
# Try to move down first
if y + 1 < self.height and self.particles[x][y + 1] is None:
new_x, new_y = x, y + 1
# If can't move down, try to spread horizontally
elif y + 1 < self.height:
spread_directions = [(-1, 0), (1, 0)] # Left and right
random.shuffle(spread_directions) # Randomize flow direction
moved = False
for dx, dy in spread_directions:
new_x, new_y = x + dx, y
if (0 <= new_x < self.width and
self.particles[new_x][new_y] is None):
moved = True
break
if not moved:
continue
else:
continue
#placeholder for gas.
if hasattr(particle, 'Gas') and particle.Gas:
if new_x > 0 and self.particles[new_x - 1][new_y] is None:
new_x -= 1
elif new_x < self.width - 1 and self.particles[new_x + 1][new_y] is None:
new_x += 1
#placeholder for fire
if hasattr(particle, 'fire') and particle.fire:
# Check if there's a liquid
if y + 1 < self.height and self.particles[x][y + 1] is not None and self.particles[x][y + 1].liquid:
# Check if there's a flammable particle below
if y + 2 < self.height and self.particles[x][y + 2] is not None and self.particles[x][y + 2].flammable:
# Set the particle below to burning
self.particles[x][y + 1].burning = True
# Set the particle two below to flammable
self.ignite_particle(x, y + 2)
# Set the particle below to flammable
self.particles[x][y + 1].flammable = True
# Set the particle two below to flammable
self.particles[x][y + 2].flammable = True
# Check if Solid is flammable
# I believe this is being done horribly wrong plus the system isn't accounting for some of this yet.
if hasattr(particle, 'Solid') and particle.Solid:
if y + 1 < self.height and self.particles[x][y + 1] is not None and self.particles[x][y + 1].flammable:
self.particles[x][y + 1].burning = True
self.ignite_particle(x, y + 1)
self.ignite_particle(x, y + 2)
self.ignite_particle(x, y + 3)
if self.particles[new_x][new_y] is None:
self.particles[x][y] = None
self.particles[new_x][new_y] = particle
self.active_particles.add((new_x, new_y))
self.active_particles.discard((x, y))
particle.x, particle.y = new_x, new_y
"""
# Complicated physics engine non working ATM.
def apply_physics(self, dt):
#Apply all physics effects to active particles.
new_active_particles = set()
for x, y in list(self.active_particles):
particle = self.particles[x][y]
if not particle:
continue
# Update forces based on particle properties
fx, fy = self.calculate_forces(particle, x, y)
# Update velocity
particle.velocity[0] += (fx / particle.mass) * dt
particle.velocity[1] += (fy / particle.mass) * dt
# Apply friction (simplified as proportional to velocity)
particle.velocity[0] *= 1 - particle.friction
particle.velocity[1] *= 1 - particle.friction
# Update position
new_x = int(particle.position[0] + particle.velocity[0] * dt)
new_y = int(particle.position[1] + particle.velocity[1] * dt)
# Handle collisions and boundary conditions
if 0 <= new_x < self.width and 0 <= new_y < self.height:
if self.particles[new_x][new_y] is None: # Move particle
self.particles[x][y] = None
self.particles[new_x][new_y] = particle
particle.position = [new_x, new_y]
new_active_particles.add((new_x, new_y))
else: # Handle collisions (simple exchange of velocity)
particle.velocity[0] *= -0.5
particle.velocity[1] *= -0.5
else: # Boundary collision
particle.velocity[0] *= -0.5
particle.velocity[1] *= -0.5
self.active_particles = new_active_particles
"""
""" if particle.is_gas:
# Gas-specific movement
dx = random.uniform(-1, 1)
dy = random.uniform(-2, 0) # Bias upward
new_x = int(x + dx)
new_y = int(y + dy)
if 0 <= new_x < self.width and 0 <= new_y < self.height:
if self.particles[new_x][new_y] is None:
self.particles[x][y] = None
self.particles[new_x][new_y] = particle
new_active_particles.add((new_x, new_y))
self.active_particles.discard((x, y))
else:
# Regular particle physics
particle.velocity[0] += (fx / particle.mass) * dt
particle.velocity[1] += (fy / particle.mass) * dt
if particle.liquid:
# Enhanced liquid spreading
spread_chance = 0.8
if random.random() < spread_chance:
dx = random.choice([-1, 1])
if (0 <= x + dx < self.width and
self.particles[x + dx][y] is None):
new_x = x + dx
new_y = y
self.particles[x][y] = None
self.particles[new_x][new_y] = particle
new_active_particles.add((new_x, new_y))
continue"""