Recupera el Sistema de Comunicaciones

Entras al curso pensando que son puntos free al ver la introducción | Son ejercicios de js para resolver

Esta clase puede ayudarles a resolver el problema: https://platzi.com/clases/2419-javascript-poo-intermedio/39821-instance-of-en-javascript-con-instancias-y-prototi/ 💪

Que gran forma de probar lo aprendido!!.. super divertido Platzi!

export class Satelite {
  constructor({
    name,
  }) {
    this.name = name;
    this.messages = [];
  }
  
  send({ from, to, text }) {
    if (
      (from instanceof Astronaut) &&
      (to instanceof SpaceStation) &&
      (to.team.includes(from.name))
    ) {
      this.messages.push({
        from: from.name,
        to: to.name,
        text,
      });
    }
  }

Listo, estuvo genial el desafío!🚀
+1

Interesante prueba, me gusta este tipo de cursos interactivos!

MI solución:

 send({ from, to, text }) {
    if(from instanceof Astronaut && to instanceof SpaceStation &&to.team.includes(from.name)){
      this.messages.push({
        from: from.name,
        to: to.name,
        text,
      });
    }
    
  }

Solo modifiqué el método send de la clase Satelite para que validara todos lo indicado

Me encantó esta temática!

Tip: Al hacer una condicional pueden “concatenar” varias condiciones con el operador && el cual pide que todas estas devuelvan true para que se cumpla la condicion, ejemplo:

if (condicion a && condicion b) {
	// Solo se ejecuta si a y b devuelven true
}

Pueden tener 2 o más condiciones según lo vean conveniente. 👍

I feel good!!! 🎵🎵🎵

¡Lo resolví!
Lo único que hice fue modificar el método send de la clase Satelite.

function ValidateAstronaut(astronaut) {
    if (astronaut instanceof Astronaut) {
        return true;
    }
    return false;
}

function ValidateStation(station) {
    if (station instanceof SpaceStation) {
        return true;
    }
    return false;
}

function VefifyIfAstronautIsInStation(astronaut, station) {
    if (station.team.includes(astronaut.name)) {
        return true;
    }
    return false;
}

export function simulacion({ satelite, estacion, astronauta, texto }) {
    satelite.send({
        from: astronauta,
        to: estacion,
        text: texto,
    });

    return satelite.messages;
}

export class Astronaut {
    constructor({ name }) {
        this.name = name;
    }
}

export class SpaceStation {
    constructor({ name }) {
        this.name = name;
        this.team = [];
    }

    addTeamMember(newMember) {
        if (newMember instanceof Astronaut) {
            this.team.push(newMember.name);
        }
    }
}

export class Satelite {
    constructor({ name }) {
        this.name = name;
        this.messages = [];
    }

    send({ from, to, text }) {
        if (!ValidateAstronaut(from)) {
            return [];
        }

        if (!ValidateStation(to)) {
            return [];
        }

        if (!VefifyIfAstronautIsInStation(from, to)) {
            return [];
        }
        
        this.messages.push({
            from: from.name,
            to: to.name,
            text,
        });
    }
}

Mi Solucion
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

Solo agregue una validacion en la clase Satelite

export class Satelite {
  constructor({
    name,
  }) {
    this.name = name;
    this.messages = [];
  }
  
  send({ from, to, text }) {
    const isAstronaut = from instanceof Astronaut
    const isSatelite = to instanceof SpaceStation
    const isTeamMember = to.team.some(member => member === from.name)

    if (isSatelite && isAstronaut && isTeamMember) {
      this.messages.push({
        from: from.name,
        to: to.name,
        text,
      })
    }
  }
}

Muy entretenido! Aunque sería genial que pudiéramos poner el código en pantalla completa.

Tarda un poco poer si esta bueno voy a revisar como resolverlo.

Primera Fase completa!!! vamos Juan DC por a salvarte!! jajajaja

Solución 😄…
Tuve un problema con las condiciones, intenté ponerlas en una única condicional con || ORs, pero a la primera que se cumplía una condición del bloque if, se ejecutaba el código dentro del mismo.
.
Entonces habían ocasiones donde tenía impostor y estación ambos impostor a la vez, y se cumplía primero la condición del astronauta impostor, así que la de la estación nunca se daba.
.

export function simulacion({ satelite, estacion, astronauta, texto }) {

  if (!(estacion instanceof SpaceStation)) { 
    return [];
  }

  if (
    !estacion.isCrewMember(astronauta) ||
    !(astronauta instanceof Astronaut)
  ) { 
    return [];
  }

  satelite.send({
    from: astronauta,
    to: estacion,
    text: texto,
  });

  return satelite.messages;
}

export class Astronaut {
  constructor({ name }) {
    this.name = name;
  }
}

export class SpaceStation {
  constructor({ name }) {
    this.name = name;
    this.team = [];
  }

  addTeamMember(newMember) {
    if (newMember instanceof Astronaut) {
      this.team.push(newMember.name);
    }
  }

  isCrewMember(person) {
    return this.team.some(
      member => member == person.name
    );
  }
}

export class Satelite {
  constructor({
    name,
  }) {
    this.name = name;
    this.messages = [];
  }

  send({ from, to, text }) {
    this.messages.push({
      from: from.name,
      to: to.name,
      text,
    });
  }
}

Ah pues era más fácil de lo que pensaba xd

Agregue validaciones al metodo send del satelite

export class Satelite {
  constructor({
    name,
  }) {
    this.name = name;
    this.messages = [];
  }
  
  send({ from, to, text }) {
    if (!from instanceof Astronaut) return
    if (!to instanceof SpaceStation) return
    if (!to.team.includes(from.name)) return
    this.messages.push({
      from: from.name,
      to: to.name,
      text,
    });
  }
}

izzi

Mi solución al reto:

class Satelite{
    constructor({
        name
    }){
        this.name = name;
        this.messages = []
    }

    send({from, to, text}){
        if((from instanceof Astronaut) && (to instanceof SpaceStation) && (to.team.includes(from.name))){
            this.messages.push({
            from: from.name,
            to: to.name,
            text,
        })
      }
    }
};

Sistema de comunicación arreglado, ahora votemos a ver quién es el impostor, yo digo que capitán DC 😂

export function simulacion({ satelite, estacion, astronauta, texto }) {
  satelite.send({
    from: astronauta,
    to: estacion,
    text: texto,
  });

  return satelite.messages;
}

export class Astronaut {
  constructor({ name }) {
    this.name = name;
  }
}

export class SpaceStation {
  constructor({ name }) {
    this.name = name;
    this.team = [];
  }

  addTeamMember(newMember) {
    if (newMember instanceof Astronaut) {
      this.team.push(newMember.name);
    }
  }
}

export class Satelite {
  constructor({
    name,
  }) {
    this.name = name;
    this.messages = [];
  }
  send({ from, to, text }) {
    if (from instanceof Astronaut && to instanceof SpaceStation && to.team.some(astronauta => from.name === astronauta)) {
      this.messages.push({
      from: from.name,
      to: to.name,
      text,
    });
    }
    
  }
}

Para solucionar los problemas identificados en el sistema de comunicación del satélite Platzi Sat01, podemos implementar las validaciones necesarias en el método send() de la clase Satelite. Aquí está la versión actualizada del código con las modificaciones:

export class Satelite {
  constructor({
    name,
  }) {
    this.name = name;
    this.messages = [];
  }

  send({ from, to, text }) {
    if (
      from instanceof Astronaut &&
      to instanceof SpaceStation &&
      to.team.includes(from.name)
    ) {
      this.messages.push({
        from: from.name,
        to: to.name,
        text,
      });
    } else {
      console.log("Error: No se pudo enviar el mensaje.");
    }
  }
}

En la nueva implementación, se verifican las siguientes condiciones antes de enviar el mensaje:
.

1. from instanceof Astronaut verifica si el remitente es una instancia de la clase Astronaut.
2. to instanceof SpaceStation verifica si el destinatario es una instancia de la clase SpaceStation.
3. to.team.includes(from.name) verifica si el nombre del remitente está en el equipo de la estación espacial destinataria.
   .
   Si alguna de estas condiciones no se cumple, se muestra un mensaje de error indicando que no se pudo enviar el mensaje.
   .
   Con estas modificaciones, el satélite Platzi Sat01 validará correctamente si el remitente es un astronauta, si el destinatario es una estación espacial y si el remitente es parte del equipo de la estación espacial.

me falta bastante para llegar a este curso! igual revisare las ayudas