Saltearse al contenido
Simulación

Unidad 6

Introducción 📜

¿Qué aprenderás en esta unidad? 💡

Actividad 01

Inspiración en agentes y comportamiento emergente

👣 Pasos:

  1. Observa “Arrels”: dedica tiempo a mirar imágenes o videos de “Arrels”. Fíjate en las estructuras que se forman. ¿Parecen seguir reglas? ¿Cómo interactúan las diferentes “ramas” o elementos?
  2. Observa “encuentros”: explora la obra “Encuentros”. Observa los "Outputs finales"¿Qué tipo de movimiento o trayectoria siguen las entidades? ¿Parecen evitarse, seguirse o ignorarse? ¿Qué reglas simples podrían generar estos caminos complejos?
  3. Reflexiona sobre la autonomía: Para ambas obras (“Arrels” y “Encuentros”), reflexiona sobre estas preguntas:
    • ¿Qué reglas o comportamientos autónomos crees que podrían estar programados en los agentes (sean ramas, líneas, partículas) para generar estas formas y patrones?
    • ¿Cómo se percibe la “vida”, la “agencia” o el comportamiento emergente (complejidad no programada explícitamente) en estas obras?
  4. (Opcional) Si viste el video de Blender: ¿Cómo se relaciona el concepto de flow field mostrado en Blender con las ideas de agentes siguiendo reglas en un entorno? ¿Qué posibilidades creativas te sugiere para la animación?

🚀 Tu solución:

Arrels (Anna Carreras)

  • Las formas parecen crecer de manera orgánica, como raíces digitales que siguen algún tipo de dirección o patrón.
  • Da la sensación de que las ramas siguen reglas simples, como expandirse hasta cierto punto antes de dividirse o cambiar de dirección.
  • La interacción entre las ramas se siente fluida, como si evitaran cruzarse demasiado o buscaran cierto equilibrio.

Encuentros (Juan Rodríguez García)

  • Las líneas parecen moverse con una lógica de atracción y repulsión, como si algunas quisieran seguirse mientras otras se evitan.
  • Los caminos que siguen no son completamente rectos ni caóticos, hay una especie de flujo que da la sensación de interacción entre los elementos.

Video blender

  • Me gusto mucho y lo intentare para mis vacaciones
  • Ademas hay muchos conceptos que estan en blender pero uno no sabe que son o no los relaciona
  • El concepto de flow fields en Blender funciona de manera similar: las partículas siguen campos de dirección que afectan su trayectoria.
  • Podría ser interesante aplicarlo en animación para simular movimientos naturales, como el fluido del agua o una ´pintura.

Investigación 🔎

Actividad 02

Analizando los campos de flujo (flow fields)

👣 Pasos:

  1. Ejecuta el ejemplo: ejecuta el código del ejemplo principal de Flow Fields de TNoC en p5.js. Observa el comportamiento de los vehículos/agentes.
  2. Identifica la estructura del campo: en el código (usualmente en una clase FlowField), localiza cómo se almacena el campo de flujo. ¿Qué estructura de datos se usa (ej: un array 2D)? ¿Qué representa cada elemento de esa estructura? ¿Cómo se calcula inicialmente el vector en cada punto?
  3. Analiza el comportamiento del agente: en el código de la clase del vehículo/agente (Vehicle), encuentra la función follow(). Explica con tus palabras:
    • ¿Cómo determina el agente qué vector del campo de flujo debe seguir basándose en su posición actual? (pista: implica mapear la posición a índices de la cuadrícula).
    • Una vez que tiene el vector deseado del campo, ¿cómo lo utiliza para calcular la fuerza de dirección (steering force)? (pista: implica calcular la diferencia con la velocidad actual y limitar la fuerza).
  4. Identifica parámetros clave: Localiza en el código las variables que controlan aspectos importantes como:
    • La resolución del campo de flujo (el tamaño de las celdas de la cuadrícula).
    • La velocidad máxima (maxspeed) y la fuerza máxima (maxforce) de los agentes.
  5. Experimenta con modificaciones: realiza al menos una de las siguientes modificaciones en el código, ejecuta y describe el efecto observado en el comportamiento de los agentes:
    • Cambia significativamente la forma en que se generan los vectores del campo (ej: usa una fórmula matemática diferente en lugar de noise(), o cambia drásticamente los parámetros de noise()).
    • Modifica sustancialmente la resolución del campo de flujo (hazla mucho más fina o mucho más gruesa).
    • Altera considerablemente maxspeed o maxforce de los agentes.

🚀 Tu solución:

Flow Fields

1. Identificación de la estructura del campo en el código

¿Qué estructura de datos se usa?

  • El campo de flujo se almacena en un array 2D (this.field):
this.field = new Array(this.cols);
for (let i = 0; i < this.cols; i++) {
  this.field[i] = new Array(this.rows);
}
  • Cada celda de este array almacena un vector (p5.Vector) que representa la dirección del flujo en esa ubicación.

¿Qué representa cada elemento de esa estructura?

  • Cada elemento this.field[i][j] es un vector de dirección que indica hacia dónde se moverán los objetos que sigan el flujo en esa celda.
  • Se genera a partir de Perlin noise, que crea transiciones suaves en el campo.
let angle = map(noise(xoff, yoff), 0, 1, 0, TWO_PI);
this.field[i][j] = p5.Vector.fromAngle(angle);
  • El angle se obtiene con noise(xoff, yoff), asegurando que los vectores cambien suavemente en el espacio.

¿Cómo se calcula inicialmente el vector en cada punto?

  • Se usa Perlin noise para generar valores entre 0 y 1, que luego se mapean a un ángulo entre 0 y TWO_PI (0° a 360°).
  • Ese ángulo se convierte en un vector unitario con p5.Vector.fromAngle(angle).
let angle = map(noise(xoff, yoff), 0, 1, 0, TWO_PI);
this.field[i][j] = p5.Vector.fromAngle(angle);
  • noise(xoff, yoff) genera un valor pseudoaleatorio suave.
  • map(…, 0, 1, 0, TWO_PI) convierte ese valor en un ángulo.
  • p5.Vector.fromAngle(angle) crea un vector en esa dirección.
class FlowField {
  constructor(r) {
    this.resolution = r; // Tamaño de cada celda en la cuadrícula
    this.cols = width / this.resolution; // Número de columnas
    this.rows = height / this.resolution; // Número de filas


    // Crear un array 2D de vectores
    this.field = new Array(this.cols);
    for (let i = 0; i < this.cols; i++) {
      this.field[i] = new Array(this.rows);
    }


    this.init(); // Llamar a la función que inicializa los vectores
  }


  // Inicializar los vectores en la cuadrícula
  init() {
    noiseSeed(random(10000)); // Semilla para Perlin noise
    let xoff = 0;
    for (let i = 0; i < this.cols; i++) {
      let yoff = 0;
      for (let j = 0; j < this.rows; j++) {
        // Usar Perlin noise para generar un ángulo entre 0 y 2*PI
        let angle = map(noise(xoff, yoff), 0, 1, 0, TWO_PI);
        // Crear un vector a partir del ángulo
        this.field[i][j] = p5.Vector.fromAngle(angle);
        yoff += 0.1; // Incremento para Perlin noise en Y
      }
      xoff += 0.1; // Incremento para Perlin noise en X
    }
  }


  // Función para obtener el vector en una posición específica
  lookup(position) {
    let column = constrain(floor(position.x / this.resolution), 0, this.cols - 1);
    let row = constrain(floor(position.y / this.resolution), 0, this.rows - 1);
    return this.field[column][row].copy(); // Devuelve una copia del vector en esa celda
  }


  // Dibujar el campo de flujo
  show() {
    for (let i = 0; i < this.cols; i++) {
      for (let j = 0; j < this.rows; j++) {
        let w = width / this.cols;
        let h = height / this.rows;
        let v = this.field[i][j].copy();
        v.setMag(w * 0.5); // Escalar el vector para visualizarlo
        let x = i * w + w / 2;
        let y = j * h + h / 2;
        strokeWeight(1);
        line(x, y, x + v.x, y + v.y); // Dibujar el vector como una línea
      }
    }
  }
}

Analiza el comportamiento del agente:

*¿Cómo determina el agente qué vector del campo de flujo debe seguir?

  • En el campo de flujo como una cuadrícula gigante llena de flechitas que indican hacia dónde moverse. El agente está en algún punto de la pantalla y necesita saber qué flechita seguir.
  • Divide por el tamaño de cada cuadrito de la cuadrícula y así sabe en qué celda está. Básicamente, convierte su posición en coordenadas de la cuadrícula y busca la flechita que le toca.

¿Cómo usa esa flechita para moverse?

Ya que tiene la flechita (vector), la usa para calcular hacia dónde debe girar y cuánto debe acelerar. Una vez que tiene esa dirección, la ajusta a su velocidad máxima y la compara con su velocidad actual. Si ya va en esa dirección, casi no cambia, pero si va en otra, calcula cuánto necesita girar y ajusta su rumbo poco a poco para no hacer movimientos bruscos. Luego aplica esa fuerza a su movimiento y sigue fluyendo de manera suave. Ya que tiene la flechita (vector), la usa para calcular hacia dónde debe girar y cuánto debe acelerar.

Identifica parámetros clave

La resolución del campo de flujo: Está determinada por this.resolution en la clase FlowField. Se define en flowfield = new FlowField(20);, lo que significa que cada celda de la cuadrícula tiene un tamaño de 20 píxeles.

class FlowField {
  constructor(r) {
    this.resolution = r;
    //{!2} Determine the number of columns and rows.
    this.cols = width / this.resolution;
    this.rows = height / this.resolution;

Dentro de la clase Vehicle puedes ver los parámetros clave que controlan la velocidad y la fuerza de los agentes:

  • Velocidad máxima (maxspeed): Está en el constructor de la clase y se pasa como parámetro al crear un vehículo.
this.maxspeed = ms;

Esto significa que cada vehículo puede tener una velocidad máxima diferente, dependiendo del valor que se le pase en new Vehicle(…).

  • Fuerza máxima (maxforce): También está en el constructor y define cuánto puede cambiar su dirección el vehículo en un instante.
this.maxforce = mf;

Estos valores se usan en la función follow(flow), donde:

  • desired.mult(this.maxspeed); → Asegura que el vector de dirección tenga la magnitud de la velocidad máxima.

  • steer.limit(this.maxforce); → Restringe la fuerza de dirección para evitar cambios bruscos.

  • Básicamente, estos dos parámetros controlan qué tan rápido se mueven los vehículos y qué tanto pueden girar en cada instante.

Experimentación con modificaciones

Cambie la forma en que se generan los vectores del campo de flujo para que no sean estáticos, use ondas sinusoidales y cosenoidales, lo que generará un patrón más estructurado y repetitivo en el campo de flujo.

¿Qué hacía el código original?

En el código original, se usaba Perlin Noise para generar los ángulos de los vectores:

let angle = map(noise(xoff, yoff), 0, 1, 0, TWO_PI);

¿Qué cambiamos?

Ahora usamos sin() y cos() en función de la posición (i, j) para generar el ángulo:

let angle = sin(i * frequency + timeOffset) * cos(j * frequency + timeOffset) * TWO_PI;
  • Ya no usamos Perlin Noise → Ahora los vectores siguen un patrón basado en funciones trigonométricas.
  • Agregamos timeOffset = random(1000)
  • Antes, los ángulos siempre dependían de (i, j), ahora también dependen de este número aleatorio.
  • Los patrones cambian más bruscamente al hacer clic, porque timeOffset modifica la forma en que se generan los ángulos.

Modificación

Image

Actividad 03

Analizando el comportamiento de enjambre (Flocking)

👣 Pasos:

  1. Ejecuta el ejemplo: ejecuta el código del ejemplo principal de Flocking de TNoC en p5.js. Observa el movimiento colectivo de los “boids” (agentes).
  2. Identifica las tres reglas: en el código de la clase del agente (ej: Boid), localiza las funciones que implementan las tres reglas fundamentales del Flocking:
    • Separación (Separation): evitar el hacinamiento con vecinos cercanos.
    • Alineación (Alignment): dirigirse en la misma dirección promedio que los vecinos cercanos.
    • Cohesión (Cohesion): moverse hacia la posición promedio de los vecinos cercanos.
  3. Explica las Reglas: para cada una de las tres reglas, explica con tus propias palabras:
    • ¿Cuál es el objetivo de la regla?
    • ¿Cómo calcula el agente la fuerza de dirección correspondiente? (describe la lógica general, ej: “Calcula un vector apuntando lejos de los vecinos demasiado cercanos”).
  4. Identifica parámetros clave: localiza en el código las variables que controlan:
    • El radio (o distancia) de percepción (perceptionRadius o similar) que define quiénes son los “vecinos”. A veces también hay un ángulo de percepción.
    • Los pesos o multiplicadores que determinan la influencia relativa de cada una de las tres reglas al combinarlas.
    • La velocidad máxima (maxspeed) y la fuerza máxima (maxforce) de los agentes (similar a Flow Fields).
  5. Experimenta con modificaciones: realiza al menos una de las siguientes modificaciones en el código, ejecuta y describe el efecto observado en el comportamiento colectivo del enjambre:
    • Cambia drásticamente el peso de una de las reglas (ej: pon la cohesión a cero, o la separación muy alta).
    • Modifica significativamente el radio de percepción (hazlo muy pequeño o muy grande).
    • Introduce un objetivo (target) que todos los boids intenten seguir (usando una fuerza de seek) además de las reglas de flocking, y ajusta su influencia.

🚀 Tu solución:

Flocking

  • Fórmula de la fuerza de dirección (dirección = deseada - velocidad) para implementar las reglas de flocado.
  • Estas fuerzas de dirección serán comportamientos grupales y requerirán que cada vehículo perciba a todos los demás vehículos.
  • Combina múltiples fuerzas.

Tres reglas rigen el flocado:

  • Separación (también conocida como evitación): Conduzca para evitar chocar con sus vecinos.

  • Alineación (también conocida como copia): Conduce en la misma dirección que tus vecinos.

  • Cohesión (también conocido como centro): Dirígete hacia el centro de tus vecinos (quédate con el grupo).

    image

Boids

Agentes individuales que simulan el comportamiento colectivo de un grupo, como una bandada de pájaros, un banco de peces o una manada de animales. Cada boid sigue reglas simples, pero cuando actúan juntos, emergen comportamientos complejos y muy realistas.

image

Cada uno de estos agentes sigue tres reglas principales que se codifican en los métodos separate(), align() y cohere().

  • Los boids no se chocan, gracias a separate().
  • Se agrupan y siguen patrones suaves, gracias a cohere() y align().
  • Si arrastras el mouse, agregas más boids al sistema (esto lo hace mouseDragged()).

1. Identifica las tres reglas:

Separación (Separation)

  • Esta función calcula un vector que aleja al boid de los vecinos cercanos para que no se agrupen demasiado.
  separate(boids) {
  let desiredSeparation = 25;
  ...
  for (let i = 0; i < boids.length; i++) {
    let d = p5.Vector.dist(this.position, boids[i].position);
    if (d > 0 && d < desiredSeparation) {
      let diff = p5.Vector.sub(this.position, boids[i].position);
      ...
      steer.add(diff);
      count++;
    }
  }
  ...
  return steer;
}

Alineación (Alignment)

  • Esta función promedia las velocidades de los vecinos cercanos y calcula un vector que empuja al boid a seguir esa dirección.
align(boids) {
  let neighborDistance = 50;
  ...
  for (let i = 0; i < boids.length; i++) {
    let d = p5.Vector.dist(this.position, boids[i].position);
    if (d > 0 && d < neighborDistance) {
      sum.add(boids[i].velocity);
      count++;
    }
  }
  ...
  return steer;
}

Cohesión (Cohesion)

  • Esta función busca el centro de masa de los vecinos cercanos y usa seek() para moverse hacia allá.
cohere(boids) {
  let neighborDistance = 50;
  ...
  for (let i = 0; i < boids.length; i++) {
    let d = p5.Vector.dist(this.position, boids[i].position);
    if (d > 0 && d < neighborDistance) {
      sum.add(boids[i].position);
      count++;
    }
  }
  if (count > 0) {
    sum.div(count);
    return this.seek(sum); // Moverse hacia el centro del grupo
  }
}

¿Dónde se aplican estas tres fuerzas?

  • En el método flock(boids)
flock(boids) {
  let sep = this.separate(boids); // Separación
  let ali = this.align(boids);    // Alineación
  let coh = this.cohere(boids);   // Cohesión


  // Pesos para cada fuerza
  sep.mult(1.5);
  ali.mult(1.0);
  coh.mult(1.0);


  // Aplicar fuerzas
  this.applyForce(sep);
  this.applyForce(ali);
  this.applyForce(coh);
}

2. Explica las Reglas

Separación (Separation)

  • Objetivo: Evitar que los boids estén demasiado cerca unos de otros, para que no se amontonen ni se choquen.

¿Cómo calcula el agente la fuerza de dirección?

  • El boid detecta a sus vecinos más cercanos (dentro de una distancia determinada).
  • Si algún vecino está demasiado cerca, calcula un vector que lo aleje de ese vecino.
  • Todos esos vectores se suman y se promedian, creando un vector final que apunta lejos del grupo cercano.
  • Ese vector se usa como fuerza de separación.

2. Alineación (Alignment)

  • Objetivo: Hacer que el boid se mueva en la misma dirección que sus vecinos, como si estuvieran “coordinados”.

¿Cómo calcula el agente la fuerza de dirección?

  • El boid busca a los boids que están dentro de un cierto rango de distancia.
  • Suma sus velocidades y las promedia.
  • Calcula un vector que lo lleva a igualar esa dirección promedio.
  • De esta forma, todos tienden a moverse en la misma dirección, como una bandada real.

3. Cohesión (Cohesion)

  • Objetivo: Mantener a los boids cerca del grupo, para que no se dispersen demasiado.

¿Cómo calcula el agente la fuerza de dirección?

  • El boid promedia las posiciones de los vecinos cercanos, encontrando el “centro del grupo”.
  • Luego calcula un vector que lo guía hacia ese centro.
  • Esto crea una fuerza que lo empuja a reunirse con los demás, manteniéndolos unidos como grupo.

3. Identifica parámetros clave

  1. Radio de percepción (quiénes son los vecinos)

Estos radios definen el rango de influencia en el que el boid considera a otros como vecinos para cada regla:

  • Separación:
let desiredSeparation = 25;

  • Está en la función separate(boids).

  • Solo se consideran vecinos muy cercanos para alejarse de ellos.

  • Alineación y Cohesión:

let neighborDistance = 50;
  • Usado en align(boids) y cohere(boids).
  • Define el rango en el que el boid ve a los demás para alinearse o agruparse.
  1. Pesos o multiplicadores de cada regla

Estos valores determinan cuánta influencia tiene cada comportamiento en el movimiento final:

sep.mult(1.5);
ali.mult(1.0);
coh.mult(1.0);
  • Se encuentran en la función flock(boids).
  • sep = separación → más fuerte (1.5)
  • ali = alineación → influencia normal (1.0)
  • coh = cohesión → influencia normal (1.0)

Estos pesos se pueden ajustar para modificar el estilo del movimiento del grupo (por ejemplo, si queremos que se mantengan muy pegados o más dispersos).

  1. Velocidad máxima y fuerza máxima

Estos controlan el movimiento del boid:

  • Velocidad máxima (maxspeed):
this.maxspeed = 3;
  • Fuerza máxima (de dirección/steering) (maxforce):
this.maxforce = 0.05;

Ambos están en el constructor de la clase Boid:

constructor(x, y) {
  ...
  this.maxspeed = 3;
  this.maxforce = 0.05;
}
  • maxspeed limita qué tan rápido puede ir un boid.
  • maxforce limita qué tanto puede cambiar de dirección un boid por frame, para que el movimiento se vea suave.

4. Modificación En la función flock(boids) de la clase Boid, reducimos a cero el peso de la regla de cohesión, comentando o eliminando su influencia:

Antes:

coh.mult(1.0); // La cohesión influye normalmente

Después:

coh.mult(0); // La cohesión no influye en absoluto
  • Esto significa que los boids ya no intentan acercarse al centro del grupo ni mantenerse unidos.

Comportamiento del enjambre:

  • Los boids se dispersan más de lo normal.
  • Ya no hay una fuerza que los mantenga agrupados o reunidos.

Aunque todavía:

  • Evitan chocar entre sí (por la regla de separación),
  • Y siguen moviéndose en direcciones similares (por la regla de alineación),
  • El enjambre se ve más caótico y fragmentado.
  • Aparecen pequeños grupos sueltos o boids que vuelan solos.
  • La estructura compacta y organizada que se observa normalmente desaparece.

!Image

Aplicación 🛠

Actividad 04

Aplicación creativa e inesperada de agentes autónomos

👣 Pasos:

  1. Elige un algoritmo: decide si trabajarás con Flow Fields o Flocking.
  2. Conceptualiza la aplicación inesperada: brainstorming: ¿Cómo puedes usar la lógica de ese algoritmo para representar algo diferente? ¿Qué fenómeno visual, natural o abstracto podrías simular de forma no convencional? Define tu concepto.
  3. Diseña la implementación:
    • ¿Cómo adaptarás el algoritmo base a tu nuevo concepto? ¿Qué representarán los “agentes”? ¿Qué significará el “campo” o las “reglas de enjambre” en tu contexto?
    • ¿Qué aspecto visual tendrán tus agentes o el resultado del proceso?
    • ¿Qué tipo de interacción incluirás? (ej: el mouse influye en el flow field, un clic añade/quita agentes, teclas cambian parámetros, micrófono, etc).
  4. Implementa tu sketch: escribe el código en p5.js. Empieza adaptando el código base del algoritmo elegido e introduce gradualmente los cambios para tu concepto, los nuevos visuales y la interacción.
  5. Prueba y refina: ejecuta, prueba la interacción y refina los parámetros y el aspecto visual hasta que logres una pieza coherente con tu concepto inesperado.

🚀 Tu solución:

Algoritmo elegido: Flocking

Conceptualización y aplicación inesperada:

¿Y si las fuerzas del flocking representaran ideas abstractas como el amor, la organización y el caos?

El algoritmo de flocking se basa en tres reglas: alineación, cohesión y separación. Cada una de estas puede reinterpretarse de forma simbólica:

  • Alineación = Organización: cuando los elementos (personas, ideas, energías) fluyen en la misma dirección, siguiendo un propósito común.
  • Cohesión = Amor: la fuerza que mantiene unidos a los boids, que los hace buscar cercanía, formar lazos.
  • Separación = Caos: la necesidad de espacio, de evitar conflictos, lo impredecible que desordena el sistema.

✨ Lo que quiero mostrar:

Una especie de universo donde esas tres fuerzas están siempre jugando entre sí. A veces todo se ve armónico (organización), a veces todo se junta bonito (amor), y otras se descontrola (caos). Como la vida real, vaya 😅.

¿Cómo adapté el algoritmo?

Pues usé la lógica básica del flocking, pero en vez de pensar en pajaritos, pensé en emociones.

Cada fuerza representa una emoción distinta, y lo que hice fue jugar con los pesos de cada una (alineación, cohesión y separación) para que a veces dominara el amor, otras la organización, o el caos.

También cambié los colores para que los boids no fueran todos iguales:

Cuando se alinean bien, se ven más azulitos (orden).

Si están junticos, se ponen rojos (amor).

Y cuando están todos locos y separados, se ponen amarillos (caos).

La interacción es con el mouse:

  • Si te acercas a un grupo de boids, los “asustas” y se alejan → como cuando el caos entra.
  • Botones para cambiar entre los modos: solo caos, solo amor, o full organización.

Flocking

!Image No me deja subirlo a giphy

Consolidación y metacognición 🤔

Actividad 05

Comparando algoritmos y consolidando conceptos

👣 Pasos:

Reflexiona sobre los dos algoritmos y tu experiencia:

  1. Diferencias fundamentales: ¿Cuál dirías que es la diferencia principal en cómo Flow Fields y Flocking logran el movimiento coordinado o dirigido de los agentes? (piensa en dónde reside la “inteligencia” o las reglas: ¿En el entorno o en las interacciones entre agentes?).
  2. Tipos de comportamiento emergente: basado en tu análisis y aplicación, ¿Qué tipo de comportamiento colectivo o patrón visual crees que es más fácil o natural lograr con Flow Fields? ¿Y con Flocking? Da ejemplos.
  3. Ventajas y desventajas: en tu opinión, ¿Cuáles podrían ser las ventajas o desventajas de usar uno u otro algoritmo para ciertos tipos de efectos visuales o simulaciones?
  4. El agente autónomo: ¿Cómo te ayudaron estos dos ejemplos (Flow Fields y Flocking) a entender mejor el concepto de “agente autónomo”? ¿Qué características definen a un agente en estos sistemas?
  5. Emergencia: ¿En qué momento observaste “comportamiento emergente” (complejidad o patrones no programados explícitamente) al trabajar con estos algoritmos?

🚀 Tu solución:

Diferencias fundamentales

  • Flow Fields → las reglas están en el entorno (el campo de fuerzas).
  • Flocking → las reglas están en las interacciones entre boids (ellos se guían entre sí).

O sea, uno sigue el “viento”, el otro sigue a sus amiguitos.

Tipos de comportamiento emergente

  • Flow Fields: es más fácil lograr patrones como remolinos, ondas, cosas suaves que parecen viento.
  • Flocking: se siente más vivo, como pájaros o peces, patrones que cambian según cómo se junten o alejen.

Ejemplo:

  • Flow = movimiento tipo humo.
  • Flocking = bandada de aves.

Ventajas y desventajas

  • Flow Fields:

✅ Muy visual y fácil de controlar con el campo.

❌ A veces los agentes no parecen “vivos”.

  • Flocking:

✅ Súper natural y dinámico.

❌ Puede ser más difícil controlar exactamente cómo se mueven.

El agente autónomo

Ambos me ayudaron a ver que un agente toma decisiones solito según reglas.

Características:

  • Tiene una posición, velocidad y dirección.
  • Reacciona a su entorno o a otros.
  • No necesita un “jefe” que le diga qué hacer todo el tiempo.

Emergencia

  • En flocking lo noté full cuando cambiaban de forma solitos, como si “decidieran” ir en grupo o separarse.
  • En flow fields cuando de la nada formaban espirales o caminos bonitos sin que yo lo pidiera.

Actividad 06

Autoevaluación del aprendizaje

👣 Pasos:

Considera tu experiencia personal en esta unidad y responde con honestidad:

  1. Comprensión conceptual: ¿Qué tan claros te resultaron los conceptos de agente autónomo, emergencia, flow fields y flocking? ¿Qué fue lo más fácil y lo más difícil de entender?
  2. Análisis de algoritmos: ¿Te resultó útil analizar los ejemplos de TNoC y experimentar con modificaciones para entender cómo funcionaban los algoritmos? ¿Qué dificultades encontraste en esta fase?
  3. Aplicación creativa: ¿Qué tan "exitoso" te sientes al aplicar uno de los algoritmos a un contexto inesperado? ¿Lograste plasmar tu idea? ¿Qué fue lo más desafiante de esta actividad?
  4. Conexión con TNoC: ¿Cómo se conectan los conceptos de esta unidad (agentes, sistemas, fuerzas) con lo que has aprendido en unidades anteriores?
  5. Exploración futura: ¿Hay algún aspecto de los agentes autónomos, flow fields, flocking u otros comportamientos de sistemas que te gustaría explorar más a fondo después de esta unidad?

🚀 Tu solución:

Comprensión conceptual

  • Los conceptos en general me quedaron claros, sobre todo lo de agentes y flocking.
  • Lo más fácil: entender cómo los boids se influencian entre ellos.
  • Lo más difícil: el tema de emergencia, como que pasa sin que uno lo programe y al principio me confundía.

Análisis de algoritmos

Sí me ayudó mucho modificar los ejemplos, ahí fue donde de verdad entendí qué hacía cada parte del código. Lo difícil fue cuando algo dejaba de funcionar y no sabía si era por una fuerza, un peso, o un error mío.

Aplicación creativa

Me siento feliz con lo que logré, sí sentí que le metí mi estilo y emoción a los boids. Lo más retador fue hacer que visualmente se entendiera la emoción que quería mostrar, sin perder el control del sistema.

Conexión con TNoC

Siento que todo se conecta con lo de sistemas complejos: fuerzas, interacciones y cómo lo simple se vuelve complejo. También con lo de inputs y respuestas en los sistemas que vimos antes, pero ahora desde lo visual y lo vivo.

Exploración futura

Mmmm no lo se la verdad, para movimientos simples, o como interactividad en una animación.

Actividad 07

Retroalimentación para mejorar la unidad

👣 Pasos:

Reflexiona sobre cómo fue tu experiencia personal al cursar esta unidad específica y responde:

  1. Claridad y enfoque: ¿Te pareció claro el objetivo de la unidad y la conexión entre las actividades (inspiración, análisis, aplicación)?
  2. Actividades de introducción e investigación: ¿Fueron útiles los referentes artísticos (SET) para introducir el tema? ¿Fueron efectivas las actividades de análisis de algoritmos para tu comprensión? ¿Sugerirías algún cambio?
  3. Actividad de aplicación: ¿Te gustó el desafío de la aplicación inesperada? ¿Fue demasiado difícil, demasiado fácil o adecuado? ¿Necesitabas más orientación o ejemplos para esta parte?
  4. Recursos: ¿Fueron suficientes los enlaces a TNoC y los ejemplos? ¿Necesitaste buscar muchos recursos adicionales por tu cuenta?
  5. Ritmo y carga de trabajo: ¿Cómo sentiste el ritmo y la carga de trabajo de esta unidad en comparación con las anteriores?
  6. Sugerencia principal: Si pudieras hacer una sugerencia principal para mejorar la experiencia de aprendizaje en esta unidad sobre agentes autónomos, ¿Cuál sería?

🚀 Tu solución:

Claridad y enfoque

Sí, el objetivo se sintió claro desde el inicio. Todo estaba conectado: inspiración, luego entender, y al final aplicar. Me gustó que tuviera como un arco narrativo.

Actividades de introducción e investigación

Los referentes me ayudaron a imaginar posibilidades más artísticas, no solo técnicas.

Actividad de aplicación

Sí me gustó el reto de hacer algo inesperado, como que me sacó de lo común. No fue fácil, pero tampoco imposible. Creo que un ejemplo más concreto de una “aplicación inesperada” hubiera ayudado a soltarme más rápido.

Recursos

Los recursos estuvieron bien, me sirvieron.

Ritmo y carga de trabajo

El ritmo fue bueno, ni tan light ni tan pesado. Sí requirió tiempo, pero era un trabajo creativo, entonces se disfrutaba.

Sugerencia principal

Una guía visual interactiva de cómo se comporta cada fuerza (alineación, separación, etc.) haría todo más intuitivo. Algo tipo: “así se ve con solo separación”, “esto pasa si aumentas la cohesión”, etc.