Entorno

01 · Punto de partida

Las reglas necesitan un mundo

Hasta ahora los agentes percibían vecinos en un cuadrado abstracto. Pero ¿qué tamaño tiene ese cuadrado? ¿Qué pasa al llegar al borde? ¿Hay comida, muros o salidas? El entorno responde esas preguntas y condiciona cada decisión.

Dos corridas con la misma regla y distinto entorno cuentan historias opuestas: con muros la multitud se apelotona en las esquinas; en un toroide fluye sin fin; con obstáculos aparecen atajos y cuellos de botella.

• ¿Qué tamaño y forma tiene el mundo?
• ¿Qué recursos y obstáculos contiene?
• ¿Qué ocurre en los bordes: muro, salida o portal?
• ¿El entorno cambia con el tiempo o es fijo?

02 · Definición

Espacio, contenido y bordes

Todo entorno combina tres ingredientes:

03 · Bordes

La decisión más silenciosa del modelo

El borde nunca es neutral: define si el mundo es una isla, un planeta circular o un escenario con entradas y salidas.

Celda / posición

Unidad mínima de lugar: casilla discreta o coordenada continua donde puede haber agentes.

Recurso

Contenido consumible: comida, dinero, pasto. Se agota y puede regenerarse.

Obstáculo

Contenido que bloquea: muro, río, edificio. Cambia rutas y vecindarios.

Borde

Regla del límite: muro, toroide o salida. Siempre debe escribirse y justificarse.

04 · Diseño

Diseñar el mundo en cuatro decisiones

Antes de poblar, fijá el escenario por escrito:

1. 1
   Tamaño y escala.

   ¿Plaza de 1×1 o ciudad de 100×100? El tamaño junto con N define la densidad, que manda en los encuentros.

2. 2
   Contenido.

   ¿Cuánta comida, dónde, se regenera? ¿Hay muros o salidas? Cada contenido es un experimento futuro.

3. 3
   Bordes y salidas.

   Muros para encierros, toroide para mecanismos puros, salidas para flujos con entradas y egresos.

05 · Representación en Python

El entorno es una clase con reglas de borde

El entorno guarda el tamaño y aplica el borde cada vez que un agente se mueve. Los agentes ya no se recortan solos: le preguntan al mundo.

class Entorno:
    def __init__(self, borde="muros"):
        self.borde = borde  # "muros" o "toro"

    def limitar(self, x):
        if self.borde == "toro":
            return x % 1.0
        return min(1.0, max(0.0, x))

mundo = Entorno(borde="muros")
print(mundo.limitar(1.2), mundo.limitar(-0.1))
mundo.borde = "toro"
print(mundo.limitar(1.2), mundo.limitar(-0.1))

Con muros todo queda en [0, 1]; en toro 1.2 entra por 0.2: el mismo movimiento, otro mundo.

Recursos que se agotan

El contenido vive en listas del entorno: comer es pedirle al mundo que retire una unidad.

import math

class Entorno:
    def __init__(self):
        self.comida = [(0.2, 0.2), (0.8, 0.8)]
    def comer_si_hay(self, x, y, radio=0.1):
        for i, (cx, cy) in enumerate(self.comida):
            if math.hypot(x - cx, y - cy) < radio:
                self.comida.pop(i)
                return True
        return False

m = Entorno()
print(m.comer_si_hay(0.22, 0.21), len(m.comida))
print(m.comer_si_hay(0.5, 0.5), len(m.comida))

06 · Exploración

Laboratorio: muros frente a toroide

Los mismos N agentes caminan igual durante T pasos. Con muros rebotan y se acumulan en bordes y esquinas; en toroide cruzan el borde y reaparecen del otro lado, sin esquinas trampa. Compará cruces, cobertura y dispersión.

El rectángulo es el mundo. Con muros los puntos se frenan en el borde; en toroide las flechas marcan cada cruce como un portal. Las esquinas sombreadas revelan acumulaciones artificiales.

Preguntas para explorar

1. Con 0 pasos, ¿difieren muros y toroide? ¿Cuándo empieza a importar el borde?
2. Subí los pasos a 200 en ambos bordes. ¿Dónde terminan más agentes en esquinas y por qué?
3. Si estudiás una plaza con salidas reales, ¿qué borde elegirías? ¿Y para estudiar bandadas puras?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: aplicar el borde

Ejecutá y verificá qué devuelve cada borde para 1.3 y −0.2. Luego probá con 0.7.

def limitar(x, borde="muros"):
    if borde == "toro":
        return x % 1.0
    return min(1.0, max(0.0, x))

print(limitar(1.3), limitar(-0.2))
print(limitar(1.3, "toro"), limitar(-0.2, "toro"))

Ejercicio 2: predecir el portal

Sin ejecutar primero: un agente en 0.95 avanza 0.1 en toroide 1×1. ¿Dónde termina? ¿Y con muros? Comprobalo después.

def limitar(x, borde):
    return x % 1.0 if borde == "toro" else min(1.0, max(0.0, x))

print(limitar(0.95 + 0.1, "toro"))
print(limitar(0.95 + 0.1, "muros"))

Ejercicio 3: recurso que se agota

Dos agentes llegan a la misma comida. ¿Cuántos comen si la comida se retira al comer?

comida = [(0.5, 0.5)]

def comer(x, y):
    for i, (cx, cy) in enumerate(comida):
        if abs(x - cx) < 0.05 and abs(y - cy) < 0.05:
            comida.pop(i)
            return True
    return False

print(comer(0.51, 0.5), comer(0.52, 0.5), len(comida))

09 · Síntesis

Ideas para recordar

En el próximo tema estudiaremos la interacción agente-entorno: percibir recursos, consumirlos y modificar el mundo.