Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Ich nenne in dieser nachricht zwei versionen von skripten der gewünschten anwendung,…

  1. 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 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):
        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_levels
    

    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.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 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):
        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_levels
    

    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.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>
    
  2. 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 ursina und opensimplex installiert sind, um das Skript auszuführen.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.