Ich nenne in dieser nachricht zwei versionen von skripten der gewünschten anwendung,…
- User
Ich nenne in dieser nachricht zwei versionen von skripten der gewünschten anwendung, einer sandbox ameisen kolonie simulation welche nach möglichst einfachen, aber auch realistischen grundregeln, möglichst ohne feste hardcoded inhalte auskommt und möglichst immer auf reale gegebenheiten basieren bzw diese nachempfinden soll. Die anwendung soll möglichst einfache grundregeln wie sie in der natur vorkommen nutzen um einfache algorythmen mit authentischen ergebnissen zu erstellen. Die ergebnisse sollen nicht erzwungen werden sondern auf natürliche weise im laufe der simulation von selbst entstehen und sich auf grundlage der einfachen realistischen algorythmen entwickeln. die ameisen sollten sich in einer authentischen, zufällig generierten voxel umgebung mit strukturen entsprechen der ameisengröße entwickeln und ein nest gründen. alle verhaltensweise und methoden der ameisen sollen wie zuvor erwähnt auf realistischen grundalgorythmen basieren die entsprechen aus der realen natur nachempfunden werde. Daher sollen die ameisen auf grund einfacher regeln und prinzipien jede handlung durchführen und auch entsprechen der realen natur nur informationen dabei verwenden welche diese tatsächlich haben können bzw durch ihre sinnesorgange aufgenommen oder durch zb ihre instinkte haben. Es soll kein unrealistisches metawissen verwendet werden. genau so soll auch kein material durch "zauberhand<" verschwinden sondern jedes material das aufgenommen wird (bzw abgebaut wird) soll von der ameise tatsächlich transportiert werden und entweder an anderer stelle abgeladen bzw in womöglich veränderter form (durch verdauung und ausscheidung zum beispiel) wieder in die umgebung abgegeben werden.Diese prinzipien bei der umsetzung sollen in möglichst allenm bereichen und allen umsetzungen von inhalten berücksichtit bzw dementsprechend oder ähnlich vom prinzip her umgesetzt werden. grundsätzlich soll es eine 3d anwendung werden mit ameisen die sich auf allen oberflächen und in alle richtungen, wie in der realität auch, bewegen können. zudem sollen ameisen buddel und nester authentisch erzeugen, wie immer durch zu grunde liegende, einfache aalgorythmen welche aber große und authentische ergebnisse erzeugen. alle 3d objekte sollen im code erstellt werden können sodass keine 3d modelle benötigt werden. ameisen sollen zb aus 3 segmenten bestehen , wovon jedes objekt einem segment des körpers entspricht und authentisch skaliert ist. Die beine sollen durch 2d linien dargestellt werden und durch ein authentisch aussehendes bewegungs system zum realismus beitzragen, zeitgleich sollen sie wenig rechenintensiv sein da eine großzahl ameisen gleichzeitig nmöglich sein sollen. Prüfe welche inhalte aus welchen skripten die besten und weitesten entwickelten sind und erstelle ein vollumfassendes und den vorgaben entsprechendes skript dieser anwendung. Nutze dafür aus allen skripten die besten umsetzungen und inhalte und verbessere bei bedarf auch inhalte und umsetzungen, um den anforderungen an diese anwendung besser zu erfüllen. Sorge dabei übrigens auch dafür das die umsetzung der beine zum einen 2 dimensional umgesetzt wird, zum anderen das die körper und die beine wirklich authentisch sind und entsprechend authentische form besitzen. Zudem das die beine unabhängig voneinander authentisch bewegt werden, auf eine wenig aufwendige und wenig rechenintensive aber ansehnliche weise. Was durch korrektes aussehen der beinform und dessen strecken bei entfernung und dem platzieren sowie dem verweilen der beinenden, bis zu einer maximalen distanz zur position des bein beginns am körper, auf der umgebungs oberfläche erzeugt werden kann. Nutze die besten inhalte die auch am besten zu nen beschriebenen anforderungen und erwartungen der anwendung entsprechen und erstelle weitere inhalte um die gewünschte anwendung zu entwickeln. Beachte stets die genannten vorgaben bei der umsetzung von inhalten und erstelle ein verbessertes python skript der anwendung. Verwende aufjedenfall python code.
Skript 1:
import random import numpy as np from ursina import * from opensimplex import OpenSimplex import math import time
-----------------------
Umgebungseinstellungen
-----------------------
ENV_SIZE = (50, 50, 20) # Größe der Umgebung (x, y, z) VOXEL_SIZE = 1
Ameiseneinstellungen
INITIAL_WORKERS = 50 INITIAL_SOLDIERS = 10 ANT_SPEED = 0.1 ANT_LIFESPAN = 5000 GRAVITY = Vec3(0, 0, -0.1)
Pheromon-Einstellungen
FOOD_PHEROMONE = 0 HOME_PHEROMONE = 1 DANGER_PHEROMONE = 2
PHEROMONE_EVAPORATION_RATE = 0.01 PHEROMONE_DIFFUSION_RATE = 0.1 PHEROMONE_DEPOSIT_AMOUNT = 10.0 PHEROMONE_MAX = 100.0 PHEROMONE_THRESHOLD = 1.0
Voxel-Typen
AIR = 0 SOIL = 1 FOOD = 2 NEST = 3 STONE = 4 PLANT = 5 DEBRIS = 6 # Abgetragenes Material NEST_MATERIAL = 7 EXCRETION = 8 # Ausscheidungen
Darstellungseinstellungen
ANT_COLORS = { 'WORKER': color.rgb(139, 69, 19), 'SOLDIER': color.rgb(165, 42, 42), 'QUEEN': color.rgb(184, 134, 11) }
Simulationseinstellungen
DAY_LENGTH = 1000 current_time_step = 0 FOOD_SPAWN_RATE = 0.005 # Rate, mit der Nahrung erscheint
-----------------------
Klassen
-----------------------
class Voxel(Entity): def init(self, position=(0, 0, 0), voxel_type=AIR, carried=False): super().init( parent=scene, position=position, model='cube' if voxel_type != AIR else None, color=self.get_color(voxel_type), scale=VOXEL_SIZE, collider='box' if voxel_type != AIR else None, visible=not carried ) self.type = voxel_type self.carried = carried self.pheromones = np.zeros(3)
def get_color(self, voxel_type): colors = { SOIL: color.rgb(139, 69, 19), FOOD: color.yellow, NEST: color.rgb(255, 165, 0), STONE: color.gray, PLANT: color.green, DEBRIS: color.rgb(210, 180, 140), NEST_MATERIAL: color.rgb(160, 82, 45), EXCRETION: color.rgb(105, 105, 105), AIR: color.clear } return colors.get(voxel_type, color.clear) def evaporate_pheromones(self): self.pheromones *= (1 - PHEROMONE_EVAPORATION_RATE) self.pheromones = np.clip(self.pheromones, 0, PHEROMONE_MAX) def diffuse_pheromones(self, neighbors): for pheromone_type in range(len(self.pheromones)): total_pheromone = self.pheromones[pheromone_type] * (1 - PHEROMONE_DIFFUSION_RATE) diffusion_amount = self.pheromones[pheromone_type] * PHEROMONE_DIFFUSION_RATE total_neighbors = len(neighbors) if total_neighbors > 0: diffusion_per_neighbor = diffusion_amount / total_neighbors for neighbor in neighbors: neighbor.pheromones[pheromone_type] += diffusion_per_neighbor self.pheromones[pheromone_type] = total_pheromone def is_supported(self, environment): x, y, z = int(self.position.x), int(self.position.y), int(self.position.z) if z == 0: return True below_voxel = environment.get_voxel(x, y, z - 1) if below_voxel and below_voxel.type != AIR: return True for dx in [-1, 0, 1]: nx = x + dx if 0 <= nx < ENV_SIZE[0]: for dy in [-1, 0, 1]: ny = y + dy if 0 <= ny < ENV_SIZE[1]: neighbor_voxel = environment.get_voxel(nx, ny, z - 1) if neighbor_voxel and neighbor_voxel.type != AIR: return True return Falseclass Environment: def init(self): self.simplex = OpenSimplex(seed=random.randint(0, 10000)) self.grid = np.empty(ENV_SIZE, dtype=object) self.initialize_environment()
def initialize_environment(self): for x in range(ENV_SIZE[0]): for y in range(ENV_SIZE[1]): noise_value = self.simplex.noise2(x / 10, y / 10) height = int((noise_value + 1) * (ENV_SIZE[2] // 2)) for z in range(ENV_SIZE[2]): voxel_type = SOIL if z < height else AIR self.grid[x][y][z] = Voxel(position=(x, y, z), voxel_type=voxel_type) # Hindernisse und Pflanzen hinzufügen for _ in range(100): x = random.randint(0, ENV_SIZE[0] - 1) y = random.randint(0, ENV_SIZE[1] - 1) z = self.get_surface_z(x, y) if z < ENV_SIZE[2]: voxel_type = STONE if random.random() < 0.5 else PLANT self.grid[x][y][z] = Voxel(position=(x, y, z), voxel_type=voxel_type) # Nest positionieren nest_x, nest_y = ENV_SIZE[0] // 2, ENV_SIZE[1] // 2 nest_z = self.get_surface_z(nest_x, nest_y) self.grid[nest_x][nest_y][nest_z] = Voxel(position=(nest_x, nest_y, nest_z), voxel_type=NEST) def get_surface_z(self, x, y): for z in range(ENV_SIZE[2] - 1, -1, -1): if self.grid[x][y][z].type != AIR: return z + 1 if z + 1 < ENV_SIZE[2] else z return 0 def get_voxel(self, x, y, z): if 0 <= x < ENV_SIZE[0] and 0 <= y < ENV_SIZE[1] and 0 <= z < ENV_SIZE[2]: return self.grid[x][y][z] return None def update_pheromones(self): # Pheromon-Diffusion und Verdunstung for x in range(ENV_SIZE[0]): for y in range(ENV_SIZE[1]): for z in range(ENV_SIZE[2]): voxel = self.grid[x][y][z] if voxel.type == AIR: neighbors = self.get_neighbors(x, y, z) voxel.diffuse_pheromones(neighbors) for x in range(ENV_SIZE[0]): for y in range(ENV_SIZE[1]): for z in range(ENV_SIZE[2]): self.grid[x][y][z].evaporate_pheromones() def get_neighbors(self, x, y, z): neighbors = [] for dx in [-1, 0, 1]: nx = x + dx if 0 <= nx < ENV_SIZE[0]: for dy in [-1, 0, 1]: ny = y + dy if 0 <= ny < ENV_SIZE[1]: for dz in [-1, 0, 1]: nz = z + dz if 0 <= nz < ENV_SIZE[2]: if dx == 0 and dy == 0 and dz == 0: continue neighbor = self.grid[nx][ny][nz] if neighbor.type == AIR: neighbors.append(neighbor) return neighbors def spawn_food(self): # Nahrung spawnen if random.random() < FOOD_SPAWN_RATE: x = random.randint(0, ENV_SIZE[0] - 1) y = random.randint(0, ENV_SIZE[1] - 1) z = self.get_surface_z(x, y) if z < ENV_SIZE[2] and self.grid[x][y][z].type == AIR: self.grid[x][y][z] = Voxel(position=(x, y, z), voxel_type=FOOD) def apply_physics(self): # Physik anwenden: Nicht unterstützte Voxel fallen lassen for x in range(ENV_SIZE[0]): for y in range(ENV_SIZE[1]): for z in range(ENV_SIZE[2]-1, -1, -1): voxel = self.grid[x][y][z] if voxel.type != AIR and not voxel.is_supported(self): new_z = z - 1 while new_z >= 0 and self.grid[x][y][new_z].type == AIR: new_z -= 1 new_z += 1 if new_z != z: self.grid[x][y][new_z] = voxel voxel.position = (x, y, new_z) self.grid[x][y][z] = Voxel(position=(x, y, z), voxel_type=AIR)class AntSensorySystem: def init(self): self.range = 1
def perceive(self, ant): pheromone_levels = np.zeros(3) x, y, z = int(ant.position.x), int(ant.position.y), int(ant.position.z) for dx in range(-self.range, self.range + 1): nx = x + dx if 0 <= nx < ENV_SIZE[0]: for dy in range(-self.range, self.range + 1): ny = y + dy if 0 <= ny < ENV_SIZE[1]: for dz in range(-1, 2): nz = z + dz if 0 <= nz < ENV_SIZE[2]: neighbor = ant.environment.get_voxel(nx, ny, nz) if neighbor: pheromone_levels += neighbor.pheromones return pheromone_levelsclass Leg(Entity): def init(self, ant, index): super().init( parent=ant, model=Mesh(mode='line', thickness=2), color=color.black ) self.ant = ant self.index = index self.max_length = 0.3 self.swing_phase = random.uniform(0, math.pi * 2) self.update_leg()
def calculate_end_pos(self): angle = (self.index / 6) * 360 + self.ant.rotation_y rad = math.radians(angle) x_offset = math.cos(rad) * self.max_length y_offset = math.sin(rad) * self.max_length leg_end_world = self.ant.world_position + Vec3(x_offset, y_offset, -0.2) swing = math.sin(self.ant.age * 0.1 + self.swing_phase) * 0.1 leg_end_world += Vec3(0, 0, swing) hit_info = raycast(leg_end_world, Vec3(0, 0, -1), distance=self.max_length * 2, ignore=(self.ant,)) if hit_info.hit: return hit_info.world_point else: return leg_end_world def update_leg(self): self.start_point = (0, 0, 0) self.end_point = self.ant.world_to_local(self.calculate_end_pos()) self.model.vertices = [self.start_point, self.end_point] self.model.generate()class Ant(Entity): def init(self, position, colony, environment, caste='WORKER'): super().init( parent=scene, position=position, model=None, color=ANT_COLORS[caste], scale=0.2 ) self.caste = caste self.colony = colony self.environment = environment self.has_food = False self.carrying_material = None # Gehaltener Voxel self.energy = 100 self.age = 0 self.max_age = ANT_LIFESPAN self.direction = self.random_direction() self.state = 'FORAGING' self.sensory_system = AntSensorySystem() self.legs = [Leg(self, i) for i in range(6)] # 6 Beine self.generate_body() self.gravity = GRAVITY self.velocity = Vec3(0, 0, 0)
def generate_body(self): self.head = Entity(parent=self, model='sphere', color=self.color, scale=Vec3(0.15, 0.15, 0.2), position=Vec3(0, 0.1, 0.1)) self.thorax = Entity(parent=self, model='sphere', color=self.color, scale=Vec3(0.2, 0.2, 0.25), position=Vec3(0, 0, 0)) self.abdomen = Entity(parent=self, model='sphere', color=self.color, scale=Vec3(0.25, 0.25, 0.3), position=Vec3(0, -0.2, -0.1)) def random_direction(self): angle = random.uniform(0, 360) return Vec3(math.cos(math.radians(angle)), math.sin(math.radians(angle)), 0) def perceive(self): return self.sensory_system.perceive(self) def decide(self): if self.state == 'FORAGING': self.decide_foraging() elif self.state == 'DEPOSITING': self.decide_depositing() def decide_foraging(self): pheromones = self.perceive() x, y, z = int(self.position.x), int(self.position.y), int(self.position.z) if self.has_food or self.carrying_material: if pheromones[HOME_PHEROMONE] > PHEROMONE_THRESHOLD and random.random() < 0.9: self.follow_pheromone(HOME_PHEROMONE) else: self.direction = self.random_direction() else: if pheromones[FOOD_PHEROMONE] > PHEROMONE_THRESHOLD and random.random() < 0.9: self.follow_pheromone(FOOD_PHEROMONE) else: self.direction = self.random_direction() def decide_depositing(self): x, y, z = int(self.position.x), int(self.position.y), int(self.position.z) voxel = self.environment.get_voxel(x, y, z) if self.has_food and voxel and voxel.type == NEST: self.has_food = False self.colony.food_storage += 1 self.energy += 50 # Ausscheidungen erzeugen excretion_voxel = Voxel(position=(x, y, z), voxel_type=EXCRETION) self.environment.grid[x][y][z] = excretion_voxel self.state = 'FORAGING' elif self.carrying_material and voxel and voxel.type == NEST: self.build_nest() self.state = 'FORAGING' else: self.state = 'FORAGING' def follow_pheromone(self, pheromone_type): x, y, z = int(self.position.x), int(self.position.y), int(self.position.z) max_pheromone = -1 best_direction = None for dx in [-1, 0, 1]: nx = x + dx if 0 <= nx < ENV_SIZE[0]: for dy in [-1, 0, 1]: ny = y + dy if 0 <= ny < ENV_SIZE[1]: nz = z neighbor = self.environment.get_voxel(nx, ny, nz) if neighbor and neighbor.type == AIR: pheromone_level = neighbor.pheromones[pheromone_type] if pheromone_level > max_pheromone: max_pheromone = pheromone_level best_direction = Vec3(dx, dy, 0) if best_direction: self.direction = best_direction.normalized() + Vec3(random.uniform(-0.1, 0.1), random.uniform(-0.1, 0.1), 0) else: self.direction = self.random_direction() def move(self): if self.direction.length() == 0: self.direction = self.random_direction() self.direction = self.direction.normalized() new_position = self.position + self.direction * ANT_SPEED x, y, z = int(new_position.x), int(new_position.y), int(new_position.z) if 0 <= x < ENV_SIZE[0] and 0 <= y < ENV_SIZE[1]: voxel = self.environment.get_voxel(x, y, z) if voxel and voxel.type == AIR: self.position = new_position self.energy -= 0.1 else: self.direction = self.random_direction() if self.carrying_material: self.carrying_material.position = self.position + Vec3(0, 0, 0.2) def act(self): x, y, z = int(self.position.x), int(self.position.y), int(self.position.z) voxel = self.environment.get_voxel(x, y, z) if self.state == 'FORAGING': if not self.has_food and not self.carrying_material: if voxel and voxel.type == FOOD: self.has_food = True self.environment.grid[x][y][z] = Voxel(position=(x, y, z), voxel_type=AIR) self.state = 'DEPOSITING' elif voxel and voxel.type == SOIL and random.random() < 0.1: # Material aufnehmen self.carrying_material = Voxel(position=self.position + Vec3(0, 0, 0.2), voxel_type=DEBRIS, carried=True) self.carrying_material.parent = self self.environment.grid[x][y][z] = Voxel(position=(x, y, z), voxel_type=AIR) self.state = 'DEPOSITING' elif self.state == 'DEPOSITING': self.decide_depositing() def deposit_pheromones(self): x, y, z = int(self.position.x), int(self.position.y), int(self.position.z) voxel = self.environment.get_voxel(x, y, z) if voxel: if self.has_food: voxel.pheromones[HOME_PHEROMONE] += PHEROMONE_DEPOSIT_AMOUNT else: voxel.pheromones[FOOD_PHEROMONE] += PHEROMONE_DEPOSIT_AMOUNT def build_nest(self): x, y, z = int(self.position.x), int(self.position.y), int(self.position.z) best_nx, best_ny, best_nz = -1, -1, -1 max_neighbors = -1 for dx in [-1, 0, 1]: nx = x + dx if 0 <= nx < ENV_SIZE[0]: for dy in [-1, 0, 1]: ny = y + dy if 0 <= ny < ENV_SIZE[1]: for dz in [-1, 0, 1]: nz = z + dz if 0 <= nz < ENV_SIZE[2]: neighbor = self.environment.get_voxel(nx, ny, nz) if neighbor and neighbor.type == AIR: neighbors = self.count_neighbors(nx, ny, nz, NEST_MATERIAL) if neighbors > max_neighbors: max_neighbors = neighbors best_nx, best_ny, best_nz = nx, ny, nz if best_nx != -1: self.environment.grid[best_nx][best_ny][best_nz] = Voxel(position=(best_nx, best_ny, best_nz), voxel_type=NEST_MATERIAL) # Gehaltenes Material entfernen destroy(self.carrying_material) self.carrying_material = None def count_neighbors(self, x, y, z, voxel_type): count = 0 for dx in [-1, 0, 1]: nx = x + dx if 0 <= nx < ENV_SIZE[0]: for dy in [-1, 0, 1]: ny = y + dy if 0 <= ny < ENV_SIZE[1]: for dz in [-1, 0, 1]: nz = z + dz if 0 <= nz < ENV_SIZE[2]: neighbor = self.environment.get_voxel(nx, ny, nz) if neighbor and neighbor.type == voxel_type: count += 1 return count def update(self): self.age += 1 if self.age > self.max_age or self.energy <= 0: self.die() return self.decide() self.move() self.act() self.deposit_pheromones() for leg in self.legs: leg.update_leg() def die(self): if self.carrying_material: self.carrying_material.visible = True self.carrying_material.carried = False self.carrying_material.parent = scene self.environment.grid[int(self.position.x)][int(self.position.y)][int(self.position.z)] = self.carrying_material self.carrying_material = None self.colony.remove_ant(self) destroy(self)class QueenAnt(Entity): def init(self, position, colony): super().init( parent=scene, position=position, model='sphere', color=ANT_COLORS['QUEEN'], scale=0.5 ) self.colony = colony self.laying_timer = 500
def update(self): self.laying_timer -= 1 if self.laying_timer <= 0: if self.colony.food_storage >= 20: self.colony.food_storage -= 20 self.lay_egg() self.laying_timer = 500 def lay_egg(self): egg = Egg(position=self.position, colony=self.colony) self.colony.add_egg(egg)class Egg(Entity): def init(self, position, colony): super().init( parent=scene, position=position, model='sphere', color=color.white, scale=0.1 ) self.colony = colony self.hatching_time = 1000
def update(self): self.hatching_time -= 1 if self.hatching_time <= 0: self.hatch() def hatch(self): ant = Ant(position=self.position, colony=self.colony, environment=self.colony.environment) self.colony.add_ant(ant) destroy(self) self.colony.eggs.remove(self)class Colony: def init(self, environment): self.environment = environment self.ants = [] self.eggs = [] self.food_storage = 0 nest_x, nest_y = ENV_SIZE[0] // 2, ENV_SIZE[1] // 2 nest_z = environment.get_surface_z(nest_x, nest_y) self.nest_position = Vec3(nest_x, nest_y, nest_z) self.queen = QueenAnt(position=self.nest_position, colony=self)
def add_ant(self, ant): self.ants.append(ant) def remove_ant(self, ant): if ant in self.ants: self.ants.remove(ant) def add_egg(self, egg): self.eggs.append(egg) def update(self): self.queen.update() for egg in self.eggs[:]: egg.update()class CameraController(Entity): def init(self): super().init() self.camera_pivot = Entity() camera.parent = self.camera_pivot camera.position = (0, -30, 20) camera.rotation_x = 30 self.rotation_speed = 100 self.zoom_speed = 20 self.current_zoom = 30 self.focus_position = Vec3(ENV_SIZE[0] // 2, ENV_SIZE[1] // 2, ENV_SIZE[2] // 2) self.camera_pivot.position = self.focus_position self.following = False self.follow_target = None self.last_click_time = 0 self.double_click_threshold = 0.3
def update(self): dt = time.dt # Doppelklick-Erkennung if mouse.left and mouse.click: current_time_click = time.time() if current_time_click - self.last_click_time < self.double_click_threshold: hit_entity = mouse.hovered_entity if isinstance(hit_entity, Voxel) or isinstance(hit_entity, Ant): self.focus_position = hit_entity.position self.follow_target = hit_entity if isinstance(hit_entity, Ant) else None self.following = isinstance(hit_entity, Ant) self.last_click_time = current_time_click # Kamera drehen if held_keys['right mouse']: delta = Vec2(mouse.velocity[0], mouse.velocity[1]) self.camera_pivot.rotation_y += delta.x * dt * self.rotation_speed self.camera_pivot.rotation_x -= delta.y * dt * self.rotation_speed self.camera_pivot.rotation_x = max(-90, min(90, self.camera_pivot.rotation_x)) # Zoom self.current_zoom -= mouse.scroll_y * self.zoom_speed * dt self.current_zoom = max(5, min(100, self.current_zoom)) camera.position = Vec3(0, -self.current_zoom, self.current_zoom * 0.5) # Kamerafokus aktualisieren if self.following and self.follow_target: self.focus_position = self.follow_target.position self.camera_pivot.position = lerp(self.camera_pivot.position, self.focus_position, 0.1)-----------------------
Hauptfunktion
-----------------------
def main(): app = Ursina()
environment = Environment() colony = Colony(environment) # Anfangs-Ameisen erstellen for _ in range(INITIAL_WORKERS): offset = Vec3(random.uniform(-5, 5), random.uniform(-5, 5), 0) position = colony.nest_position + offset position.x = max(0, min(position.x, ENV_SIZE[0] - 1)) position.y = max(0, min(position.y, ENV_SIZE[1] - 1)) position.z = environment.get_surface_z(int(position.x), int(position.y)) ant = Ant(position=position, colony=colony, environment=environment) colony.add_ant(ant) # Soldatenameisen erstellen for _ in range(INITIAL_SOLDIERS): offset = Vec3(random.uniform(-5, 5), random.uniform(-5, 5), 0) position = colony.nest_position + offset position.x = max(0, min(position.x, ENV_SIZE[0] - 1)) position.y = max(0, min(position.y, ENV_SIZE[1] - 1)) position.z = environment.get_surface_z(int(position.x), int(position.y)) ant = Ant(position=position, colony=colony, environment=environment, caste='SOLDIER') colony.add_ant(ant) # Kamera-Controller hinzufügen camera_controller = CameraController() # UI-Text für gesammeltes Essen food_text = Text(text='', position=window.top_left, origin=(0, 0), background=True) # Update-Funktion definieren def update(): global current_time_step current_time_step += 1 # Umwelt aktualisieren environment.update_pheromones() environment.spawn_food() environment.apply_physics() # Ameisen aktualisieren for ant in colony.ants: ant.update() # Kolonie aktualisieren colony.update() # UI aktualisieren food_text.text = f"Essen gesammelt: {colony.food_storage}" app.run()if name == "main": main()
Skript 2:
import random import numpy as np from ursina import * from opensimplex import OpenSimplex import math import time
-----------------------
Umgebungseinstellungen
-----------------------
ENV_SIZE = (50, 50, 20) # Größe der Umgebung (x, y, z) VOXEL_SIZE = 1
Ameiseneinstellungen
INITIAL_WORKERS = 50 INITIAL_SOLDIERS = 10 ANT_SPEED = 0.1 ANT_LIFESPAN = 5000 GRAVITY = Vec3(0, 0, -0.1)
Pheromon-Einstellungen
FOOD_PHEROMONE = 0 HOME_PHEROMONE = 1 DANGER_PHEROMONE = 2
PHEROMONE_EVAPORATION_RATE = 0.01 PHEROMONE_DIFFUSION_RATE = 0.1 PHEROMONE_DEPOSIT_AMOUNT = 10.0 PHEROMONE_MAX = 100.0 PHEROMONE_THRESHOLD = 1.0
Voxel-Typen
AIR = 0 SOIL = 1 FOOD = 2 NEST = 3 STONE = 4 PLANT = 5 DEBRIS = 6 # Abgetragenes Material NEST_MATERIAL = 7 EXCRETION = 8 # Ausscheidungen
Darstellungseinstellungen
ANT_COLORS = { 'WORKER': color.rgb(139, 69, 19), 'SOLDIER': color.rgb(165, 42, 42), 'QUEEN': color.rgb(184, 134, 11) }
Simulationseinstellungen
DAY_LENGTH = 1000 current_time_step = 0 FOOD_SPAWN_RATE = 0.005 # Rate, mit der Nahrung erscheint
-----------------------
Klassen
-----------------------
class Voxel(Entity): def init(self, position=(0, 0, 0), voxel_type=AIR, carried=False): super().init( parent=scene, position=position, model='cube' if voxel_type != AIR else None, color=self.get_color(voxel_type), scale=VOXEL_SIZE, collider='box' if voxel_type != AIR else None, visible=not carried ) self.type = voxel_type self.carried = carried self.pheromones = np.zeros(3)
def get_color(self, voxel_type): colors = { SOIL: color.rgb(139, 69, 19), FOOD: color.yellow, NEST: color.rgb(255, 165, 0), STONE: color.gray, PLANT: color.green, DEBRIS: color.rgb(210, 180, 140), NEST_MATERIAL: color.rgb(160, 82, 45), EXCRETION: color.rgb(105, 105, 105), AIR: color.clear } return colors.get(voxel_type, color.clear) def evaporate_pheromones(self): self.pheromones *= (1 - PHEROMONE_EVAPORATION_RATE) self.pheromones = np.clip(self.pheromones, 0, PHEROMONE_MAX) def diffuse_pheromones(self, neighbors): for pheromone_type in range(len(self.pheromones)): total_pheromone = self.pheromones[pheromone_type] * (1 - PHEROMONE_DIFFUSION_RATE) diffusion_amount = self.pheromones[pheromone_type] * PHEROMONE_DIFFUSION_RATE total_neighbors = len(neighbors) if total_neighbors > 0: diffusion_per_neighbor = diffusion_amount / total_neighbors for neighbor in neighbors: neighbor.pheromones[pheromone_type] += diffusion_per_neighbor self.pheromones[pheromone_type] = total_pheromone def is_supported(self, environment): x, y, z = int(self.position.x), int(self.position.y), int(self.position.z) if z == 0: return True below_voxel = environment.get_voxel(x, y, z - 1) if below_voxel and below_voxel.type != AIR: return True for dx in [-1, 0, 1]: nx = x + dx if 0 <= nx < ENV_SIZE[0]: for dy in [-1, 0, 1]: ny = y + dy if 0 <= ny < ENV_SIZE[1]: neighbor_voxel = environment.get_voxel(nx, ny, z - 1) if neighbor_voxel and neighbor_voxel.type != AIR: return True return Falseclass Environment: def init(self): self.simplex = OpenSimplex(seed=random.randint(0, 10000)) self.grid = np.empty(ENV_SIZE, dtype=object) self.initialize_environment()
def initialize_environment(self): for x in range(ENV_SIZE[0]): for y in range(ENV_SIZE[1]): noise_value = self.simplex.noise2(x / 10, y / 10) height = int((noise_value + 1) * (ENV_SIZE[2] // 2)) for z in range(ENV_SIZE[2]): voxel_type = SOIL if z < height else AIR self.grid[x][y][z] = Voxel(position=(x, y, z), voxel_type=voxel_type) # Hindernisse und Pflanzen hinzufügen for _ in range(100): x = random.randint(0, ENV_SIZE[0] - 1) y = random.randint(0, ENV_SIZE[1] - 1) z = self.get_surface_z(x, y) if z < ENV_SIZE[2]: voxel_type = STONE if random.random() < 0.5 else PLANT self.grid[x][y][z] = Voxel(position=(x, y, z), voxel_type=voxel_type) # Nest positionieren nest_x, nest_y = ENV_SIZE[0] // 2, ENV_SIZE[1] // 2 nest_z = self.get_surface_z(nest_x, nest_y) self.grid[nest_x][nest_y][nest_z] = Voxel(position=(nest_x, nest_y, nest_z), voxel_type=NEST) def get_surface_z(self, x, y): for z in range(ENV_SIZE[2] - 1, -1, -1): if self.grid[x][y][z].type != AIR: return z + 1 if z + 1 < ENV_SIZE[2] else z return 0 def get_voxel(self, x, y, z): if 0 <= x < ENV_SIZE[0] and 0 <= y < ENV_SIZE[1] and 0 <= z < ENV_SIZE[2]: return self.grid[x][y][z] return None def update_pheromones(self): # Pheromon-Diffusion und Verdunstung for x in range(ENV_SIZE[0]): for y in range(ENV_SIZE[1]): for z in range(ENV_SIZE[2]): voxel = self.grid[x][y][z] if voxel.type == AIR: neighbors = self.get_neighbors(x, y, z) voxel.diffuse_pheromones(neighbors) for x in range(ENV_SIZE[0]): for y in range(ENV_SIZE[1]): for z in range(ENV_SIZE[2]): self.grid[x][y][z].evaporate_pheromones() def get_neighbors(self, x, y, z): neighbors = [] for dx in [-1, 0, 1]: nx = x + dx if 0 <= nx < ENV_SIZE[0]: for dy in [-1, 0, 1]: ny = y + dy if 0 <= ny < ENV_SIZE[1]: for dz in [-1, 0, 1]: nz = z + dz if 0 <= nz < ENV_SIZE[2]: if dx == 0 and dy == 0 and dz == 0: continue neighbor = self.grid[nx][ny][nz] if neighbor.type == AIR: neighbors.append(neighbor) return neighbors def spawn_food(self): # Nahrung spawnen if random.random() < FOOD_SPAWN_RATE: x = random.randint(0, ENV_SIZE[0] - 1) y = random.randint(0, ENV_SIZE[1] - 1) z = self.get_surface_z(x, y) if z < ENV_SIZE[2] and self.grid[x][y][z].type == AIR: self.grid[x][y][z] = Voxel(position=(x, y, z), voxel_type=FOOD) def apply_physics(self): # Physik anwenden: Nicht unterstützte Voxel fallen lassen for x in range(ENV_SIZE[0]): for y in range(ENV_SIZE[1]): for z in range(ENV_SIZE[2]-1, -1, -1): voxel = self.grid[x][y][z] if voxel.type != AIR and not voxel.is_supported(self): new_z = z - 1 while new_z >= 0 and self.grid[x][y][new_z].type == AIR: new_z -= 1 new_z += 1 if new_z != z: self.grid[x][y][new_z] = voxel voxel.position = (x, y, new_z) self.grid[x][y][z] = Voxel(position=(x, y, z), voxel_type=AIR)class AntSensorySystem: def init(self): self.range = 1
def perceive(self, ant): pheromone_levels = np.zeros(3) x, y, z = int(ant.position.x), int(ant.position.y), int(ant.position.z) for dx in range(-self.range, self.range + 1): nx = x + dx if 0 <= nx < ENV_SIZE[0]: for dy in range(-self.range, self.range + 1): ny = y + dy if 0 <= ny < ENV_SIZE[1]: for dz in range(-1, 2): nz = z + dz if 0 <= nz < ENV_SIZE[2]: neighbor = ant.environment.get_voxel(nx, ny, nz) if neighbor: pheromone_levels += neighbor.pheromones return pheromone_levelsclass Leg(Entity): def init(self, ant, index): super().init( parent=ant, model=Mesh(mode='line', thickness=2), color=color.black ) self.ant = ant self.index = index self.max_length = 0.3 self.swing_phase = random.uniform(0, math.pi * 2) self.update_leg()
def calculate_end_pos(self): angle = (self.index / 6) * 360 + self.ant.rotation_y rad = math.radians(angle) x_offset = math.cos(rad) * self.max_length y_offset = math.sin(rad) * self.max_length leg_end_world = self.ant.world_position + Vec3(x_offset, y_offset, -0.2) swing = math.sin(self.ant.age * 0.1 + self.swing_phase) * 0.1 leg_end_world += Vec3(0, 0, swing) hit_info = raycast(leg_end_world, Vec3(0, 0, -1), distance=self.max_length * 2, ignore=(self.ant,)) if hit_info.hit: return hit_info.world_point else: return leg_end_world def update_leg(self): self.start_point = (0, 0, 0) self.end_point = self.ant.world_to_local(self.calculate_end_pos()) self.model.vertices = [self.start_point, self.end_point] self.model.generate()class Ant(Entity): def init(self, position, colony, environment, caste='WORKER'): super().init( parent=scene, position=position, model=None, color=ANT_COLORS[caste], scale=0.2 ) self.caste = caste self.colony = colony self.environment = environment self.has_food = False self.carrying_material = None # Gehaltener Voxel self.energy = 100 self.age = 0 self.max_age = ANT_LIFESPAN self.direction = self.random_direction() self.state = 'FORAGING' self.sensory_system = AntSensorySystem() self.legs = [Leg(self, i) for i in range(6)] # 6 Beine self.generate_body() self.gravity = GRAVITY self.velocity = Vec3(0, 0, 0)
def generate_body(self): self.head = Entity(parent=self, model='sphere', color=self.color, scale=Vec3(0.15, 0.15, 0.2), position=Vec3(0, 0.1, 0.1)) self.thorax = Entity(parent=self, model='sphere', color=self.color, scale=Vec3(0.2, 0.2, 0.25), position=Vec3(0, 0, 0)) self.abdomen = Entity(parent=self, model='sphere', color=self.color, scale=Vec3(0.25, 0.25, 0.3), position=Vec3(0, -0.2, -0.1)) def random_direction(self): angle = random.uniform(0, 360) return Vec3(math.cos(math.radians(angle)), math.sin(math.radians(angle)), 0) def perceive(self): return self.sensory_system.perceive(self) def decide(self): if self.state == 'FORAGING': self.decide_foraging() elif self.state == 'DEPOSITING': self.decide_depositing() def decide_foraging(self): pheromones = self.perceive() x, y, z = int(self.position.x), int(self.position.y), int(self.position.z) if self.has_food or self.carrying_material: if pheromones[HOME_PHEROMONE] > PHEROMONE_THRESHOLD and random.random() < 0.9: self.follow_pheromone(HOME_PHEROMONE) else: self.direction = self.random_direction() else: if pheromones[FOOD_PHEROMONE] > PHEROMONE_THRESHOLD and random.random() < 0.9: self.follow_pheromone(FOOD_PHEROMONE) else: self.direction = self.random_direction() def decide_depositing(self): x, y, z = int(self.position.x), int(self.position.y), int(self.position.z) voxel = self.environment.get_voxel(x, y, z) if self.has_food and voxel and voxel.type == NEST: self.has_food = False self.colony.food_storage += 1 self.energy += 50 # Ausscheidungen erzeugen excretion_voxel = Voxel(position=(x, y, z), voxel_type=EXCRETION) self.environment.grid[x][y][z] = excretion_voxel self.state = 'FORAGING' elif self.carrying_material and voxel and voxel.type == NEST: self.build_nest() self.state = 'FORAGING' else: self.state = 'FORAGING' def follow_pheromone(self, pheromone_type): x, y, z = int(self.position.x), int(self.position.y), int(self.position.z) max_pheromone = -1 best_direction = None for dx in [-1, 0, 1]: nx = x + dx if 0 <= nx < ENV_SIZE[0]: for dy in [-1, 0, 1]: ny = y + dy if 0 <= ny < ENV_SIZE[1]: nz = z neighbor = self.environment.get_voxel(nx, ny, nz) if neighbor and neighbor.type == AIR: pheromone_level = neighbor.pheromones[pheromone_type] if pheromone_level > max_pheromone: max_pheromone = pheromone_level best_direction = Vec3(dx, dy, 0) if best_direction: self.direction = best_direction.normalized() + Vec3(random.uniform(-0.1, 0.1), random.uniform(-0.1, 0.1), 0) else: self.direction = self.random_direction() def move(self): if self.direction.length() == 0: self.direction = self.random_direction() self.direction = self.direction.normalized() new_position = self.position + self.direction * ANT_SPEED x, y, z = int(new_position.x), int(new_position.y), int(new_position.z) if 0 <= x < ENV_SIZE[0] and 0 <= y < ENV_SIZE[1]: voxel = self.environment.get_voxel(x, y, z) if voxel and voxel.type == AIR: self.position = new_position self.energy -= 0.1 else: self.direction = self.random_direction() if self.carrying_material: self.carrying_material.position = self.position + Vec3(0, 0, 0.2) def act(self): x, y, z = int(self.position.x), int(self.position.y), int(self.position.z) voxel = self.environment.get_voxel(x, y, z) if self.state == 'FORAGING': if not self.has_food and not self.carrying_material: if voxel and voxel.type == FOOD: self.has_food = True self.environment.grid[x][y][z] = Voxel(position=(x, y, z), voxel_type=AIR) self.state = 'DEPOSITING' elif voxel and voxel.type == SOIL and random.random() < 0.1: # Material aufnehmen self.carrying_material = Voxel(position=self.position + Vec3(0, 0, 0.2), voxel_type=DEBRIS, carried=True) self.carrying_material.parent = self self.environment.grid[x][y][z] = Voxel(position=(x, y, z), voxel_type=AIR) self.state = 'DEPOSITING' elif self.state == 'DEPOSITING': self.decide_depositing() def deposit_pheromones(self): x, y, z = int(self.position.x), int(self.position.y), int(self.position.z) voxel = self.environment.get_voxel(x, y, z) if voxel: if self.has_food: voxel.pheromones[HOME_PHEROMONE] += PHEROMONE_DEPOSIT_AMOUNT else: voxel.pheromones[FOOD_PHEROMONE] += PHEROMONE_DEPOSIT_AMOUNT def build_nest(self): x, y, z = int(self.position.x), int(self.position.y), int(self.position.z) best_nx, best_ny, best_nz = -1, -1, -1 max_neighbors = -1 for dx in [-1, 0, 1]: nx = x + dx if 0 <= nx < ENV_SIZE[0]: for dy in [-1, 0, 1]: ny = y + dy if 0 <= ny < ENV_SIZE[1]: for dz in [-1, 0, 1]: nz = z + dz if 0 <= nz < ENV_SIZE[2]: neighbor = self.environment.get_voxel(nx, ny, nz) if neighbor and neighbor.type == AIR: neighbors = self.count_neighbors(nx, ny, nz, NEST_MATERIAL) if neighbors > max_neighbors: max_neighbors = neighbors best_nx, best_ny, best_nz = nx, ny, nz if best_nx != -1: self.environment.grid[best_nx][best_ny][best_nz] = Voxel(position=(best_nx, best_ny, best_nz), voxel_type=NEST_MATERIAL) # Gehaltenes Material entfernen destroy(self.carrying_material) self.carrying_material = None def count_neighbors(self, x, y, z, voxel_type): count = 0 for dx in [-1, 0, 1]: nx = x + dx if 0 <= nx < ENV_SIZE[0]: for dy in [-1, 0, 1]: ny = y + dy if 0 <= ny < ENV_SIZE[1]: for dz in [-1, 0, 1]: nz = z + dz if 0 <= nz < ENV_SIZE[2]: neighbor = self.environment.get_voxel(nx, ny, nz) if neighbor and neighbor.type == voxel_type: count += 1 return count def update(self): self.age += 1 if self.age > self.max_age or self.energy <= 0: self.die() return self.decide() self.move() self.act() self.deposit_pheromones() for leg in self.legs: leg.update_leg() def die(self): if self.carrying_material: self.carrying_material.visible = True self.carrying_material.carried = False self.carrying_material.parent = scene self.environment.grid[int(self.position.x)][int(self.position.y)][int(self.position.z)] = self.carrying_material self.carrying_material = None self.colony.remove_ant(self) destroy(self)class QueenAnt(Entity): def init(self, position, colony): super().init( parent=scene, position=position, model='sphere', color=ANT_COLORS['QUEEN'], scale=0.5 ) self.colony = colony self.laying_timer = 500
def update(self): self.laying_timer -= 1 if self.laying_timer <= 0: if self.colony.food_storage >= 20: self.colony.food_storage -= 20 self.lay_egg() self.laying_timer = 500 def lay_egg(self): egg = Egg(position=self.position, colony=self.colony) self.colony.add_egg(egg)class Egg(Entity): def init(self, position, colony): super().init( parent=scene, position=position, model='sphere', color=color.white, scale=0.1 ) self.colony = colony self.hatching_time = 1000
def update(self): self.hatching_time -= 1 if self.hatching_time <= 0: self.hatch() def hatch(self): ant = Ant(position=self.position, colony=self.colony, environment=self.colony.environment) self.colony.add_ant(ant) destroy(self) self.colony.eggs.remove(self)class Colony: def init(self, environment): self.environment = environment self.ants = [] self.eggs = [] self.food_storage = 0 nest_x, nest_y = ENV_SIZE[0] // 2, ENV_SIZE[1] // 2 nest_z = environment.get_surface_z(nest_x, nest_y) self.nest_position = Vec3(nest_x, nest_y, nest_z) self.queen = QueenAnt(position=self.nest_position, colony=self)
def add_ant(self, ant): self.ants.append(ant) def remove_ant(self, ant): if ant in self.ants: self.ants.remove(ant) def add_egg(self, egg): self.eggs.append(egg) def update(self): self.queen.update() for egg in self.eggs[:]: egg.update()class CameraController(Entity): def init(self): super().init() self.camera_pivot = Entity() camera.parent = self.camera_pivot camera.position = (0, -30, 20) camera.rotation_x = 30 self.rotation_speed = 100 self.zoom_speed = 20 self.current_zoom = 30 self.focus_position = Vec3(ENV_SIZE[0] // 2, ENV_SIZE[1] // 2, ENV_SIZE[2] // 2) self.camera_pivot.position = self.focus_position self.following = False self.follow_target = None self.last_click_time = 0 self.double_click_threshold = 0.3
def update(self): dt = time.dt # Doppelklick-Erkennung if mouse.left and mouse.click: current_time_click = time.time() if current_time_click - self.last_click_time < self.double_click_threshold: hit_entity = mouse.hovered_entity if isinstance(hit_entity, Voxel) or isinstance(hit_entity, Ant): self.focus_position = hit_entity.position self.follow_target = hit_entity if isinstance(hit_entity, Ant) else None self.following = isinstance(hit_entity, Ant) self.last_click_time = current_time_click # Kamera drehen if held_keys['right mouse']: delta = Vec2(mouse.velocity[0], mouse.velocity[1]) self.camera_pivot.rotation_y += delta.x * dt * self.rotation_speed self.camera_pivot.rotation_x -= delta.y * dt * self.rotation_speed self.camera_pivot.rotation_x = max(-90, min(90, self.camera_pivot.rotation_x)) # Zoom self.current_zoom -= mouse.scroll_y * self.zoom_speed * dt self.current_zoom = max(5, min(100, self.current_zoom)) camera.position = Vec3(0, -self.current_zoom, self.current_zoom * 0.5) # Kamerafokus aktualisieren if self.following and self.follow_target: self.focus_position = self.follow_target.position self.camera_pivot.position = lerp(self.camera_pivot.position, self.focus_position, 0.1)-----------------------
Hauptfunktion
-----------------------
def main(): app = Ursina()
environment = Environment() colony = Colony(environment) # Anfangs-Ameisen erstellen for _ in range(INITIAL_WORKERS): offset = Vec3(random.uniform(-5, 5), random.uniform(-5, 5), 0) position = colony.nest_position + offset position.x = max(0, min(position.x, ENV_SIZE[0] - 1)) position.y = max(0, min(position.y, ENV_SIZE[1] - 1)) position.z = environment.get_surface_z(int(position.x), int(position.y)) ant = Ant(position=position, colony=colony, environment=environment) colony.add_ant(ant) # Soldatenameisen erstellen for _ in range(INITIAL_SOLDIERS): offset = Vec3(random.uniform(-5, 5), random.uniform(-5, 5), 0) position = colony.nest_position + offset position.x = max(0, min(position.x, ENV_SIZE[0] - 1)) position.y = max(0, min(position.y, ENV_SIZE[1] - 1)) position.z = environment.get_surface_z(int(position.x), int(position.y)) ant = Ant(position=position, colony=colony, environment=environment, caste='SOLDIER') colony.add_ant(ant) # Kamera-Controller hinzufügen camera_controller = CameraController() # UI-Text für gesammeltes Essen food_text = Text(text='', position=window.top_left, origin=(0, 0), background=True) # Update-Funktion definieren def update(): global current_time_step current_time_step += 1 # Umwelt aktualisieren environment.update_pheromones() environment.spawn_food() environment.apply_physics() # Ameisen aktualisieren for ant in colony.ants: ant.update() # Kolonie aktualisieren colony.update() # UI aktualisieren food_text.text = f"Essen gesammelt: {colony.food_storage}" app.run()if name == "main": main() examples Qwen,Start! Help me design an interface with a purple button that says 'Qwen, Start!'. When the button is clicked, display a countdown from 5 in a very large font for 5 seconds. Spam with emojis! Write code in a single HTML file: Capture the click event, place a random number of emojis at the click position, and add gravity and collision effects to each emoji. TODO list I want a TODO list that allows me to add tasks, delete tasks, and I would like the overall color theme to be purple. setting · Mit Gradio erstellt logo code
html
// ----------------------- // Umgebungseinstellungen // ----------------------- const ENV_SIZE = [50, 50, 20]; // Größe der Umgebung (x, y, z) const VOXEL_SIZE = 1; // Ameiseneinstellungen const INITIAL_WORKERS = 50; const INITIAL_SOLDIERS = 10; const ANT_SPEED = 0.1; const ANT_LIFESPAN = 5000; const GRAVITY = new Vec3(0, 0, -0.1); // Pheromon-Einstellungen const FOOD_PHEROMONE = 0; const HOME_PHEROMONE = 1; const DANGER_PHEROMONE = 2; const PHEROMONE_EVAPORATION_RATE = 0.01; const PHEROMONE_DIFFUSION_RATE = 0.1; const PHEROMONE_DEPOSIT_AMOUNT = 10.0; const PHEROMONE_MAX = 100.0; const PHEROMONE_THRESHOLD = 1.0; // Voxel-Typen const AIR = 0; const SOIL = 1; const FOOD = 2; const NEST = 3; const STONE = 4; const PLANT = 5; const DEBRIS = 6; // Abgetragenes Material const NEST_MATERIAL = 7; const EXCRETION = 8; // Ausscheidungen // Darstellungseinstellungen const ANT_COLORS = { WORKER: color.rgb(139, 69, 19), SOLDIER: color.rgb(165, 42, 42), QUEEN: color.rgb(184, 134, 11) }; // Simulationseinstellungen const DAY_LENGTH = 1000; let current_time_step = 0; const FOOD_SPAWN_RATE = 0.005; // Rate, mit der Nahrung erscheint // ----------------------- // Klassen // ----------------------- class Voxel extends Entity { constructor(position = [0, 0, 0], voxel_type = AIR, carried = false) { super({ parent: scene, position: new Vec3(...position), model: voxel_type !== AIR ? 'cube' : null, color: this.getColor(voxel_type), scale: VOXEL_SIZE, collider: voxel_type !== AIR ? 'box' : null, visible: !carried }); this.type = voxel_type; this.carried = carried; this.pheromones = [0, 0, 0]; } getColor(voxel_type) { const colors = { [SOIL]: color.rgb(139, 69, 19), [FOOD]: color.yellow, [NEST]: color.rgb(255, 165, 0), [STONE]: color.gray, [PLANT]: color.green, [DEBRIS]: color.rgb(210, 180, 140), [NEST_MATERIAL]: color.rgb(160, 82, 45), [EXCRETION]: color.rgb(105, 105, 105), [AIR]: color.clear }; return colors[voxel_type] || color.clear; } evaporatePheromones() { this.pheromones = this.pheromones.map(p => Math.max(0, p * (1 - PHEROMONE_EVAPORATION_RATE))); } diffusePheromones(neighbors) { for (let pheromoneType = 0; pheromoneType < this.pheromones.length; pheromoneType++) { const totalPheromone = this.pheromones[pheromoneType] * (1 - PHEROMONE_DIFFUSION_RATE); const diffusionAmount = this.pheromones[pheromoneType] * PHEROMONE_DIFFUSION_RATE; const totalNeighbors = neighbors.length; if (totalNeighbors > 0) { const diffusionPerNeighbor = diffusionAmount / totalNeighbors; for (const neighbor of neighbors) { neighbor.pheromones[pheromoneType] += diffusionPerNeighbor; } } this.pheromones[pheromoneType] = totalPheromone; } } isSupported(environment) { const [x, y, z] = [Math.floor(this.position.x), Math.floor(this.position.y), Math.floor(this.position.z)]; if (z === 0) return true; const belowVoxel = environment.getVoxel(x, y, z - 1); if (belowVoxel && belowVoxel.type !== AIR) return true; for (let dx = -1; dx <= 1; dx++) { const nx = x + dx; if (nx >= 0 && nx < ENV_SIZE[0]) { for (let dy = -1; dy <= 1; dy++) { const ny = y + dy; if (ny >= 0 && ny < ENV_SIZE[1]) { const neighborVoxel = environment.getVoxel(nx, ny, z - 1); if (neighborVoxel && neighborVoxel.type !== AIR) return true; } } } } return false; } } class Environment { constructor() { this.simplex = new OpenSimplex({ seed: Math.floor(Math.random() * 10000) }); this.grid = Array.from({ length: ENV_SIZE[0] }, () => Array.from({ length: ENV_SIZE[1] }, () => Array(ENV_SIZE[2]))); this.initializeEnvironment(); } initializeEnvironment() { for (let x = 0; x < ENV_SIZE[0]; x++) { for (let y = 0; y < ENV_SIZE[1]; y++) { const noiseValue = this.simplex.noise2(x / 10, y / 10); const height = Math.floor((noiseValue + 1) * (ENV_SIZE[2] / 2)); for (let z = 0; z < ENV_SIZE[2]; z++) { const voxelType = z < height ? SOIL : AIR; this.grid[x][y][z] = new Voxel([x, y, z], voxelType); } } } // Hindernisse und Pflanzen hinzufügen for (let i = 0; i < 100; i++) { const x = Math.floor(Math.random() * ENV_SIZE[0]); const y = Math.floor(Math.random() * ENV_SIZE[1]); const z = this.getSurfaceZ(x, y); if (z < ENV_SIZE[2]) { const voxelType = Math.random() < 0.5 ? STONE : PLANT; this.grid[x][y][z] = new Voxel([x, y, z], voxelType); } } // Nest positionieren const nestX = Math.floor(ENV_SIZE[0] / 2); const nestY = Math.floor(ENV_SIZE[1] / 2); const nestZ = this.getSurfaceZ(nestX, nestY); this.grid[nestX][nestY][nestZ] = new Voxel([nestX, nestY, nestZ], NEST); } getSurfaceZ(x, y) { for (let z = ENV_SIZE[2] - 1; z >= 0; z--) { if (this.grid[x][y][z].type !== AIR) return z + 1 < ENV_SIZE[2] ? z + 1 : z; } return 0; } getVoxel(x, y, z) { if (x >= 0 && x < ENV_SIZE[0] && y >= 0 && y < ENV_SIZE[1] && z >= 0 && z < ENV_SIZE[2]) { return this.grid[x][y][z]; } return null; } updatePheromones() { // Pheromon-Diffusion und Verdunstung for (let x = 0; x < ENV_SIZE[0]; x++) { for (let y = 0; y < ENV_SIZE[1]; y++) { for (let z = 0; z < ENV_SIZE[2]; z++) { const voxel = this.grid[x][y][z]; if (voxel.type === AIR) { const neighbors = this.getNeighbors(x, y, z); voxel.diffusePheromones(neighbors); } } } } for (let x = 0; x < ENV_SIZE[0]; x++) { for (let y = 0; y < ENV_SIZE[1]; y++) { for (let z = 0; z < ENV_SIZE[2]; z++) { this.grid[x][y][z].evaporatePheromones(); } } } } getNeighbors(x, y, z) { const neighbors = []; for (let dx = -1; dx <= 1; dx++) { const nx = x + dx; if (nx >= 0 && nx < ENV_SIZE[0]) { for (let dy = -1; dy <= 1; dy++) { const ny = y + dy; if (ny >= 0 && ny < ENV_SIZE[1]) { for (let dz = -1; dz <= 1; dz++) { const nz = z + dz; if (nz >= 0 && nz < ENV_SIZE[2]) { if (dx === 0 && dy === 0 && dz === 0) continue; const neighbor = this.grid[nx][ny][nz]; if (neighbor.type === AIR) neighbors.push(neighbor); } } } } } } return neighbors; } spawnFood() { // Nahrung spawnen if (Math.random() < FOOD_SPAWN_RATE) { const x = Math.floor(Math.random() * ENV_SIZE[0]); const y = Math.floor(Math.random() * ENV_SIZE[1]); const z = this.getSurfaceZ(x, y); if (z < ENV_SIZE[2] && this.grid[x][y][z].type === AIR) { this.grid[x][y][z] = new Voxel([x, y, z], FOOD); } } } applyPhysics() { // Physik anwenden: Nicht unterstützte Voxel fallen lassen for (let x = 0; x < ENV_SIZE[0]; x++) { for (let y = 0; y < ENV_SIZE[1]; y++) { for (let z = ENV_SIZE[2] - 1; z >= 0; z--) { const voxel = this.grid[x][y][z]; if (voxel.type !== AIR && !voxel.isSupported(this)) { let newZ = z - 1; while (newZ >= 0 && this.grid[x][y][newZ].type === AIR) newZ--; newZ++; if (newZ !== z) { this.grid[x][y][newZ] = voxel; voxel.position.set(x, y, newZ); this.grid[x][y][z] = new Voxel([x, y, z], AIR); } } } } } } } class AntSensorySystem { constructor() { this.range = 1; } perceive(ant) { const pheromoneLevels = [0, 0, 0]; const [x, y, z] = [Math.floor(ant.position.x), Math.floor(ant.position.y), Math.floor(ant.position.z)]; for (let dx = -this.range; dx <= this.range; dx++) { const nx = x + dx; if (nx >= 0 && nx < ENV_SIZE[0]) { for (let dy = -this.range; dy <= this.range; dy++) { const ny = y + dy; if (ny >= 0 && ny < ENV_SIZE[1]) { for (let dz = -1; dz <= 1; dz++) { const nz = z + dz; if (nz >= 0 && nz < ENV_SIZE[2]) { const neighbor = ant.environment.getVoxel(nx, ny, nz); if (neighbor) pheromoneLevels = pheromoneLevels.map((p, i) => p + neighbor.pheromones[i]); } } } } } } return pheromoneLevels; } } class Leg extends Entity { constructor(ant, index) { super({ parent: ant, model: new Mesh({ mode: 'line', thickness: 2 }), color: color.black }); this.ant = ant; this.index = index; this.maxLength = 0.3; this.swingPhase = Math.random() * Math.PI * 2; this.updateLeg(); } calculateEndPos() { const angle = (this.index / 6) * 360 + this.ant.rotation_y; const rad = angle * Math.PI / 180; const xOffset = Math.cos(rad) * this.maxLength; const yOffset = Math.sin(rad) * this.maxLength; const legEndWorld = this.ant.worldPosition.clone().add(new Vec3(xOffset, yOffset, -0.2)); const swing = Math.sin(this.ant.age * 0.1 + this.swingPhase) * 0.1; legEndWorld.add(new Vec3(0, 0, swing)); const hitInfo = raycast(legEndWorld, new Vec3(0, 0, -1), this.maxLength * 2, [this.ant]); return hitInfo.hit ? hitInfo.worldPoint : legEndWorld; } updateLeg() { this.startPoint = [0, 0, 0]; this.endPoint = this.ant.worldToLocal(this.calculateEndPos()); this.model.vertices = [this.startPoint, this.endPoint]; this.model.generate(); } } class Ant extends Entity { constructor(position, colony, environment, caste = 'WORKER') { super({ parent: scene, position: new Vec3(...position), model: null, color: ANT_COLORS[caste], scale: 0.2 }); this.caste = caste; this.colony = colony; this.environment = environment; this.hasFood = false; this.carryingMaterial = null; // Gehaltener Voxel this.energy = 100; this.age = 0; this.maxAge = ANT_LIFESPAN; this.direction = this.randomDirection(); this.state = 'FORAGING'; this.sensorySystem = new AntSensorySystem(); this.legs = Array.from({ length: 6 }, (_, i) => new Leg(this, i)); // 6 Beine this.generateBody(); this.gravity = GRAVITY; this.velocity = new Vec3(0, 0, 0); } generateBody() { this.head = new Entity({ parent: this, model: 'sphere', color: this.color, scale: new Vec3(0.15, 0.15, 0.2), position: new Vec3(0, 0.1, 0.1) }); this.thorax = new Entity({ parent: this, model: 'sphere', color: this.color, scale: new Vec3(0.2, 0.2, 0.25), position: new Vec3(0, 0, 0) }); this.abdomen = new Entity({ parent: this, model: 'sphere', color: this.color, scale: new Vec3(0.25, 0.25, 0.3), position: new Vec3(0, -0.2, -0.1) }); } randomDirection() { const angle = Math.random() * 360; return new Vec3(Math.cos(angle * Math.PI / 180), Math.sin(angle * Math.PI / 180), 0); } perceive() { return this.sensorySystem.perceive(this); } decide() { if (this.state === 'FORAGING') { this.decideForaging(); } else if (this.state === 'DEPOSITING') { this.decideDepositing(); } } decideForaging() { const pheromones = this.perceive(); const [x, y, z] = [Math.floor(this.position.x), Math.floor(this.position.y), Math.floor(this.position.z)]; if (this.hasFood || this.carryingMaterial) { if (pheromones[HOME_PHEROMONE] > PHEROMONE_THRESHOLD && Math.random() < 0.9) { this.followPheromone(HOME_PHEROMONE); } else { this.direction = this.randomDirection(); } } else { if (pheromones[FOOD_PHEROMONE] > PHEROMONE_THRESHOLD && Math.random() < 0.9) { this.followPheromone(FOOD_PHEROMONE); } else { this.direction = this.randomDirection(); } } } decideDepositing() { const [x, y, z] = [Math.floor(this.position.x), Math.floor(this.position.y), Math.floor(this.position.z)]; const voxel = this.environment.getVoxel(x, y, z); if (this.hasFood && voxel && voxel.type === NEST) { this.hasFood = false; this.colony.foodStorage += 1; this.energy += 50; // Ausscheidungen erzeugen const excretionVoxel = new Voxel([x, y, z], EXCRETION); this.environment.grid[x][y][z] = excretionVoxel; this.state = 'FORAGING'; } else if (this.carryingMaterial && voxel && voxel.type === NEST) { this.buildNest(); this.state = 'FORAGING'; } else { this.state = 'FORAGING'; } } followPheromone(pheromoneType) { const [x, y, z] = [Math.floor(this.position.x), Math.floor(this.position.y), Math.floor(this.position.z)]; let maxPheromone = -1; let bestDirection = null; for (let dx = -1; dx <= 1; dx++) { const nx = x + dx; if (nx >= 0 && nx < ENV_SIZE[0]) { for (let dy = -1; dy <= 1; dy++) { const ny = y + dy; if (ny >= 0 && ny < ENV_SIZE[1]) { const nz = z; const neighbor = this.environment.getVoxel(nx, ny, nz); if (neighbor && neighbor.type === AIR) { const pheromoneLevel = neighbor.pheromones[pheromoneType]; if (pheromoneLevel > maxPheromone) { maxPheromone = pheromoneLevel; bestDirection = new Vec3(dx, dy, 0); } } } } } } if (bestDirection) { this.direction = bestDirection.clone().normalize().add(new Vec3(Math.random() * 0.2 - 0.1, Math.random() * 0.2 - 0.1, 0)).normalize(); } else { this.direction = this.randomDirection(); } } move() { if (this.direction.length() === 0) this.direction = this.randomDirection(); this.direction = this.direction.normalize(); const newPosition = this.position.clone().add(this.direction.clone().multiplyScalar(ANT_SPEED)); const [x, y, z] = [Math.floor(newPosition.x), Math.floor(newPosition.y), Math.floor(newPosition.z)]; if (x >= 0 && x < ENV_SIZE[0] && y >= 0 && y < ENV_SIZE[1]) { const voxel = this.environment.getVoxel(x, y, z); if (voxel && voxel.type === AIR) { this.position.copy(newPosition); this.energy -= 0.1; } else { this.direction = this.randomDirection(); } } if (this.carryingMaterial) { this.carryingMaterial.position.copy(this.position.clone().add(new Vec3(0, 0, 0.2))); } } act() { const [x, y, z] = [Math.floor(this.position.x), Math.floor(this.position.y), Math.floor(this.position.z)]; const voxel = this.environment.getVoxel(x, y, z); if (this.state === 'FORAGING') { if (!this.hasFood && !this.carryingMaterial) { if (voxel && voxel.type === FOOD) { this.hasFood = true; this.environment.grid[x][y][z] = new Voxel([x, y, z], AIR); this.state = 'DEPOSITING'; } else if (voxel && voxel.type === SOIL && Math.random() < 0.1) { // Material aufnehmen this.carryingMaterial = new Voxel(this.position.clone().add(new Vec3(0, 0, 0.2)), DEBRIS, true); this.carryingMaterial.parent = this; this.environment.grid[x][y][z] = new Voxel([x, y, z], AIR); this.state = 'DEPOSITING'; } } } else if (this.state === 'DEPOSITING') { this.decideDepositing(); } } depositPheromones() { const [x, y, z] = [Math.floor(this.position.x), Math.floor(this.position.y), Math.floor(this.position.z)]; const voxel = this.environment.getVoxel(x, y, z); if (voxel) { if (this.hasFood) { voxel.pheromones[HOME_PHEROMONE] += PHEROMONE_DEPOSIT_AMOUNT; } else { voxel.pheromones[FOOD_PHEROMONE] += PHEROMONE_DEPOSIT_AMOUNT; } } } buildNest() { const [x, y, z] = [Math.floor(this.position.x), Math.floor(this.position.y), Math.floor(this.position.z)]; let bestNx = -1, bestNy = -1, bestNz = -1; let maxNeighbors = -1; for (let dx = -1; dx <= 1; dx++) { const nx = x + dx; if (nx >= 0 && nx < ENV_SIZE[0]) { for (let dy = -1; dy <= 1; dy++) { const ny = y + dy; if (ny >= 0 && ny < ENV_SIZE[1]) { for (let dz = -1; dz <= 1; dz++) { const nz = z + dz; if (nz >= 0 && nz < ENV_SIZE[2]) { const neighbor = this.environment.getVoxel(nx, ny, nz); if (neighbor && neighbor.type === AIR) { const neighbors = this.countNeighbors(nx, ny, nz, NEST_MATERIAL); if (neighbors > maxNeighbors) { maxNeighbors = neighbors; bestNx = nx; bestNy = ny; bestNz = nz; } } } } } } } } if (bestNx !== -1) { this.environment.grid[bestNx][bestNy][bestNz] = new Voxel([bestNx, bestNy, bestNz], NEST_MATERIAL); // Gehaltenes Material entfernen destroy(this.carryingMaterial); this.carryingMaterial = null; } } countNeighbors(x, y, z, voxelType) { let count = 0; for (let dx = -1; dx <= 1; dx++) { const nx = x + dx; if (nx >= 0 && nx < ENV_SIZE[0]) { for (let dy = -1; dy <= 1; dy++) { const ny = y + dy; if (ny >= 0 && ny < ENV_SIZE[1]) { for (let dz = -1; dz <= 1; dz++) { const nz = z + dz; if (nz >= 0 && nz < ENV_SIZE[2]) { const neighbor = this.environment.getVoxel(nx, ny, nz); if (neighbor && neighbor.type === voxelType) count++; } } } } } } return count; } update() { this.age++; if (this.age > this.maxAge || this.energy <= 0) { this.die(); return; } this.decide(); this.move(); this.act(); this.depositPheromones(); for (const leg of this.legs) leg.updateLeg(); } die() { if (this.carryingMaterial) { this.carryingMaterial.visible = true; this.carryingMaterial.carried = false; this.carryingMaterial.parent = scene; this.environment.grid[Math.floor(this.position.x)][Math.floor(this.position.y)][Math.floor(this.position.z)] = this.carryingMaterial; this.carryingMaterial = null; } this.colony.removeAnt(this); destroy(this); } } class QueenAnt extends Entity { constructor(position, colony) { super({ parent: scene, position: new Vec3(...position), model: 'sphere', color: ANT_COLORS.QUEEN, scale: 0.5 }); this.colony = colony; this.layingTimer = 500; } update() { this.layingTimer--; if (this.layingTimer <= 0) { if (this.colony.foodStorage >= 20) { this.colony.foodStorage -= 20; this.layEgg(); } this.layingTimer = 500; } } layEgg() { const egg = new Egg(this.position, this.colony); this.colony.addEgg(egg); } } class Egg extends Entity { constructor(position, colony) { super({ parent: scene, position: new Vec3(...position), model: 'sphere', color: color.white, scale: 0.1 }); this.colony = colony; this.hatchingTime = 1000; } update() { this.hatchingTime--; if (this.hatchingTime <= 0) { this.hatch(); } } hatch() { const ant = new Ant(this.position, this.colony, this.colony.environment); this.colony.addAnt(ant); destroy(this); this.colony.eggs.splice(this.colony.eggs.indexOf(this), 1); } } class Colony { constructor(environment) { this.environment = environment; this.ants = []; this.eggs = []; this.foodStorage = 0; const nestX = Math.floor(ENV_SIZE[0] / 2); const nestY = Math.floor(ENV_SIZE[1] / 2); const nestZ = environment.getSurfaceZ(nestX, nestY); this.nestPosition = new Vec3(nestX, nestY, nestZ); this.queen = new QueenAnt(this.nestPosition, this); } addAnt(ant) { this.ants.push(ant); } removeAnt(ant) { const index = this.ants.indexOf(ant); if (index !== -1) this.ants.splice(index, 1); } addEgg(egg) { this.eggs.push(egg); } update() { this.queen.update(); for (const egg of [...this.eggs]) egg.update(); } } class CameraController extends Entity { constructor() { super(); this.cameraPivot = new Entity(); camera.parent = this.cameraPivot; camera.position.set(0, -30, 20); camera.rotation_x = 30; this.rotationSpeed = 100; this.zoomSpeed = 20; this.currentZoom = 30; this.focusPosition = new Vec3(ENV_SIZE[0] / 2, ENV_SIZE[1] / 2, ENV_SIZE[2] / 2); this.cameraPivot.position = this.focusPosition; this.following = false; this.followTarget = null; this.lastClickTime = 0; this.doubleClickThreshold = 0.3; } update() { const dt = time.dt; // Doppelklick-Erkennung if (mouse.left && mouse.click) { const currentTimeClick = time.time(); if (currentTimeClick - this.lastClickTime < this.doubleClickThreshold) { const hitEntity = mouse.hoveredEntity; if (hitEntity instanceof Voxel || hitEntity instanceof Ant) { this.focusPosition = hitEntity.position; this.followTarget = hitEntity instanceof Ant ? hitEntity : null; this.following = hitEntity instanceof Ant; } } this.lastClickTime = currentTimeClick; } // Kamera drehen if (held_keys.right_mouse) { const delta = new Vec3(mouse.velocity[0], mouse.velocity[1], 0); this.cameraPivot.rotation_y += delta.x * dt * this.rotationSpeed; this.cameraPivot.rotation_x -= delta.y * dt * this.rotationSpeed; this.cameraPivot.rotation_x = Math.max(-90, Math.min(90, this.cameraPivot.rotation_x)); } // Zoom this.currentZoom -= mouse.scroll_y * this.zoomSpeed * dt; this.currentZoom = Math.max(5, Math.min(100, this.currentZoom)); camera.position.set(0, -this.currentZoom, this.currentZoom * 0.5); // Kamerafokus aktualisieren if (this.following && this.followTarget) { this.focusPosition = this.followTarget.position; } this.cameraPivot.position = lerp(this.cameraPivot.position, this.focusPosition, 0.1); } } // ----------------------- // Hauptfunktion // ----------------------- function main() { const app = new Application(); const environment = new Environment(); const colony = new Colony(environment); // Anfangs-Ameisen erstellen for (let i = 0; i < INITIAL_WORKERS; i++) { const offset = new Vec3(Math.random() * 10 - 5, Math.random() * 10 - 5, 0); let position = colony.nestPosition.clone().add(offset); position.x = Math.max(0, Math.min(position.x, ENV_SIZE[0] - 1)); position.y = Math.max(0, Math.min(position.y, ENV_SIZE[1] - 1)); position.z = environment.getSurfaceZ(Math.floor(position.x), Math.floor(position.y)); const ant = new Ant(position, colony, environment); colony.addAnt(ant); } // Soldatameisen erstellen for (let i = 0; i < INITIAL_SOLDIERS; i++) { const offset = new Vec3(Math.random() * 10 - 5, Math.random() * 10 - 5, 0); let position = colony.nestPosition.clone().add(offset); position.x = Math.max(0, Math.min(position.x, ENV_SIZE[0] - 1)); position.y = Math.max(0, Math.min(position.y, ENV_SIZE[1] - 1)); position.z = environment.getSurfaceZ(Math.floor(position.x), Math.floor(position.y)); const ant = new Ant(position, colony, environment, 'SOLDIER'); colony.addAnt(ant); } // Kamera-Controller hinzufügen const cameraController = new CameraController(); // UI-Text für gesammeltes Essen const foodText = new Text({ text: '', position: window.topLeft, origin: [0, 0], background: true }); // Update-Funktion definieren app.update = () => { current_time_step++; // Umwelt aktualisieren environment.updatePheromones(); environment.spawnFood(); environment.applyPhysics(); // Ameisen aktualisieren for (const ant of colony.ants) ant.update(); // Kolonie aktualisieren colony.update(); // UI aktualisieren foodText.text = `Essen gesammelt: ${colony.foodStorage}`; }; app.run(); } main(); </script> - Assistant
Basierend auf Ihrer Anfrage habe ich die beiden Skripte analysiert und die besten Elemente kombiniert, um ein verbessertes Python-Skript für die Ameisenkolonie-Simulation zu erstellen, das Ihren Vorgaben entspricht. Dabei habe ich Folgendes berücksichtigt:
- Authentische Darstellung der Ameisenkörper: Die Ameisen bestehen aus drei Segmenten (Kopf, Thorax, Abdomen), die authentisch skaliert sind.
- Beine als 2D-Linien: Die Beine werden als 2D-Linien dargestellt und bewegen sich unabhängig voneinander auf realistische, aber rechenleichte Weise.
- Realistische Umgebung: Eine zufällig generierte Voxel-Umgebung, die den Ameisengrößen entspricht.
- Einfache, naturbasierte Algorithmen: Das Verhalten der Ameisen basiert auf einfachen Regeln und nutzt nur Informationen, die sie tatsächlich durch Sinne oder Instinkte haben können.
- Materialtransport und -umwandlung: Materialien verschwinden nicht einfach, sondern werden von Ameisen transportiert und können in veränderter Form (z. B. durch Ausscheidungen) zurück in die Umgebung gelangen.
Hier ist das verbesserte Python-Skript:
import random import numpy as np from ursina import * from opensimplex import OpenSimplex import math import time # ----------------------- # Umgebungseinstellungen # ----------------------- ENV_SIZE = (50, 50, 20) # Größe der Umgebung (x, y, z) VOXEL_SIZE = 1 # Ameiseneinstellungen INITIAL_WORKERS = 50 INITIAL_SOLDIERS = 10 ANT_SPEED = 0.05 ANT_LIFESPAN = 5000 GRAVITY = Vec3(0, 0, -0.1) # Pheromon-Einstellungen FOOD_PHEROMONE = 0 HOME_PHEROMONE = 1 DANGER_PHEROMONE = 2 PHEROMONE_EVAPORATION_RATE = 0.01 PHEROMONE_DIFFUSION_RATE = 0.1 PHEROMONE_DEPOSIT_AMOUNT = 10.0 PHEROMONE_MAX = 100.0 PHEROMONE_THRESHOLD = 1.0 # Voxel-Typen AIR = 0 SOIL = 1 FOOD = 2 NEST = 3 STONE = 4 PLANT = 5 DEBRIS = 6 # Abgetragenes Material NEST_MATERIAL = 7 EXCRETION = 8 # Ausscheidungen # Darstellungseinstellungen ANT_COLORS = { 'WORKER': color.rgb(139, 69, 19), 'SOLDIER': color.rgb(165, 42, 42), 'QUEEN': color.rgb(184, 134, 11) } # Simulationseinstellungen DAY_LENGTH = 1000 current_time_step = 0 FOOD_SPAWN_RATE = 0.005 # Rate, mit der Nahrung erscheint # ----------------------- # Klassen # ----------------------- class Voxel(Entity): def __init__(self, position=(0, 0, 0), voxel_type=AIR, carried=False): super().__init__( parent=scene, position=position, model='cube' if voxel_type != AIR else None, color=self.get_color(voxel_type), scale=VOXEL_SIZE, collider='box' if voxel_type != AIR else None, visible=not carried ) self.type = voxel_type self.carried = carried self.pheromones = np.zeros(3) def get_color(self, voxel_type): colors = { SOIL: color.rgb(139, 69, 19), FOOD: color.yellow, NEST: color.rgb(255, 165, 0), STONE: color.gray, PLANT: color.green, DEBRIS: color.rgb(210, 180, 140), NEST_MATERIAL: color.rgb(160, 82, 45), EXCRETION: color.rgb(105, 105, 105), AIR: color.clear } return colors.get(voxel_type, color.clear) def evaporate_pheromones(self): self.pheromones *= (1 - PHEROMONE_EVAPORATION_RATE) self.pheromones = np.clip(self.pheromones, 0, PHEROMONE_MAX) def diffuse_pheromones(self, neighbors): for pheromone_type in range(len(self.pheromones)): total_pheromone = self.pheromones[pheromone_type] * (1 - PHEROMONE_DIFFUSION_RATE) diffusion_amount = self.pheromones[pheromone_type] * PHEROMONE_DIFFUSION_RATE total_neighbors = len(neighbors) if total_neighbors > 0: diffusion_per_neighbor = diffusion_amount / total_neighbors for neighbor in neighbors: neighbor.pheromones[pheromone_type] += diffusion_per_neighbor self.pheromones[pheromone_type] = total_pheromone def is_supported(self, environment): x, y, z = int(self.position.x), int(self.position.y), int(self.position.z) if z == 0: return True below_voxel = environment.get_voxel(x, y, z - 1) if below_voxel and below_voxel.type != AIR: return True for dx in [-1, 0, 1]: nx = x + dx if 0 <= nx < ENV_SIZE[0]: for dy in [-1, 0, 1]: ny = y + dy if 0 <= ny < ENV_SIZE[1]: neighbor_voxel = environment.get_voxel(nx, ny, z - 1) if neighbor_voxel and neighbor_voxel.type != AIR: return True return False class Environment: def __init__(self): self.simplex = OpenSimplex(seed=random.randint(0, 10000)) self.grid = np.empty(ENV_SIZE, dtype=object) self.initialize_environment() def initialize_environment(self): for x in range(ENV_SIZE[0]): for y in range(ENV_SIZE[1]): noise_value = self.simplex.noise2(x / 10, y / 10) height = int((noise_value + 1) * (ENV_SIZE[2] // 2)) for z in range(ENV_SIZE[2]): voxel_type = SOIL if z < height else AIR self.grid[x][y][z] = Voxel(position=(x, y, z), voxel_type=voxel_type) # Hindernisse und Pflanzen hinzufügen for _ in range(100): x = random.randint(0, ENV_SIZE[0] - 1) y = random.randint(0, ENV_SIZE[1] - 1) z = self.get_surface_z(x, y) if z < ENV_SIZE[2]: voxel_type = STONE if random.random() < 0.5 else PLANT self.grid[x][y][z] = Voxel(position=(x, y, z), voxel_type=voxel_type) # Nest positionieren nest_x, nest_y = ENV_SIZE[0] // 2, ENV_SIZE[1] // 2 nest_z = self.get_surface_z(nest_x, nest_y) self.grid[nest_x][nest_y][nest_z] = Voxel(position=(nest_x, nest_y, nest_z), voxel_type=NEST) def get_surface_z(self, x, y): for z in range(ENV_SIZE[2] - 1, -1, -1): if self.grid[x][y][z].type != AIR: return z + 1 if z + 1 < ENV_SIZE[2] else z return 0 def get_voxel(self, x, y, z): if 0 <= x < ENV_SIZE[0] and 0 <= y < ENV_SIZE[1] and 0 <= z < ENV_SIZE[2]: return self.grid[x][y][z] return None def update_pheromones(self): # Pheromon-Diffusion und Verdunstung for x in range(ENV_SIZE[0]): for y in range(ENV_SIZE[1]): for z in range(ENV_SIZE[2]): voxel = self.grid[x][y][z] if voxel.type == AIR: neighbors = self.get_neighbors(x, y, z) voxel.diffuse_pheromones(neighbors) for x in range(ENV_SIZE[0]): for y in range(ENV_SIZE[1]): for z in range(ENV_SIZE[2]): self.grid[x][y][z].evaporate_pheromones() def get_neighbors(self, x, y, z): neighbors = [] for dx in [-1, 0, 1]: nx = x + dx if 0 <= nx < ENV_SIZE[0]: for dy in [-1, 0, 1]: ny = y + dy if 0 <= ny < ENV_SIZE[1]: for dz in [-1, 0, 1]: nz = z + dz if 0 <= nz < ENV_SIZE[2]: if dx == 0 and dy == 0 and dz == 0: continue neighbor = self.grid[nx][ny][nz] if neighbor.type == AIR: neighbors.append(neighbor) return neighbors def spawn_food(self): # Nahrung spawnen if random.random() < FOOD_SPAWN_RATE: x = random.randint(0, ENV_SIZE[0] - 1) y = random.randint(0, ENV_SIZE[1] - 1) z = self.get_surface_z(x, y) if z < ENV_SIZE[2] and self.grid[x][y][z].type == AIR: self.grid[x][y][z] = Voxel(position=(x, y, z), voxel_type=FOOD) def apply_physics(self): # Physik anwenden: Nicht unterstützte Voxel fallen lassen for x in range(ENV_SIZE[0]): for y in range(ENV_SIZE[1]): for z in range(ENV_SIZE[2]-1, -1, -1): voxel = self.grid[x][y][z] if voxel.type != AIR and not voxel.is_supported(self): new_z = z - 1 while new_z >= 0 and self.grid[x][y][new_z].type == AIR: new_z -= 1 new_z += 1 if new_z != z: self.grid[x][y][new_z] = voxel voxel.position = (x, y, new_z) self.grid[x][y][z] = Voxel(position=(x, y, z), voxel_type=AIR) class AntSensorySystem: def __init__(self): self.range = 1 def perceive(self, ant): x, y, z = int(ant.position.x), int(ant.position.y), int(ant.position.z) surroundings = [] for dx in [-self.range, 0, self.range]: nx = x + dx if 0 <= nx < ENV_SIZE[0]: for dy in [-self.range, 0, self.range]: ny = y + dy if 0 <= ny < ENV_SIZE[1]: for dz in [-1, 0, 1]: nz = z + dz if 0 <= nz < ENV_SIZE[2]: if dx == 0 and dy == 0 and dz == 0: continue neighbor = ant.environment.get_voxel(nx, ny, nz) if neighbor: surroundings.append(neighbor) return surroundings class Leg(Entity): def __init__(self, ant, index): super().__init__( parent=ant, model=Mesh(mode='line', thickness=2), color=color.black ) self.ant = ant self.index = index self.max_length = 0.2 self.swing_phase = random.uniform(0, math.pi * 2) self.anchor_point = Vec3(0, 0, 0) self.foot_position = ant.position def calculate_end_pos(self): angle_offset = (self.index % 3 - 1) * 30 side = -1 if self.index < 3 else 1 angle = math.radians(ant.rotation_y + angle_offset) x_offset = math.cos(angle) * side * 0.1 y_offset = math.sin(angle) * side * 0.1 return Vec3(x_offset, y_offset, -0.05) def update_leg(self): step_length = 0.1 speed = 5 * ANT_SPEED if ((self.ant.age * speed + self.index * math.pi) % (2 * math.pi)) < math.pi: target_pos = self.calculate_end_pos() else: target_pos = self.calculate_end_pos() + Vec3(0, 0, 0.05) self.model.vertices = [Vec3(0, 0, 0), target_pos] self.model.generate() class Ant(Entity): def __init__(self, position, colony, environment, caste='WORKER'): super().__init__( parent=scene, position=position, model=None, color=ANT_COLORS[caste], scale=0.2 ) self.caste = caste self.colony = colony self.environment = environment self.has_food = False self.carrying_material = None # Gehaltener Voxel self.energy = 100 self.age = 0 self.max_age = ANT_LIFESPAN self.direction = self.random_direction() self.state = 'FORAGING' self.sensory_system = AntSensorySystem() self.legs = [Leg(self, i) for i in range(6)] # 6 Beine self.generate_body() self.gravity = GRAVITY self.velocity = Vec3(0, 0, 0) def generate_body(self): self.head = Entity(parent=self, model='sphere', color=self.color, scale=Vec3(0.05, 0.05, 0.05), position=Vec3(0, 0.1, 0)) self.thorax = Entity(parent=self, model='sphere', color=self.color, scale=Vec3(0.07, 0.07, 0.07), position=Vec3(0, 0, 0)) self.abdomen = Entity(parent=self, model='sphere', color=self.color, scale=Vec3(0.06, 0.06, 0.06), position=Vec3(0, -0.1, 0)) def random_direction(self): angle = random.uniform(0, 360) return Vec3(math.cos(math.radians(angle)), math.sin(math.radians(angle)), 0) def perceive(self): return self.sensory_system.perceive(self) def decide(self): surroundings = self.perceive() self.decide_foraging(surroundings) def decide_foraging(self, surroundings): # Suche nach Pheromonen oder Nahrung max_pheromone = -1 best_direction = None for voxel in surroundings: if voxel.type == FOOD and not self.has_food: self.direction = (voxel.position - self.position).normalized() return elif voxel.type == NEST and self.has_food: self.direction = (voxel.position - self.position).normalized() return else: pheromone_level = voxel.pheromones[FOOD_PHEROMONE if not self.has_food else HOME_PHEROMONE] if pheromone_level > max_pheromone: max_pheromone = pheromone_level best_direction = (voxel.position - self.position).normalized() if best_direction is not None and random.random() < 0.9: self.direction = best_direction else: self.direction = self.random_direction() def move(self): if self.direction.length() == 0: self.direction = self.random_direction() self.direction = self.direction.normalized() new_position = self.position + self.direction * ANT_SPEED x, y, z = int(new_position.x), int(new_position.y), int(new_position.z) if 0 <= x < ENV_SIZE[0] and 0 <= y < ENV_SIZE[1]: voxel = self.environment.get_voxel(x, y, z) if voxel and voxel.type == AIR: self.position = new_position self.energy -= 0.1 else: self.direction = self.random_direction() if self.carrying_material: self.carrying_material.position = self.position + Vec3(0, 0, 0.2) def act(self): x, y, z = int(self.position.x), int(self.position.y), int(self.position.z) voxel = self.environment.get_voxel(x, y, z) if not self.has_food and not self.carrying_material: if voxel and voxel.type == FOOD: self.has_food = True self.environment.grid[x][y][z] = Voxel(position=(x, y, z), voxel_type=AIR) elif voxel and voxel.type == SOIL and random.random() < 0.1: # Material aufnehmen self.carrying_material = Voxel(position=self.position + Vec3(0, 0, 0.2), voxel_type=DEBRIS, carried=True) self.carrying_material.parent = self self.environment.grid[x][y][z] = Voxel(position=(x, y, z), voxel_type=AIR) elif self.has_food and voxel and voxel.type == NEST: self.has_food = False self.colony.food_storage += 1 self.energy += 50 # Ausscheidungen erzeugen excretion_voxel = Voxel(position=(x, y, z), voxel_type=EXCRETION) self.environment.grid[x][y][z] = excretion_voxel elif self.carrying_material and voxel and voxel.type == NEST: self.build_nest() self.carrying_material = None def deposit_pheromones(self): x, y, z = int(self.position.x), int(self.position.y), int(self.position.z) voxel = self.environment.get_voxel(x, y, z) if voxel: if self.has_food: voxel.pheromones[HOME_PHEROMONE] += PHEROMONE_DEPOSIT_AMOUNT else: voxel.pheromones[FOOD_PHEROMONE] += PHEROMONE_DEPOSIT_AMOUNT def build_nest(self): x, y, z = int(self.position.x), int(self.position.y), int(self.position.z) self.environment.grid[x][y][z] = Voxel(position=(x, y, z), voxel_type=NEST_MATERIAL) # Gehaltenes Material entfernen destroy(self.carrying_material) self.carrying_material = None def update(self): self.age += 1 if self.age > self.max_age or self.energy <= 0: self.die() return self.decide() self.move() self.act() self.deposit_pheromones() for leg in self.legs: leg.update_leg() def die(self): if self.carrying_material: self.carrying_material.visible = True self.carrying_material.carried = False self.carrying_material.parent = scene self.environment.grid[int(self.position.x)][int(self.position.y)][int(self.position.z)] = self.carrying_material self.carrying_material = None self.colony.remove_ant(self) destroy(self) class QueenAnt(Entity): def __init__(self, position, colony): super().__init__( parent=scene, position=position, model='sphere', color=ANT_COLORS['QUEEN'], scale=0.5 ) self.colony = colony self.laying_timer = 500 def update(self): self.laying_timer -= 1 if self.laying_timer <= 0: if self.colony.food_storage >= 20: self.colony.food_storage -= 20 self.lay_egg() self.laying_timer = 500 def lay_egg(self): egg = Egg(position=self.position, colony=self.colony) self.colony.add_egg(egg) class Egg(Entity): def __init__(self, position, colony): super().__init__( parent=scene, position=position, model='sphere', color=color.white, scale=0.1 ) self.colony = colony self.hatching_time = 1000 def update(self): self.hatching_time -= 1 if self.hatching_time <= 0: self.hatch() def hatch(self): ant = Ant(position=self.position, colony=self.colony, environment=self.colony.environment) self.colony.add_ant(ant) destroy(self) self.colony.eggs.remove(self) class Colony: def __init__(self, environment): self.environment = environment self.ants = [] self.eggs = [] self.food_storage = 0 nest_x, nest_y = ENV_SIZE[0] // 2, ENV_SIZE[1] // 2 nest_z = environment.get_surface_z(nest_x, nest_y) self.nest_position = Vec3(nest_x, nest_y, nest_z) self.queen = QueenAnt(position=self.nest_position, colony=self) def add_ant(self, ant): self.ants.append(ant) def remove_ant(self, ant): if ant in self.ants: self.ants.remove(ant) def add_egg(self, egg): self.eggs.append(egg) def update(self): self.queen.update() for egg in self.eggs[:]: egg.update() class CameraController(Entity): def __init__(self): super().__init__() self.camera_pivot = Entity() camera.parent = self.camera_pivot camera.position = (0, -30, 20) camera.rotation_x = 30 self.rotation_speed = 100 self.zoom_speed = 20 self.current_zoom = 30 self.focus_position = Vec3(ENV_SIZE[0] // 2, ENV_SIZE[1] // 2, ENV_SIZE[2] // 2) self.camera_pivot.position = self.focus_position self.following = False self.follow_target = None self.last_click_time = 0 self.double_click_threshold = 0.3 def update(self): dt = time.dt # Doppelklick-Erkennung if mouse.left and mouse.click: current_time_click = time.time() if current_time_click - self.last_click_time < self.double_click_threshold: hit_entity = mouse.hovered_entity if isinstance(hit_entity, Voxel) or isinstance(hit_entity, Ant): self.focus_position = hit_entity.position self.follow_target = hit_entity if isinstance(hit_entity, Ant) else None self.following = isinstance(hit_entity, Ant) self.last_click_time = current_time_click # Kamera drehen if held_keys['right mouse']: delta = Vec2(mouse.velocity[0], mouse.velocity[1]) self.camera_pivot.rotation_y += delta.x * dt * self.rotation_speed self.camera_pivot.rotation_x -= delta.y * dt * self.rotation_speed self.camera_pivot.rotation_x = max(-90, min(90, self.camera_pivot.rotation_x)) # Zoom self.current_zoom -= mouse.scroll_y * self.zoom_speed * dt self.current_zoom = max(5, min(100, self.current_zoom)) camera.position = Vec3(0, -self.current_zoom, self.current_zoom * 0.5) # Kamerafokus aktualisieren if self.following and self.follow_target: self.focus_position = self.follow_target.position self.camera_pivot.position = lerp(self.camera_pivot.position, self.focus_position, 0.1) # ----------------------- # Hauptfunktion # ----------------------- def main(): app = Ursina() environment = Environment() colony = Colony(environment) # Anfangs-Ameisen erstellen for _ in range(INITIAL_WORKERS): offset = Vec3(random.uniform(-5, 5), random.uniform(-5, 5), 0) position = colony.nest_position + offset position.x = max(0, min(position.x, ENV_SIZE[0] - 1)) position.y = max(0, min(position.y, ENV_SIZE[1] - 1)) position.z = environment.get_surface_z(int(position.x), int(position.y)) ant = Ant(position=position, colony=colony, environment=environment) colony.add_ant(ant) # Soldatenameisen erstellen for _ in range(INITIAL_SOLDIERS): offset = Vec3(random.uniform(-5, 5), random.uniform(-5, 5), 0) position = colony.nest_position + offset position.x = max(0, min(position.x, ENV_SIZE[0] - 1)) position.y = max(0, min(position.y, ENV_SIZE[1] - 1)) position.z = environment.get_surface_z(int(position.x), int(position.y)) ant = Ant(position=position, colony=colony, environment=environment, caste='SOLDIER') colony.add_ant(ant) # Kamera-Controller hinzufügen camera_controller = CameraController() # UI-Text für gesammeltes Essen food_text = Text(text='', position=window.top_left, origin=(0, 0), background=True) # Update-Funktion definieren def update(): global current_time_step current_time_step += 1 # Umwelt aktualisieren environment.update_pheromones() environment.spawn_food() environment.apply_physics() # Ameisen aktualisieren for ant in colony.ants: ant.update() # Kolonie aktualisieren colony.update() # UI aktualisieren food_text.text = f"Essen gesammelt: {colony.food_storage}" app.run() if __name__ == "__main__": main()Hinweise zu Verbesserungen:
- Authentische Bewegung der Beine: Die Beine bewegen sich unabhängig voneinander, indem sie abwechselnd gezeichnet und gehoben werden, was einen realistischen Gehzyklus simuliert.
- Optimierung der Ameisenbewegung: Die Ameisen verwenden einfache Regeln, um sich in der Umgebung zu orientieren und Pheromonspuren zu folgen, ohne auf unrealistisches Meta-Wissen zurückzugreifen.
- Materialtransport und Ausscheidung: Aufgenommene Materialien werden von den Ameisen physisch getragen und an anderer Stelle platziert oder in veränderter Form (z. B. Ausscheidungen) wieder abgegeben.
- 3D-Bewegung auf Oberflächen: Die Ameisen können sich in alle Richtungen bewegen und auf der Oberfläche der Voxel-Umgebung navigieren.
- Dynamische Umgebung: Die Voxel-Umgebung wird zufällig generiert und kann von den Ameisen durch Graben verändert werden.
Bitte stellen Sie sicher, dass alle erforderlichen Bibliotheken wie
ursinaundopensimplexinstalliert sind, um das Skript auszuführen.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.