Comportamiento

01 · Punto de partida

De la ficha a la acción

En el Tema 4 el agente tenía su ficha completa: grupo, tolerancia, posición, energía. Pero una ficha quieta no simula nada. El comportamiento es la ficha en movimiento: lo que el agente efectivamente hace cuando le toca actuar.

Un forrajeador vaga, come o descansa. Un auto acelera, frena o cambia de carril. Una persona sale, se aísla o se vacuna. Cada modelo define un repertorio pequeño y una forma de elegir.

• ¿Qué acciones puede hacer este agente?
• ¿Cuándo elige cada una?
• ¿Cuánto dura y cuánto cuesta cada acción?
• ¿Qué cambia en el mundo después de ejecutarla?

02 · Definición

Tres familias de acciones

Casi todo repertorio combina estas tres familias:

03 · Propiedades

Cómo es una buena acción

Una acción bien definida responde cuatro cosas antes de programarse:

Condición

Cuándo se puede ejecutar: hay comida a menos de r, energía mayor que 2.

Duración

Cuánto ocupa: un paso, varios pasos. En este curso, casi siempre un paso.

Costo

Qué consume: energía, tiempo, dinero. Sin costo todo es gratis y nada es creíble.

Efecto

Qué cambia: nueva posición, menos energía, una planta menos, un vecino contagiado.

04 · Selección

Del repertorio a la acción del paso

Elegir es aplicar prioridades en orden, sin ambigüedad:

1. 1
   Listar el repertorio.

   Descansar, comer, vagar: pocas acciones con nombre claro.

2. 2
   Ordenar por prioridad.

   Si puede comer, come; si está lleno, descansa; si no, vaga.

3. 3
   Ejecutar una sola.

   Un agente, un paso, una acción: así el modelo es legible y comparable.

05 · Representación en Python

Cada acción es un método, elegir es un if

El repertorio se lee mejor como métodos con nombres de verbo. La selección es una cascada de condiciones con prioridades explícitas.

class Agente:
    def __init__(self, energia=8):
        self.energia = energia

    def descansar(self):
        self.energia = min(20, self.energia + 1)
        return "descansar"

    def comer(self):
        self.energia = min(20, self.energia + 4)
        return "comer"

    def vagar(self):
        self.energia -= 1
        return "vagar"

    def comportarse(self, ve_comida):
        if ve_comida:
            return self.comer()
        if self.energia > 15:
            return self.descansar()
        return self.vagar()

yo = Agente(energia=16)
print(yo.comportarse(ve_comida=False))
print(yo.comportarse(ve_comida=True), yo.energia)

Con energía 16 y sin comida descansa; con comida a la vista come aunque esté lleno: la oportunidad manda.

Medir el comportamiento colectivo

Un paso no dice nada; cien pasos con 40 agentes muestran el reparto del repertorio.

import random
random.seed(5)

pob = [Agente(energia=random.randint(5, 18)) for _ in range(40)]
conteo = {"descansar": 0, "comer": 0, "vagar": 0}
for a in pob:
    ve = random.random() < 0.3
    conteo[a.comportarse(ve_comida=ve)] += 1
print(conteo)

06 · Exploración

Laboratorio: vagar, comer o descansar

Cada agente aplica la misma prioridad: si ve comida cerca come (amarillo), si está lleno descansa (gris), si no vaga (azul). Movete los controles y observá cómo el entorno cambia el reparto sin cambiar la regla.

Amarillo come, azul vaga, gris descansa. Los puntos amarillos pequeños son comida. La misma regla produce otro reparto si cambia la comida o la energía.

Preguntas para explorar

1. Poné comida en 0. ¿Qué comportamientos sobreviven? ¿Por qué descansar depende de la energía y no del entorno?
2. Subí la energía inicial a 18 con comida 45. ¿Aumenta comer o descansar? ¿Qué nos dice sobre prioridades?
3. Achicá el radio de vista al mínimo con mucha comida. ¿Los agentes comen más o menos? ¿Ven el mundo o solo sus cercanías?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: ejecutar una acción

Ejecutá y verificá el efecto sobre la energía. Luego hacé descansar dos veces seguidas.

class Agente:
    def __init__(self, energia=8):
        self.energia = energia
    def vagar(self):
        self.energia -= 1
        return "vagar"
    def descansar(self):
        self.energia = min(20, self.energia + 1)
        return "descansar"

a = Agente(8)
print(a.vagar(), a.energia)

Ejercicio 2: predecir la elección

Sin ejecutar primero: con energía 16 y sin comida, ¿qué elige este agente? Comprobalo después.

class Agente:
    def __init__(self, energia):
        self.energia = energia
    def comportarse(self, ve_comida):
        if ve_comida:
            return "comer"
        if self.energia > 15:
            return "descansar"
        return "vagar"

print(Agente(16).comportarse(False))

Ejercicio 3: contar el repertorio

Simulá 100 decisiones con 30 % de avistajes y contá el reparto. Cambiá la energía a 18 y compará.

import random
random.seed(6)

def eleccion(energia, ve):
    if ve:
        return "comer"
    return "descansar" if energia > 15 else "vagar"

for energia in [8, 18]:
    c = {"comer": 0, "descansar": 0, "vagar": 0}
    for _ in range(100):
        c[eleccion(energia, random.random() < 0.3)] += 1
    print(energia, c)

09 · Síntesis

Ideas para recordar

En el próximo tema estudiaremos las reglas de decisión: cómo escribir esos si-entonces sin ambigüedad.