Unidad 3

Introducción

En esta unidad, explorarás el concepto de fuerzas y cómo se aplican en la creación de sistemas interactivos dinámicos. Partiendo de la manipulación de la aceleración vista en la unidad anterior, aprenderás a utilizar las leyes de Newton para simular el movimiento de objetos en un entorno virtual. A través de ejercicios prácticos, comprenderás cómo las fuerzas influyen en la aceleración, velocidad y posición de los elementos visuales, y cómo modelar diferentes tipos de fuerzas, incluyendo la fricción, la resistencia y la gravedad. Además, explorarás la narrativa como un elemento clave para dar sentido y propósito a las interacciones entre los elementos de la simulación. Finalmente, integrarás la interactividad del usuario para enriquecer la experiencia y el control sobre el sistema.

¿Qué aprenderás en esta unidad?

En esta fase inicial, establecerás las bases para comprender las fuerzas en sistemas interactivos. Despertarás la curiosidad y establecerás conexiones con conocimientos previos.

Actividad 01

Explorando las Fuerzas en el Mundo Real

Enunciado: observa a tu alrededor e identifica cinco ejemplos de fuerzas en acción. Describe cada ejemplo y explica qué tipo de fuerza está actuando (ej. gravedad, fricción, empuje). ¿Cómo se manifiesta visualmente cada fuerza?

Por ejemplo, considera un libro sobre una mesa:

Fuerza en acción: gravedad.
Descripción: la gravedad tira del libro hacia abajo, pero la mesa ejerce una fuerza de reacción normal que evita que caiga.
Manifestación visual: el libro permanece en reposo sobre la mesa sin moverse.

¿Cómo conectamos esto con el arte y diseño generativo? Por ejemplo, una simulación de equilibrio y gravedad. En una simulación de arte generativo podrías pensar en algoritmos de simulación de cuerpos rígidos que calculan la estabilidad de estructuras apiladas. Como inspiración visual se podrían analizar obras que exploran la gravedad y el equilibrio, como las esculturas de Alexander Calder (móviles que juegan con la estabilidad y el contrapeso). Esto lo podrías aplicar a una simulación de un sistema generativo donde las formas geométricas se apilan siguiendo un modelo de fuerzas de reacción y colisión.

Entrega: una lista de cinco ejemplos de fuerzas del mundo real, con descripciones detalladas de cada fuerza, su manifestación visual y qué te inspira en términos de arte/diseño generativo algorítmico?

🚀 Tu solución:

Fuerzas en acción

Ventilador encendido:

Fuerza en acción: empuje del motor y resistencia del aire.
Descripción: el motor del ventilador genera una fuerza que hace girar las aspas, mientras que por otro lado, la resistencia del aire se opone al movimiento.
Manifestación visual: las aspas giran continuamente, y se puede sentir el flujo de aire generado por el frente.

Inspiración: En este caso se me ocurre una especie de simulación de partículas, creando patrones caóticos o suaves dependiendo de la “potencia” del ventilador virtual, y que este apunte hacia donde se mueva el mouse en pantalla

Deslizar el celular sobre una cama:

Fuerza en acción: fricción.
Descripción: al intentar mover el celular sobre la superficie de la cama, la fricción entre ambos materiales dificulta el movimiento.
Manifestación visual: el celular no se desliza con facilidad, a diferencia de una superficie lisa como una mesa.

Inspiración: Aquí podríamos generar una simulación de ondas suaves que se expanden en la pantalla cuando una especie de celular digital (Objeto cuadrado) se desliza, similar al efecto de un objeto moviéndose sobre agua o un colchón de aire.

Abrir una puerta:

Fuerza en acción: fuerza aplicada.
Descripción: cuando se empuja la puerta, se aplica una fuerza en un punto específico que genera un torque en las bisagras, lo que hace que la puerta gire.
Manifestación visual: la puerta cambia de posición y se abre o cierra dependiendo de la dirección del empuje.

Inspiración: Aquí realmente pueden haber muchos diseños aleatorios, por ejemplo, puede ser una pantalla llena de puertas y que dependiendo de cual se habra aparezcan ciertos patrones u otros aleatoriamente, de esta manera, al interactuar con la pantalla se estaría formando una imagen diferente cada vez, lo cual sería interesante de ver.

Un lapicero lanzado hacia arriba:

Fuerza en acción: fuerza de empuje y gravedad.
Descripción: al aplicar una fuerza hacia arriba con la mano, el lapicero gana velocidad y se eleva, sin embargo, la gravedad actúa en sentido contrario, desacelerándolo hasta que se detiene momentáneamente en su punto más alto y luego cae de nuevo.
Manifestación visual: el lapicero sube gradualmente, se detiene brevemente en el aire y luego comienza a descender cada vez más rápido debido a la atracción gravitacional.

Inspiración: Aquí se puede hacer una pequeña animación en la cual con cada lanzamiento hacia arriba quede el trazo del lapicero, y en caso tal de tener cierta inclinación u otra, de la curva, de esta forma nos aseguramos de generar una imagen única con las interacciones que tenemos

Mover un mouse sobre una alfombrilla:

Fuerza en acción: fricción y fuerza aplicada.
Descripción: al empujar el mouse con la mano, se ejerce una fuerza aplicada que lo hace moverse, pero la fricción entre la alfombrilla y el mouse regula su movimiento, evitando que se deslice demasiado rápido o de manera incontrolable.
Manifestación visual: el mouse se desplaza en la dirección en la que se empuja, con movimientos más suaves o bruscos dependiendo de la fricción de la alfombrilla.

Inspiración: Aquí podríamos crear un diseño interactivo donde mover el mouse altere un paisaje digital quizá ya entregado o en formación, formando flujos suaves en superficies de baja fricción y patrones más caóticos en zonas de alta fricción.

Actividad 02

Explorando Posibilidades

Enunciado: te voy a presentar el estudio de diseño SOSO. Observa el proyecto Data Structure.

Tomando como inspiración el proyecto de Data Structure, explora cómo las experiencias digitales pueden manifestarse en el mundo físico. Esto puede lograrse mediante la creación de instalaciones interactivas que fusionen elementos digitales y físicos, utilizando técnicas como la proyección, la realidad aumentada y la fabricación digital.

Por ejemplo, se podría desarrollar una instalación donde los jugadores interactúen con proyecciones en superficies físicas, creando una experiencia de juego que trascienda la pantalla tradicional. Otra posibilidad es diseñar esculturas cinéticas controladas por algoritmos generativos, donde la animación digital influya directamente en el movimiento físico de la obra.

Entrega: un texto donde propongas una idea concreta, asociada con tus intereses o línea de énfasis, acerca de cómo difuminar la línea entre lo digital y lo tangible, ofreciendo experiencias inmersivas que involucren al espectador de manera multisensorial.

🚀 Tu solución:

Experiencia inmersiva

Me gustaría para este punto traer al contexto un trabajo que hice con mi equipo de taller el semestre pasado, el cual se trata de un detective con múltiples personalidades, el cual tenía que resolver un caso, resulta que eventualmente se daría cuenta que a quien estaba buscando era a otra personalidad de él mismo. Dicho esto, sigamos con la idea de la experiencia:

Inspirándome en la idea de múltiples personalidades y la lucha interna del ser humano, esta instalación exploraría la interacción entre lo tangible y lo digital mediante un espejo interactivo que proyectaría una versión fragmentada y dinámica del espectador.
Los participantes se colocan frente a una especie de “espejo virtual” proyectado en una superficie. A medida que se mueven, su reflejo digital se descompone en fragmentos geométricos que reaccionan a su postura, voz y gestos, haciendo así que cada fragmento revele una “identidad alternativa”, mostrando versiones distorsionadas, glitch o incluso alteraciones inspiradas en el arte generativo y la estética cyberpunk.
La idea de esto es difuminar la línea entre lo real y lo virtual, explorando cómo la tecnología puede representar la fragmentación de la identidad y la percepción de uno mismo, algo que realmente ya está sucediendo. La instalación no solo sería visual, sino también sonora, pues la voz del usuario podría modularse en respuesta a sus movimientos, reforzando la idea de transformación y dualidad.

Referencias: Keijiro Takahashi - Blade Runner 2049 - Ghost in the Shell

Keijiro Takahashi,Shaders Unity

Investigación

En esta fase, profundizarás en la comprensión de las leyes de Newton y cómo se aplican en la simulación de fuerzas. Analizarás ejemplos de código y resolverás problemas para afianzar el conocimiento.

Actividad 03

Lectura Inicial Exploratoria

Enunciado: comienza dando una lectura inicial exploratoria a la unidad 2 del libro The nature of code. NO OLVIDES: inicial exploratoria (la idea es dedicarle solo 30 minutos). Mira de que se trata. Observa los ejemplos y lee las partes que más te llamen la atención.

Entrega: un texto donde:

Expliques qué fue lo más te llamó la atención de la unidad
¿Por qué?
¿Qué relación observas entre la unidad anterior y esta en relación con el marco Motion 101?

🚀 Tu solución:

Fuerzas y leyes de Newton

Lo que más me llamó la atención de la unidad sobre fuerzas fue la manera en que los principios físicos del mundo real pueden trasladarse de forma tan directa a la programación, empezando con la ecuación de Newton y su implementación en código, lo cual resalta cómo la aceleración de un objeto no solo depende de la fuerza aplicada, sino también de su masa. Me parece interesante porque esta relación permite crear simulaciones donde los objetos reaccionan de manera natural a su entorno, en lugar de moverse de forma arbitraria o predefinida, como ya se había hecho anteriormente con el marco 101, esto no solo hace que las animaciones sean más realistas, sino que también introduce una dimensión de emergencias y comportamientos inesperados que enriquecen la experiencia interactiva, dando lugar a muchas otras probabilidades y libertades creativas al momento de programar alguna experiencia del entretenimiento digital.

Me pareció especialmente relevante el concepto de acumulación de fuerzas, donde cada frame en la simulación suma nuevas fuerzas a la aceleración del objeto, nuevamente, algo similar al motion 101, y es que esto significa que el movimiento no es un cambio instantáneo de posición, sino un resultado de múltiples influencias que evolucionan con el tiempo y que lo mejor que puede pasar es que sea en ocasiones de forma cíclica. También debo resaltar que genuinamente me sorprendió la forma en que diferentes fuerzas, como la fricción o la resistencia del aire, y es que realmente pueden simularse con ajustes simples en la dirección y magnitud de los vectores, lo cual es algo que me parecía bastante más complicado de hacer, esto me hace pensar en la infinidad de maneras en que estos principios pueden aplicarse en el diseño de videojuegos, animaciones y arte generativo, sin necesidad de tener que invertir mucho tiempo en aplicar los conceptos.

En relación con la unidad anterior y el marco Motion 101, noto que ambas se centran en la idea de crear movimiento natural y fluido, en la unidad anterior, se exploraba cómo la posición de los objetos se mueven a partir de sumar velocidad y aceleración, pero en esta unidad se introduce la interacción con fuerzas externas, lo que agrega una capa más de complejidad. En Motion 101, estos conceptos son fundamentales, ya que los principios de animación y diseño interactivo buscan que los movimientos se sientan orgánicos, evitando transiciones bruscas y permitiendo que las interacciones tengan peso y respuesta realista, aquí no sólo se tiene en cuenta esto, sino otros factores que pueden afectar y dar más naturalidad.

Actividad 04

Marco Motion 101

Entrega: ¿Recuerdas el marco motion 101 de la unidad anterior? Regresa y dale una mirada rápida si es del caso. Luego considera lo siguiente:

let mover;

function setup() {
    createCanvas(640, 240);
    mover = new Mover();
}

function draw() {
    background(255);
    mover.show();
    mover.update();
    mover.checkEdges();
}

.
.
.


update() {

    // Aquí calculo la aceleración
    .
    .
    .
    this.velocity.add(this.acceleration);
    this.velocity.limit(this.topSpeed);
    this.position.add(this.velocity);
}
.
.
.

Mira bien el código. ¿Dónde está el marco motion 101?

En la unidad anterior tu definías la aceleración mediante algún algoritmo. ¿Cuáles eran? Muestra ejemplos de código de la unidad anterior (solo la parte donde se define la aceleración).
En esta unidad tu vas a calcular la aceleración. ¿Qué tiene que ver esto con las leyes de movimiento de Newton?

Entrega: texto y fragmentos de código donde des respuesta a cada una de las preguntas anteriores.

🚀 Tu solución:

Marco motion 101

En este caso, en la parte del código en donde se ve claramente el marco 101, es en la parte de Update(), aquí se calcula la aceleración, esta se suma a la velocidad, y la velocidad se suma a la posición, en esencia, esta es la base del marco motion 101, también, para complementar el código, se limita la velocidad y se verifican los bordes, para que el objeto nunca salga de la pantalla.
Hablando de los algoritmos de la unidad anterior mediante los cuales yo definía la aceleración, eran bastante simples, básicamente la aceleración que personalmente utilizaba en la unidad anterior era un vector el cual yo, arbitrariamente decidía qué valores tenía, podían ser aleatorios, o podían ser valores que como antes mencioné, yo simplemente ponía y poco más, a continuación mostraré ejemplo de estas entradas de código, directamente desde la unidad anterior:

class Mover {
  constructor() {
    this.position = createVector(random(width), random(height));
    this.velocity = createVector(random(-2, 2), random(-2, 2));
    this.aceleracion = createVector(0.01, 0.01);
  }

  update() {
    this.velocity.add(this.aceleracion)
    this.position.add(this.velocity);
  }


.
.
.
.

En este caso se aprecia cómo claramente está el marco motion 101, en donde a la velocidad se le suma la aceleración, y a la posición se le suma la velocidad, aquí la aceleración tiene valores concretos, y la velocidad está limitada a mi manera, me funciona y eso fue lo importante en su momento

Ahora, respecto a qué tienen que ver estas cosas con las leyes de movimiento de Newton, y es que en el caso de la unidad anterior, prácticamente ya empezamos a aplicar las leyes de Newton, sólo que de una forma sumamente básica, en la unidad actual, la 3, la idea es tener en cuenta las leyes de movimiento, el cómo se mueven los objetos en el mundo físico y cómo esto se puede traducir a código, y era algo que ya habíamos hecho, sólo que de forma muy arbitraria, básica, y sin tener en cuenta factores externos, prácticamente estábamos aplicando las leyes en un ambiente sumamente controlado, lo cual realmente es poco realista, ahora, la diferencia es que estas fuerzas que se aplican sobre el “objeto” serán calculadas, puede que mediante alguna fórmula de alguna fuerza ya existente, o nos podríamos inventar una, y también afectarán otros factores al objeto, como resistencia del aire, la masa del mismo, etc. Ahora todo es como un marco motion 101, pero mucho más complejo, y esto se traduce a las leyes de newton, pero en código.

Actividad 05

¿Y qué relación tiene esto de las leyes de Newton con al arte generativo?

Enunciado: analiza con detenimiento la siguiente idea.

Antes de comenzar, disfruta esta simulación donde puedes experimentar de manera creativa las leyes de la atracción. Ahora si, volviendo al lío de Monte Pío (pero no tanto).

La ecuación vectorial de la segunda ley de Newton se expresa como:

Donde:

La fuerza neta o la sumatoria de todas las fuerzas que actúan sobre un objeto:
Masa del objeto:
Aceleración del objeto:

Nota entonces que:

Y lo siguiente lo dejaré a tu criterio, finalmente tu eres quien toma las decisiones en tu mundo de arte generativo ¿Qué tal si la masa es igual a 1? Yo no veo por qué no, finalmente, en el mundo de los pixeles el artista manda (¿O no?) 😉.

Entonces ya tenemos la relación. En la unidad anterior tu definías en cada frame de la simulación un algoritmo para la aceleración. Ahora, la aceleración en cada frame la calcularemos como la influencia de todas las fuerzas sobre nuestros elementos gráficos 😹.

Si volvemos a nuestro texto guía: The Nature of code, verás que un elemento gráfica que se mueva en el canvas tendrá mínimo estas propiedades:

class Mover {
  constructor() {
    this.position = createVector();
    this.velocity = createVector();
    this.acceleration = createVector();
  }
}

Ahora, considera que en un frame actúan sobre este elemento dos fuerzas: viento y gravedad. Por tanto, en ese frame aplicarás las dos fuerzas:

mover.applyForce(wind);

y luego:

mover.applyForce(gravity);

Finalmente, en el método applyForce de la clase Mover tendrás algo como:

applyForce(force) {
  this.acceleration = force;
}

Y listo ¿Cierto?

Entrega: ¿Qué problema le ves a este planteamiento? ¿Qué solución propones? ¿Cómo lo implementarías en p5.js?

Nota: no olvides que queremos calcular la aceleración en cada frame como la sumatoria de todas las fuerzas que actúan sobre un objeto.

🚀 Tu solución:

Sumatoria de fuerzas

Esto es algo que ya se había planteado en la unidad 2 del libro, en la parte de acumulación de fuerzas, y es que el problema con este planteamiento es que el método applyForce(force) está sobrescribiendo el valor de this.acceleration en lugar de acumular las fuerzas que actúan sobre el objeto, esto se hace por referencia, es decir, que el método se reemplaza, al llamar primero a wind, y luego a gravity, sin importar cual sea el valor, en otras palabras, al llamar mover.applyForce(wind) y luego mover.applyForce(gravity), la primera fuerza (wind) se almacena en this.acceleration, pero en la siguiente línea esta es reemplazada por gravity, en lugar de sumarse, que es lo que estamos buscando.
En este caso sería algo fácil de solucionar, y es que en lugar de reemplazar estas fuerzas, debemos sumarlas en el código.

Es decir, en lugar de escribir:

applyForce(force) {
  this.acceleration = force;
}

Debemos escribir:

applyForce(force) {
  this.acceleration.add(force);
}

Con esta corrección, cada nueva fuerza que se aplique se sumará a la aceleración existente, en lugar de reemplazarla.

Ahora, en lugar de implementarlo yo, voy a tomar como ejemplo en el cual esto ya está corregido del libro e indicaré donde se puede notar

class Mover {
  constructor() {
    this.mass = 1;
    this.position = createVector(width / 2, 30);
    this.velocity = createVector(0, 0);
    this.acceleration = createVector(0, 0);
  }

  applyForce(force) {
    let f = p5.Vector.div(force, this.mass);
    this.acceleration.add(f);                    // A esto me refiero, en lugar de reemplazarse la fuerza, se suma,
  }                                              // de esta manera no sólo queda el viento, sino también la gravedad

  update() {
    this.velocity.add(this.acceleration);
    this.position.add(this.velocity);
    this.acceleration.mult(0);
  }

  display() {
    stroke(0);
    strokeWeight(2);
    fill(127, 127);
    ellipse(this.position.x, this.position.y, 48, 48);
  }

  checkEdges() {
    if (this.position.x > width) {
      this.position.x = width;
      this.velocity.x *= -1;
    } else if (this.position.x < 0) {
      this.velocity.x *= -1;
      this.position.x = 0;
    }
    if (this.position.y > height) {
      this.velocity.y *= -1;
      this.position.y = height;
    }
  }

}


let mover;

function setup() {
  createCanvas(640, 240);
  mover = new Mover();
  createP("Click mouse to apply wind force.");
}

function draw() {
  background(255);

  let gravity = createVector(0, 0.1);
  mover.applyForce(gravity);

  if (mouseIsPressed) {
    let wind = createVector(0.1, 0);
    mover.applyForce(wind);
  }

  mover.update();
  mover.display();
  mover.checkEdges();
}

Actividad 06

La fuerza neta debe ser acumulativa

Enunciado: ya te diste cuenta entonces que la fuerza neta es la sumatoria de todas las fuerzas que actúan sobre un objeto. Ahora, ¿Qué pasa si en un frame actúan sobre un objeto dos fuerzas? ¿Cómo calculas la aceleración resultante?

mover.applyForce(wind);
mover.applyForce(gravity);
.
.
.

applyForce(force) {
  // Segunda ley de Newton, pero con acumulación de fuerza, sumando todas las fuerzas de entrada a la aceleración
  this.acceleration.add(force);
}

⚠️

Te diste cuenta qué pasó aquí con respecto a la actividad anterior? Vuelve a mirar.

Entonces en cada frame, la aceleración se calcula como la sumatoria de todas las fuerzas que actúan sobre un objeto:

mover.applyForce(wind);
mover.applyForce(gravity);
mover.update();

Y en el método update() se actualiza la velocidad y la posición del objeto:

update() {
    this.velocity.add(this.acceleration);
    this.position.add(this.velocity);
    this.acceleration.mult(0);
}

Pero calma 🧘. Notaste algo raro al final de update()?

¿Por qué es necesario multiplicar la aceleración por cero en cada frame?
¿Por qué se multiplica por cero justo al final de update()?

Entrega: un texto donde expliques por qué es necesario multiplicar la aceleración por cero al final de cada frame.

🚀 Tu solución:

Aceleración controlada

Esto tiene una explicación muy importante, y es que la aceleración es una fuerza acumulativa, si esta fuerza no se reinicia, las fuerzas anteriores seguirán afectando al objeto indefinidamente, y es que una vez que la aceleración ha sido usada para actualizar la velocidad, ya no debe afectar el siguiente frame, esto sólo lograría que el objeto siga acelerando indefinidamente aunque no haya más fuerzas aplicadas, algo que de hecho me llegó a pasar en la unidad anterior y por eso controlé la velocidad, ahora veo que realmente fue un “machetazo”, pero como anteriormente dije, funcionó y en su momento, aunque ahora me doy cuenta que no era lo correcto, era lo importante.
Ahora, ¿por qué al final de update? se hace justo al final de update porque la aceleración primero debe cumplir su propósito antes de ser reseteada, esto quiere decir que primero debe afectar la velocidad, la cual afectaría la posición, una vez hecho esto, volvemos a lo anterior, se debe reiniciar para que no la siga afectando, pues ya hizo su trabajo, y de ser necesario, se le volvería a llamar, si por ejemplo se nos diera por reiniciarla antes, eliminaríamos la aceleración antes de actualizar la velocidad, lo cual rompería el sistema de movimiento y tampoco es lo que queremos, la idea es lograr un sistema de movimiento coherente y natural.

Actividad 07

En mi mundo los pixeles si tienen masa

Enunciado:

Como en tu mundo los pixeles tienen masa, entonces, ¿Qué pasa si en un frame actúan sobre un objeto dos fuerzas? ¿Cómo calculas la aceleración resultante?

mover.applyForce(wind);
mover.applyForce(gravity);

applyForce(force) {
    // Asume que la masa es 10
    force.div(10);
    this.acceleration.add(force);
}

¿Y listo cierto? Pues ¡No! 🤣

¿Qué ves raro?

Entrega: un texto donde expliques qué problema le ves a este planteamiento y qué solución propones. ¿Cómo lo implementarías en p5.js?

Nota: recuerda, ¿Cuándo se pasa algo a un función por valor y cuándo por referencia? En este caso, force es objeto de la clase p5.Vector, es decir, es un objeto que se pasa por referencia. ¿Qué implica esto?

🚀 Tu solución:

Hablemos de la masa

Aquí la cuestión está en que al utilizar la línea de código

applyForce(force) {
    // Asumiendo que la masa es 10
    force.div(10);
    this.acceleration.add(force);
}

Lo que estamos haciendo es modificar directamente el vector de fuerza original, el cual pasamos como argumento, esto tiene mucho que ver con los conceptos de función por valor y por referencia, tal y como dice el enunciado, en este caso lo ideal sería dividir la fuerza sin modificar el vector original, utiliando algo como esto:

applyForce(force){
let f = p5.Vector.div(force, this.mass); // En este lugar se cambia 10 por this.mass
this.acceleration.add(force);
}

Esto lo que nos da es la libertad de cambiar la masa del objeto sin tener que modificar la función applyForce(), sino sólo la “this.mass”.

Básicamente el problema aquí radica en que p5.Vector es un objeto pasado por referencia, y si dividimos la “force” entre 10, modificamos el vector original de fuerza, algo que no es bueno en caso tal de necesitar usar la fuerza en otros lugares (Lo cual es el caso), para evitar esto lo que debemos hacer es crear una copia o utilizar un nuevo vector, en este caso, lo que hicimos con la línea propuesta fue crear una nueva instancia para que la fuerza fuera de la función no cambie, es decir, la fuerza original, siga siendo la fuerza original siempre que necesitemos usarla.

Actividad 08

Paso por valor y paso por referencia

Enunciado:

En el siguiente código:

let friction = this.velocity.copy();
let friction = this.velocity;

¿Cuál es la diferencia entre las dos líneas?
¿Qué podría salir mal con let friction = this.velocity;

De nuevo, toca repasar. ¿Cuál es la diferencia entre copiar por VALOR y por REFERENCIA?

En el fragmento de código ¿Cuándo es por VALOR y cuándo por REFERENCIA.

Entrega: un texto donde expliques la diferencia entre paso por valor y paso por referencia. ¿Qué implica esto en el fragmento de código?

🚀 Tu solución:

Diferencia entre valor y referencia

Aquí tenemos un caso claro de la diferencia entre estos conceptos y cómo puede ser uno mucho mejor que otro para los fines que tenemos en mente, en este caso, vamos a hablar individualmente de cada línea, empecemos por la:

let friction = this.velocity.copy();

En este caso tenemos un objeto de paso por valor, aquí tenemos una ventaja grande y es que la función copy() crea un nuevo objeto con los mismos valores de this.velocity, pero en otro lugar de la memoria, de esta manera podemos modificar friction sin afectar el valor original de velocity, dándonos la libertad de poder usar esta función más adelante con su valor original sin tener ningún tipo de problema, algo que no podemos hacer en:

let friction = this.velocity;

En donde tenemos un claro ejemplo de paso por referencia, en este caso friction en lugar de ser una copia, es una referencia de velocity, esto hace que cualquier cambio que hagamos en esta función afectará directamente a la función original de velocity, dándonos como resultado que se modifique su valor original, y al querer por ejemplo modificar friction solamente, no podremos dejarlo ahí ya que esto afectará a su vez a velocity, no tendremos libertad de utilizar fricción en el objeto ya que si ponemos que la friction se multiplica por -1 por ejemplo, la velocidad también se multiplicará por -1, rompiendo totalmente la naturalidad del objeto en movimiento, en lugar de simular un fenómeno natural como lo es la fricción

Actividad 09

Creando fuerzas en tu mundo de pixeles

Enunciado:

En tu mundo de pixeles tu puedes crear las fuerzas o las puedes modelar.

La fuerza

Vamos a probar con lo segundo, modelar una fuerza. Ve a la sección Modeling forces del texto guía. Lee con detenimiento y responde:

Dada una fuerza que desees modelar para usar en tu simulación ¿Qué pasos hay que seguir?

Entrega: un texto donde expliques los pasos a seguir para modelar una fuerza en tu simulación.

🚀 Tu solución:

Modelado de una fuerza

Bueno, según lo leído en el texto guía, tenemos que primero que todo tener clara la fórmula que vamos a usar en nuestra simulación y las fuerzas que están presentes en la misma, de esta manera tendremos claro desde un principo qué vectores van a ser factores clave para el modelo de esta en la simulación, es cierto que podemos inventarnos las fuerzas que querramos, pero realmente aquí haré un ejemplo hablando como de fuerzas ya existentes.

En este caso, teniendo una fuerza con cierto grupo de variables, debemos principalmente tener en cuenta lo siguiente: la dirección y la magnitud de la fuerza, y cómo estas dos cosas afectan a las variables involucradas en la fórmula de la misma, después de tener esto totalmente claro, el siguiente paso es traducir esta fórmula a un código que pueda ser utilizado para simular la fuerza y aplicarla al objeto que tenemos en pantalla.

Ahora, desglosemos esto con ejemplos, si por ejemplo en la fuerza están involucradas la gravedad, la velocidad, y la fuerza normal, y estas se multiplican entre sí, tenemos que tener claro en qué dirección se multiplican las mismas, ya que es importante siempre saber hacia dónde va la fuerza, por ejemplo si una de las variables es negativa, esta siempre debe ser multiplicada por -1, si una variable ya es un vector dentro del código, se le puede llamar mediante una referencia utilizando una copia, una instancia, a veces, las fuerzas tienen constantes que arbitrariamente podemos cambiar, esto es algo que realmente va en decisión de quien esté haciendo el código.

Ahora, al final, después de tener en cuenta estos valores, si son constantes, variables, referencias dentro del código, etc, lo que debemos hacer es usar funciones de JS para recrear la fórmula en código, multiplicando con mult(), dividiendo por div(), etc, al tener todo esto se normaliza el vector y se multiplica por la magnitud, la cual normalmente depende de nosotros y suele ser la normal multiplicada por la constante que arbitrariamente decidamos, hecho esto, ya estaría lista y calculada nuestra fuerza, al mismo tiempo que traducida a código, realmente no es algo complicado, se debe tener un orden y siempre lo recomendable es utilizar copias para no modificar los valores de ninguna otra fuerza y poder tener una mayor libertad en el código, saber cómo se usan las funciones y como se aplican en el contexto, y poco más, las cosas principales son la dirección y la magnitud, y pues siempre saber en qué momento se usa una función u otra en la fórmula para que la codificación sea correcta.

Aplicación

En esta fase, aplicarás los conceptos aprendidos para crear simulaciones interactivas que involucren diferentes tipos de fuerzas.

Actividad 10

Modelando fuerzas

Enunciado: diseña varias simulaciones interactivas que muestren cómo modelar fuerzas en tu mundo de pixeles.

Las fuerzas que puedes modelar son las siguientes:

Fricción.
Resistencia del aire y de fluidos.
Atracción gravitacional.

Entrega: el código de cada una de las simulaciones y un texto donde expliques cómo modelaste cada fuerza. Adicionalmente, no olvides incluir un enlace a cada simulación en el editor de p5.js. Para hacer esto recuerda que debes estar logueado en el editor de p5.js y que debes hacer clic en el botón “Save” para guardar los cambios. De esta manera, el enlace a tu simulación se actualizará en la barra de direcciones de tu navegador.

🚀 Tu solución:

Modelando las fuerzas:

Fricción:

La fricción es una fuerza que se modela tomando una copia de la velocidad del objeto, normalizándola para obtener solo la dirección y multiplicándola por un coeficiente negativo, lo que genera una fuerza que se opone al movimiento; esta fuerza se aplica a la aceleración del objeto, sumándose a otras fuerzas (como la gravedad), y al final de cada frame se reinicia la aceleración para que las fuerzas se recalculen desde cero, logrando que el objeto desacelere de forma realista.

El acceso a la aplicación interactiva estaría en el siguiente link: Aplicación interactiva de Fricción
Resistencia al aire:

En esta simulación, la resistencia del aire se modela calculando una fuerza de arrastre (drag) que se opone al movimiento del objeto y es proporcional al cuadrado de su velocidad. Para lograrlo, se copia la velocidad del objeto, se invierte su dirección y se normaliza, y luego se multiplica por un coeficiente y por la magnitud de la velocidad al cuadrado. Esta fuerza de drag se aplica al objeto junto con otras fuerzas (como la gravedad y, opcionalmente, el viento al presionar el mouse), lo que provoca que el objeto desacelere de forma natural al moverse. Al final de cada frame, la aceleración se reinicia para que en el siguiente se vuelvan a calcular las fuerzas actuales, logrando así una simulación realista del efecto de la resistencia del aire.

El acceso a la aplicación interactiva estaría en el siguiente link: Aplicación interactiva de Resistencia al aire
Atracción gravitacional:

En esta simulación se modela la atracción gravitacional aplicando la ley de gravitación universal de Newton, que establece que la fuerza de atracción entre dos cuerpos es proporcional al producto de sus masas e inversamente proporcional al cuadrado de la distancia entre ellos. Se define un objeto “Attractor” con una masa considerable y una posición fija (que se puede reposicionar haciendo click), y se calcula el vector de fuerza desde el “mover” hacia el “attractor”. Esta fuerza se normaliza, se ajusta con la constante gravitacional y se aplica al mover, modificando su aceleración, velocidad y posición en cada frame. De esta forma, se observa cómo el mover es atraído hacia el atractor, creando una experiencia interactiva donde se puede modificar la atracción al reposicionar el atractor.

El acceso a la aplicación interactiva estaría en el siguiente link: Aplicación interactiva de la Atracción gravitacional

Ahora, mostremos los códigos de manera explícita:
Aquí tendríamos el código de la fricción:

class Mover {
  constructor() {
    this.mass = 1;
    this.position = createVector(width / 2, 30);
    this.velocity = createVector(2, 0); // Se inicia con cierta velocidad horizontal
    this.acceleration = createVector(0, 0);
  }

  applyForce(force) {
    let f = p5.Vector.div(force, this.mass);
    this.acceleration.add(f);
  }

  // Calcula y aplica la fricción, que se opone a la dirección del movimiento.
  applyFriction() {
    // Copia la velocidad para no modificar el vector original (paso por referencia vs copia)
    let friction = this.velocity.copy();
    friction.normalize();       // Nos quedamos solo con la dirección
    friction.mult(-0.02);       // Coeficiente de fricción: ajustar para mayor o menor efecto
    this.applyForce(friction);  // Se suma a la aceleración, junto con otras fuerzas aplicadas
  }

  update() {
    this.velocity.add(this.acceleration);
    this.position.add(this.velocity);
    this.acceleration.mult(0);
  }

  display() {
    stroke(0);
    strokeWeight(2);
    fill(255,127, 127);
    ellipse(this.position.x, this.position.y, 48, 48);
  }

  checkEdges() {
    if (this.position.x > width) {
      this.position.x = width;
      this.velocity.x *= -1;
    } else if (this.position.x < 0) {
      this.velocity.x *= -1;
      this.position.x = 0;
    }
    if (this.position.y > height) {
      this.velocity.y *= -1;
      this.position.y = height;
    }
  }
}

let mover;

function setup() {
  createCanvas(640, 640);
  mover = new Mover();
  createP("Esta simulación modela fricción: la fuerza que se opone al movimiento, sumada a la gravedad.");
}

function draw() {
  background(92,155,155);

  // Aplicamos una gravedad constante
  let gravity = createVector(0, 0.1);
  mover.applyForce(gravity);

  if (mouseIsPressed) {
  let wind = createVector(0.1, 0); // Aumenté la fuerza del viento
  mover.applyForce(wind);
}


  // Aplicamos fricción: fuerza opuesta a la dirección del movimiento
  mover.applyFriction();

  mover.update();
  mover.display();
  mover.checkEdges();
}

Aquí tendríamos el código de la resistencia al aire:

class Mover {
  constructor() {
    this.mass = 1;
    this.position = createVector(width / 2, 30);
    this.velocity = createVector(0, 0);
    this.acceleration = createVector(0, 0);
  }

  // Aplica una fuerza dividiéndola por la masa
  applyForce(force) {
    let f = p5.Vector.div(force, this.mass);
    this.acceleration.add(f);
  }

  // Modela la resistencia del aire (drag)
  // Se calcula como una fuerza opuesta al movimiento y proporcional al cuadrado de la velocidad.
  applyAirResistance(coefficient) {
    // Copiamos la velocidad y obtenemos su magnitud al cuadrado.
    let drag = this.velocity.copy();
    let speedSq = this.velocity.magSq();

    // Invertir la dirección para que la fuerza se oponga al movimiento
    drag.mult(-1);
    drag.normalize();
    // La fuerza de drag es proporcional al coeficiente y al cuadrado de la velocidad
    drag.mult(coefficient * speedSq);

    this.applyForce(drag);
  }

  update() {
    this.velocity.add(this.acceleration);
    this.position.add(this.velocity);
    // Reinicia la aceleración para que en cada frame se recalculen las fuerzas aplicadas
    this.acceleration.mult(0);
  }

  display() {
    stroke(0);
    strokeWeight(2);
    fill(127,255, 127);
    ellipse(this.position.x, this.position.y, 48, 48);
  }

  checkEdges() {
    if (this.position.x > width) {
      this.position.x = width;
      this.velocity.x *= -1;
    } else if (this.position.x < 0) {
      this.velocity.x *= -1;
      this.position.x = 0;
    }
    if (this.position.y > height) {
      this.position.y = height;
      this.velocity.y *= -1;
    }
  }
}

let mover;

function setup() {
  createCanvas(640, 640);
  mover = new Mover();
  createP("Click mouse to apply wind force.");
}

function draw() {
  background(155,155,155);

  // Aplica gravedad
  let gravity = createVector(0, 0.1);
  mover.applyForce(gravity);

  // Aplica la resistencia del aire con un coeficiente (ajusta este valor para modificar el efecto)
  mover.applyAirResistance(0.01);

  // Si se presiona el mouse, aplica una fuerza de viento
  if (mouseIsPressed) {
    let wind = createVector(0.1, 0);
    mover.applyForce(wind);
  }

  mover.update();
  mover.display();
  mover.checkEdges();
}

Aquí tendríamos el código de la atracción gravitacional:

class Mover {
  constructor() {
    this.mass = 1;
    this.position = createVector(random(width), random(height));
    this.velocity = createVector(0, 0);
    this.acceleration = createVector(0, 0);
  }

  applyForce(force) {
    // Se divide la fuerza por la masa para obtener la aceleración (F = ma)
    let f = p5.Vector.div(force, this.mass);
    this.acceleration.add(f);
  }

  update() {
    this.velocity.add(this.acceleration);
    this.position.add(this.velocity);
    this.acceleration.mult(0); // Reinicia la aceleración para el siguiente frame
  }

  display() {
    stroke(0);
    strokeWeight(2);
    fill(255,127, 127);
    ellipse(this.position.x, this.position.y, 48, 48);
  }

  checkEdges() {
    if (this.position.x > width) {
      this.position.x = width;
      this.velocity.x *= -1;
    } else if (this.position.x < 0) {
      this.position.x = 0;
      this.velocity.x *= -1;
    }
    if (this.position.y > height) {
      this.position.y = height;
      this.velocity.y *= -1;
    } else if (this.position.y < 0) {
      this.position.y = 0;
      this.velocity.y *= -1;
    }
  }
}

class Attractor {
  constructor() {
    this.mass = 20;
    this.position = createVector(width / 2, height / 2);
  }

  attract(mover) {
    // Vector que va desde el mover hacia el atractor
    let force = p5.Vector.sub(this.position, mover.position);
    // Calcula la distancia y la limita para evitar fuerzas extremas\n
    let distance = force.mag();
    distance = constrain(distance, 5, 25);
    force.normalize();
    // La fuerza de atracción se calcula con la ley gravitacional: F = G * (m1 * m2) / (r^2)
    let strength = (G * this.mass * mover.mass) / (distance * distance);
    force.mult(strength);
    return force;
  }

  display() {
    fill(200, 11, 11);
    noStroke();
    ellipse(this.position.x, this.position.y, this.mass, this.mass);
  }
}

let mover;
let attractor;
let G = 1; // Constante gravitacional para ajustar la fuerza

function setup() {
  createCanvas(640, 640);
  mover = new Mover();
  attractor = new Attractor();
  createP("Haz click para reposicionar el atractor.");
}

function draw() {
  background(155);

  // Calcula la fuerza gravitacional ejercida por el atractor sobre el mover
  let force = attractor.attract(mover);
  mover.applyForce(force);

  mover.update();
  mover.display();
  mover.checkEdges();
  attractor.display();
}

// Permite reposicionar el atractor con un click
function mousePressed() {
  attractor.position.set(mouseX, mouseY);
}

Actividad 11

El problema de los n-cuerpos

Enunciado: vas a diseñar una simulación interactiva, en la que se muestre el problema de los n-cuerpos. En el texto guía tienes una sección que te puede ayudar a entender cómo modelar este problema, pero la idea es que uses tu creatividad para crear algo diferente basado en ese concepto. ¿Qué tal si te inspiras en las esculturas cinéticas de Alexander Calder?

Entrega:

El código de tu simulación
Un texto donde expliques cómo modelaste el problema de los n-cuerpos.
No olvides incluir un enlace a tu simulación en el editor de p5.js.
Adicionalmente, captura una imagen del resultado.

🚀 Tu solución:

El problema de los n-cuerpos

En este caso lo que hice fue modificar el sistema de cuerpos para que no se atraigan entre sí todo el tiempo, sino que floten libremente hasta que le de click en la pantalla, siendo así, cuando hago click, los cuerpos son atraídos hacia ese lugar con una fuerza gravitacional más fuerte, lo que hace que se intenten agrupar, una vez que llegan, cuando logran hacerlo, la fuerza vuelve a la normalidad y los cuerpos se dispersan de nuevo, también puse colisiones con los bordes de la pantalla para que reboten en lugar de atravesarlos e irse al inifinito, limité la velocidad y poco más. A pesar de estos cambios, sigue siendo un problema de los n-cuerpos porque cada objeto sigue teniendo masa, posición, velocidad y aceleración, y las fuerzas siguen afectando su movimiento. En vez de que los cuerpos interactúen gravitacionalmente entre ellos, ahora reaccionan a la interacción con el punto donde hago clic, pero la esencia del problema sigue siendo la simulación de cuerpos en movimiento bajo fuerzas externas, con más o menos control en este caso.

Problema de los n-cuerpos modificado

Aleatorio Click1 Click2

class Body {
  constructor(x, y, m) {
    this.mass = m;
    this.position = createVector(x, y);
    this.velocity = createVector(random(-1, 1), random(-1, 1)); // Velocidad inicial aleatoria
    this.acceleration = createVector(0, 0);
    this.target = null; // Punto objetivo
  }

  applyForce(force) {
    let f = p5.Vector.div(force, this.mass);
    this.acceleration.add(f);
  }

  update() {
    if (this.target) {
      let force = p5.Vector.sub(this.target, this.position);
      let distance = force.mag();

      if (distance < 5) {
        this.target = null; // Liberar cuando llegan
      } else {
        force.setMag(G * this.mass);
        this.applyForce(force);
      }
    }

    this.velocity.add(this.acceleration);
    this.velocity.limit(2);
    this.position.add(this.velocity);
    this.acceleration.mult(0);

    this.checkEdges(); // Verificar colisión con bordes
  }

  checkEdges() {
    if (this.position.x <= 0 || this.position.x >= width) {
      this.velocity.x *= -1;
      this.position.x = constrain(this.position.x, 0, width);
    }
    if (this.position.y <= 0 || this.position.y >= height) {
      this.velocity.y *= -1;
      this.position.y = constrain(this.position.y, 0, height);
    }
  }

  show() {
    stroke(0);
    strokeWeight(2);
    fill(255,127, 127);
    circle(this.position.x, this.position.y, this.mass * 25);
  }
}

let bodies = [];
let G = 0.1;

function setup() {
  createCanvas(640, 640);
  for (let i = 0; i < 10; i++) {
    bodies[i] = new Body(random(width), random(height), random(0.5, 2));
  }
}

function draw() {
  background(155,155,255);

  for (let body of bodies) {
    body.update();
    body.show();
  }
}

function mousePressed() {
  for (let body of bodies) {
    body.target = createVector(mouseX, mouseY);
  }
}

Consolidación y metacognición

En esta fase final, reflexionarás sobre el proceso de aprendizaje y consolidarás los conocimientos adquiridos.

Actividad 12

Análisis de resultados

Enunciado: revisa los resultados de las actividades de la fase APPLY. ¿Qué desafíos encontraste al aplicar los conceptos aprendidos? ¿Qué aprendiste de estos desafíos?

Entrega: descripción de los desafíos encontrados y las lecciones aprendidas durante la fase APPLY. No olvides incluir ejemplos concretos de tu experiencia.

🚀 Tu solución:

Desafíos encontrados

Diría que los desafíos que encontré se debieron principalmente a la implementación y la modelación de las diferentes fuerzas que se me llegaron a pedir, principalmente en la actividad 10,
en donde tenía que modelar fuerzas diferentes y aplicar estos conceptos a código, haciendo que de esta manera se pudieran simular las fuerzas en el entorno 2d que nos brinda javascript, realmente no estoy seguro de si de la forma en que lo hice fue totalmente claro, pero diría que en eso específicamente fue que se centraron mis dificultades al momento de completar la fase, ya que aunque realmente uno entiende cómo funcionan estas fuerzas en la vida real, traducirlas a código, modelarlas y aplicarlas no es algo que en mi caso salga me haya salido y se me haya ocurrido así de primerazo, ya que aparte de tener claras cómo funcionan las fuerzas hay que tener en cuenta las muchas funciones de código de js que nos pueden resultar útilles para llegar a estos resultados sin necesidad de ser reduntantes, puesto que hay funciones que son perfectas para simular este tipo de cosas, sea que estas estén hechas o no principalmente para este propósito.

Por ejemplo, en el caso de la resistencia al aire, no fue sólo utilizar la función “drag” sino, modificar la misma y de esta manera modelar lo que vendría siendo una fuerza que simulara la resistencia al aire de específicamente ese objeto en ese código, yo no lo llegué a pensar y tuve que ponerme a buscar fomas de hacerlo y encontré esa, ya luego la implementación fue otro cuento, pero el tema es ese, que en ocasiones, como esta, no se me hace tan claro qué es lo que tengo que hacer, lo cual puede que me dificulte un poco los avances, aún así es cuestión de utilizar de apoyo la infinidad de recursos que tenemos a nuesstra disposición para resolver este tipo de problemas de razonamiento.

De esto aprendí que realmente debemos tener muy claros y muy presentes todos los conceptos aprendidos durante los cursos, ya que todos y cada uno de ellos son una pieza fundamental, todo es un sistema muy interesante al cual si le hace falta la mínima cosa no seguirá funcionando de manera óptima, y en este caso, si hubiera tenido en cuenta un concepto que ví hace ya muchas actividades, quizá no hubiera tenido que buscar cómo hacerlo y simplemente lo hubiera implementado directamente, pero es cuestión de seguir estudiando y hacer un buen proceso de razonamiento y memorización.

Actividad 13

Conexión con Diseño de Entretenimiento Digital

Enunciado: describe cómo los conceptos de esta unidad pueden ser utilizados en el diseño de videojuegos, experiencias interactivas o animaciones. Da ejemplos concretos.

Entrega: descripción de al menos tres aplicaciones de los conceptos aprendidos en el diseño de entretenimiento digital, con ejemplos concretos.

🚀 Tu solución:

Conexión con el entretenimiento digital

No es un secreto que las fuerzas son de gran utilidad para poder diseñar mundos más creíbles y reactivos, mejorando la inmersión tanto en videojuegos como en animaciones, en este caso, todas estas fuerzas permiten simular momvimientos más naturales e interacciones muchísimo más realistas en todo tipo de entornos digitales.

Como ejemplos concretos se me ocurre lo siguiente:

(1) En el Red Dead Redemption 2 tenemos un ejemplo perfecto de tanto la resistencia del aire como de la fricción, en este juego hay una infinidad de detalles impresionantes, empecemos con que la resistencia del aire afecta la velocidad del caballo y la fricción influye en cómo se desplaza en diferentes terrenos como la arena, nieve, lodo, pasto normal, etc. Las balas en este juego tienen física realista, ya que la resistencia del aire hace que pierdan velocidad y caigan con la distancia.
Así mismo, esto se puede aplicar de muchas otras formas en otros juegos, es fácil pensar e incluso implementar el hecho de que dependiendo del terreno en que esté un personaje, este se mueva con una mayor o menor velocidad, y de hecho tiene mucho sentido.
(2) En las animaciones de Spiderman, en este caso especifiquemos, en las de Spider-Man: Into the Spider-Verse, cuando Miles Morales salta de un edificio, su aceleración y velocidad cambian en función de la gravedad, la resistencia del aire y el peso, este uso de fuerzas le da una sensación única de peso y momentum a la animación.
Esto mismo se puede replicar en otro tipo de animaciones, en dónde también puede entrar la fricción, en caso tal de que el personaje entre en un entorno más denso, algo como agua, un poco de objetos acumulados, aquí ya tendrían que tenerse en cuenta otros detalles importantes para que la animación tenga sentido, pero el hecho de que el simple hecho de que en otros entornos se afecete la velocidad de movimiento, ya es una gran ventaja
(3) También podemos encontrar el problema de los ncuerpos en videojuegos por ejemplo, en el caso de Super Mario Galaxy, en donde cada planeta genera su propia gravedad, atrayendo a Mario según su cercanía,j aquí, al saltar, la dirección de la fuerza cambia dependiendo del planeta en el que esté, lo que simula el problema de los n-cuerpos en un entorno interactivo.

Actividad 14

Reflexión sobre el proceso de aprendizaje

Enunciado: reflexiona sobre tu propio proceso de aprendizaje durante esta unidad. ¿Qué estrategias te resultaron más efectivas para comprender los conceptos? ¿Qué podrías mejorar en futuras unidades?

Entrega:

Descripción de las estrategias de aprendizaje utilizadas y su efectividad. No olvides mencionar de manera explícita en qué punto del proceso aplicaste estas estrategias, ilustrando con ejemplos concretos de tu trabajo en la unidad.
Planteamiento de mejoras para futuras unidades.

🚀 Tu solución:

Proceso de aprendizaje

En esta ocasión aparte de las estrategias de aprendizaje que ya he mencionado anteriormente entre las cuales está principalmente combinar la página guía del curso, otras páginas que hablen de estos temas técnicamente y pedirle a nuestro querido chatgpt que me explique estos temas comparándolos con otros conceptos que tengo más familiarizados, lo cual me ha seguido ayudando demasiado, está ahora el hecho de volver en mis pasos y leer actividades anteriores, e incluso unidades anteriores, ya que he notado que muchas veces, hay problemas que se resuelven de manera mucho más sencilla con conceptos que supuestammente ya quedaron atrás (en otras unidades) pero que se deben retomar para poder seguir con el proceso de aprendizaje de manera efectiva, muchas veces haciendo esto encontré soluciones a problemas actuales, es decir, volviendo en conceptos y en soluciones que di a otros problemas de otras actividades, me doy cuenta que las actuales se podrían resolver de maneras similares, de esta forma puede que no haga lo mismo, pero si me resultan muy útiles los recursos que yo mismo he puesto a mi disposición como referencias de código o incluso inspiración para poder diseñar nuevas aplicaciones de los nuevos conceptos aprendidos.

Por ejemplo en esta unidad, en la actividad 5, hubo un problema casi que exactamente igual a otro que había en la unidad anterior, con el tema de sumar los vectores para poder lograr primero velocidad y luego aceleración, sólo que en este caso ya estábamos hablando de otro tipo de fuerzas más complejas, pero el principio era el mismo, no se debían reemplazar los valores, sino sumarlos, para poder aplicar todas las fuerzas que queríamos aplicar y de esa forma dar solución al problema, el “pero” era el mismo, y la solución casi que igual.

En cuanto a mejoras lo que debo hacer, lo principal es tener más compromiso, he tenido grandes retrasos en las unidades, ya vamos bastante avazandos en tiempo y yo estoy muy atrás en el cronograma, el hecho de ponerme al día me puede alivianar muchísimo la carga del trabajo y seguramente de esa manera pueda entender muchísimo mejor muchos de los conceptos que aquí se plantean , y esto conlleva tenerlos más presentes, y por ende estudiarlos más seguido, de esta forma no habrá lugar a que se me olviden algunos o varios de ellos, mejorando así bastante la memoria y trabajando aún más en el correcto razonamiento.

Actividad 15

Autoevaluación

Enunciado: evalúa tu nivel de comprensión de los conceptos de la unidad en una escala del 1 al 5 (1: Nada de comprensión, 5: Dominio completo). Justifica tu autoevaluación con ejemplos concretos de tu trabajo en la unidad. Identifica áreas donde necesitas reforzar tu aprendizaje.

Entrega:

Autoevaluación con justificación y ejemplos concretos de tu trabajo que sustenten.
Identificación de áreas de mejora.

🚀 Tu solución:

Autoevaluación de la unidad

Autoevaluación: 4/5
En esta ocasión diría que en comparación estoy bastante similar a la unidad anterior, en este caso por suerte, habían muchos conceptos que realmente ya conocía, ya que eran conceptos de física y la única diferencia aquí era que se trataba de ponerlos en código, sin embargo, es un hecho de que esa será siempre un área de mejora constante, el hecho de aprender y reforzar más sobre esa lógica de programación para poder tener una mayor facilidad a la hora de implementar todo lo que tengo en mente en código, pero bueno, volvamos al tema, respecto a los conceptos de la unidad tengo bastante claros la gran mayoría de ellos, el tema de las fuerzas, la sumatoria de fuerzas, como es que estas salen, las leyes de Newton, en general todo es bastante claro conceptualmente, el pequeño problema viene a la hora de modelar estas fuerzas y traducirlas, o mejor dicho implementarlas como código, esto es algo que intenté hacer en la actividad #10, y se me complicó un poco, ya que sí llegué a entender el texto referente a esto, cuando se habló de la sumatoria de fuerzas y posteriormente del modelado de las mismas, pero a la hora de hacer realidad esto, no me fue tan fácil, tenía claro qué tocaba hacer, pero como mencioné anteriormente, para mí tenía que hacerlo de una forma específica y no caí en cuenta de que habían funciones que hacían eso que yo estaba buscando en su momento, es interesante esto y aunque no me fue tan mal entendiendo por qué se modelaban de esa manera, es cierto que no me salió de primerazo y no se me hizo tan fácil hacerlo, tuve que recurrir a la tan útil ayuda de la IA.
Ya lo he dicho varias veces, en general necesito mejorar y reforzar la lógica de programación que tengo, yo en los códigos que hago logro entender todo lo que sucede, pero si me ponen a hacer un código de esos por mi cuenta, sin ayuda de nada, lo más seguro es que me demore bastante e incluso así tenga muchos errores, no ha sido tan fácil “reconciliarme” con el tema de la programación a pesar de que si lo he intentado y al principio del semestre me llegué a emocionar bastante con esto, no me fue tan fácil continuar con esta disciplina, la cual es sumamente necesaria para poder recuperar ese nivel perdido, y en esencia mejorar el que ya tengo.