Movimiento

01 · Punto de partida

Ver no alcanza si no te movés

En el Tema 11 el agente filtraba el mundo desde donde estaba parado. Pero su ventana se mueve con su cuerpo: para ver otra cosa hay que girar, para cruzarse con otros hay que caminar, para encontrar comida hay que buscar. El movimiento es lo que convierte posiciones en historias.

Y todo movimiento es una apuesta: cada paso gasta energía, abandona lo conocido y crea los encuentros del Tema 9, los avisos del Tema 10 y lo percibido del Tema 11. Sin paso no hay mezcla; con pasos gigantes no hay detalle.

• ¿Cuánto avanza por paso y hacia dónde?
• ¿Cuándo gira: al azar, por lo que ve o por lo que recuerda?
• ¿Busca al azar o sigue una pista?
• ¿Qué pasa al chocar con bordes y obstáculos?

02 · Definición

Paso, rumbo y búsqueda

Todo desplazamiento combina cuánto, hacia dónde y con qué lógica:

03 · Formas

Azar que mezcla frente a rumbo que dirige

El azar cubre sin apuntar; el rumbo apunta pero puede encerrar. El modelo declara cuánto de cada uno.

Paso

Distancia por avance: si es mayor que el radio de percepción, el agente salta sin ver lo intermedio.

Rumbo

Dirección en radianes que se actualiza con giros. Seguir derecho conserva filas; girar mucho dispersa.

Velocidad

Pasos por unidad de tiempo o tamaño de paso por ronda. Más velocidad es más mezcla y más choques.

Sesgo

Componente dirigida del giro: cuánto del rumbo mira al objetivo y cuánto tiembla al azar.

04 · Ciclo

El paso que gira y avanza

Cada agente actualiza su rumbo antes de moverse, en este orden:

1. 1
   Percibir lo cercano.

   Leer vecinos, comida o muros con la ventana del Tema 11.

2. 2
   Girar el rumbo.

   Sumar azar, corregir hacia el objetivo o mantener la marcha según la regla.

3. 3
   Avanzar y limitar.

   Sumar paso por dirección y aplicar el borde del entorno (Tema 7).

05 · Representación en Python

Girar con azar y avanzar con borde

El agente guarda posición y rumbo. Girar es sumar un tiembla; avanzar es trigonometría con tope en [0, 1].

import math, random

class Agente:
    def __init__(self, x=0.5, y=0.5, rumbo=0.0):
        self.x = x
        self.y = y
        self.rumbo = rumbo

    def girar(self, tiembla=0.5):
        self.rumbo += random.uniform(-tiembla, tiembla)
        return self.rumbo

    def avanzar(self, paso=0.03):
        self.x = min(1.0, max(0.0, self.x + paso * math.cos(self.rumbo)))
        self.y = min(1.0, max(0.0, self.y + paso * math.sin(self.rumbo)))
        return (self.x, self.y)

a = Agente()
print(a.girar(tiembla=0.5))
print(a.avanzar(paso=0.03))

Con paso 0,03 hacen falta ~30 avances para cruzar el mapa: el paso chico detalla, el grande mezcla.

Girar hacia un objetivo

El sesgo corrige el rumbo hacia comida o salida; el azar evita filas perfectas.

def girar_hacia(ag, ox, oy, sesgo=0.7, tiembla=0.3):
    objetivo = math.atan2(oy - ag.y, ox - ag.x)
    dif = (objetivo - ag.rumbo + math.pi) % (2 * math.pi) - math.pi
    ag.rumbo += sesgo * dif + random.uniform(-tiembla, tiembla)
    return ag.rumbo

a = Agente(0.2, 0.2, rumbo=0.0)
print(girar_hacia(a, 0.9, 0.9))
print(a.avanzar(paso=0.05))

06 · Exploración

Laboratorio: pasos que cubren el mapa

Los agentes caminan al azar con el mismo paso durante T rondas. El mapa se divide en 16 cuadrantes: ¿cuántos se pisan? Compará paso corto contra paso largo con la misma cantidad de rondas.

Cada punto es un agente y la cruz marca su punto de partida. La grilla divide el mapa en 16 cuadrantes: iluminado fue pisado. Pulsá Nueva réplica para otra caminata con los mismos parámetros.

Preguntas para explorar

1. Con 0 rondas, ¿cuánta cobertura hay? ¿Por qué sin pasos no hay mezcla aunque haya muchos agentes?
2. Con paso mínimo y 200 rondas frente a paso máximo y 20 rondas, ¿quién cubre más? ¿Qué enseña sobre paso y tiempo?
3. Repetí la misma configuración 3 veces. ¿La cobertura es idéntica? ¿Qué parte es regla y qué parte es azar de giros?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: avanzar con borde

Ejecutá y verificá dónde termina. Luego probá con paso 0,5 y observá por qué el borde es parte del movimiento.

import math
x, y, rumbo, paso = 0.95, 0.5, 0.0, 0.1
x = min(1.0, max(0.0, x + paso * math.cos(rumbo)))
y = min(1.0, max(0.0, y + paso * math.sin(rumbo)))
print(x, y)

Ejercicio 2: predecir la deriva

Sin ejecutar primero: rumbo 0 (este) con tiembla ±0,1 durante 3 pasos de 0,05. ¿Avanza más en x o en y? Comprobalo después.

import math, random
random.seed(2)
x = y = 0.5
rumbo = 0.0
for _ in range(3):
    rumbo += random.uniform(-0.1, 0.1)
    x += 0.05 * math.cos(rumbo)
    y += 0.05 * math.sin(rumbo)
print(round(x, 3), round(y, 3))

Ejercicio 3: paso que saltea comida

Comida en 0,55 y agente en 0,5 mirando al este. ¿La pisa con paso 0,03? ¿Y con paso 0,10?

for paso in [0.03, 0.10]:
    x = 0.5 + paso
    print(paso, abs(x - 0.55) < 0.02)

09 · Síntesis

Ideas para recordar

En el próximo tema estudiaremos los vecindarios: quiénes son vecinos y cómo se definen.