void PanelMundo::botonCrearClickeado() {
	if (creador->nombreVacio()) {
		informable->nombreSeleccionadoVacio();
		return;
	}
	if (creador->nombreExistente()) {
		informable->nombreSeleccionadoYaExistente();
		return;
	}

	// Creo el nodo del nombre
	XMLNode* nodoNombre = new XMLNode("Nombre");
	XMLText* textNombre = new XMLText(creador->getNombreElegido());
	nodoNombre->LinkEndChild(textNombre);

	// Creo el nodo de la cantidad de jugadores
	XMLNode* nodoJugadores = new XMLNode("Jugadores");
	std::string sJugadores = cfd::intToString(creador->getCantidadJugadores());
	XMLText* textJugadores = new XMLText(sJugadores);
	nodoJugadores->LinkEndChild(textJugadores);

	// Creo el nodo de niveles vacío
	XMLNode* nodoNiveles = new XMLNode("Niveles");

	// Creo el nodo del mundo y linkeo los hijos
	XMLNode* nodoMundo = new XMLNode("Mundo");
	nodoMundo->LinkEndChild(nodoNombre);
	nodoMundo->LinkEndChild(nodoJugadores);
	nodoMundo->LinkEndChild(nodoNiveles);

	// Creo un Documento XML
	XMLDocument doc;
	XMLDeclaration* decl = new XMLDeclaration("1.0", "UTF-8", "");
	doc.LinkEndChild(decl);
	doc.LinkEndChild(nodoMundo);

	// Establezco la ruta donde guardar el XML y lo guardo.
	std::string ruta = RUTA_CARPETA_MUNDOS + creador->getNombreElegido() + ".xml";
	doc.SaveFile(ruta);

	// Actualizo la lista de mundos
	this->actualizarArchivoMundos(ruta);

	// Ahora procedo a editar el mundo recien creado
	informable->editarMundo(ruta);
}
XMLNode* ImagenCajaMetal::serialize(const int altoEscenario) const {
	// Serializo la posicion de la imagen
	XMLNode* punto = this->serializarCoordenadas(altoEscenario);
	// Creo el nodo para la imagen
	XMLNode* nodo = new XMLNode("CajaMetal");
	// Agrego el nodo del Punto2D
	nodo->LinkEndChild(punto);
	return nodo;
}
XMLNode* Banana::serialize() {
	// Serializo la posicion de la fruta
	const b2Vec2 vec = this->cuerpo->GetPosition();
	Punto2D p(vec.x, vec.y);
	XMLNode* punto = p.serialize();
	// Creo el nodo para la fruta
	XMLNode* nodo = new XMLNode("Banana");
	// Agrego el nodo del Punto2D
	nodo->LinkEndChild(punto);
	return nodo;
}
void PanelMundo::actualizarArchivoMundos(const std::string rutaMundo) const {
	// Abro el archivo de los mundos
	XMLDocument doc;
	bool seAbrio = doc.LoadFile(pathFileMundos);
	// Si el archivo no existe, salgo
	if (!seAbrio)
		return;

	// Obtengo el nodo raiz
	XMLNode* root = doc.RootElement();
	// Si es nulo, salgo sin realizar nada
	if (root == 0)
		return;

	// Creo el nodo asociado al mundo
	XMLNode* nodoMundo = new XMLNode("Mundo");
	// Agrego el atributo de la cantidad de jugadores
	nodoMundo->SetAttribute("cantJugadores", creador->getCantidadJugadores());

	// Creo el nodo asociado al nombre del mundo
	XMLNode* nodoNombre = new XMLNode("Nombre");
	XMLText* textNombre = new XMLText(creador->getNombreElegido());
	nodoNombre->LinkEndChild(textNombre);

	// Creo el nodo asociado a al ruta del archivo que almacena el mundo
	XMLNode* nodoRuta = new XMLNode("Ruta");
	XMLText* textRuta = new XMLText(rutaMundo);
	nodoRuta->LinkEndChild(textRuta);

	// Linkeo los nodos de nombre y ruta al del mundo
	nodoMundo->LinkEndChild(nodoNombre);
	nodoMundo->LinkEndChild(nodoRuta);

	// Linkeo el nodo del nuevo mundo al nodo de mundos
	root->LinkEndChild(nodoMundo);

	// Guardo el archivo
	doc.SaveFile();
}
void PanelEscenario::guardarCaracteristicasEscenario() const {
    // Abro el archivo asociado al nivel
    XMLDocument doc;
    doc.LoadFile(this->rutaNivel);
    // Obtengo el nodo raiz, que en teoria es el llamado Nivel.
    XMLNode* nivelNode = doc.RootElement();

    // Limpio el nodo de nivel
    this->limpiarNodoNivel(nivelNode);

    // Creo un nuevo nodo del escenario y cargo los atributos básicos.
    XMLNode* escenarioNode = new XMLNode("Escenario");
    // Convierto los valores flotantes a string.
    std::string sAncho = cfd::floatToString(anchoFlotante);
    std::string sAlto = cfd::floatToString(altoFlotante);
    // Seteo los atributos del nodo del escenario.
    escenarioNode->SetAttribute("ancho", sAncho);
    escenarioNode->SetAttribute("alto", sAlto);

    // Creo el nodo de la imagen del fondo.
    XMLNode* imageFondoNode = new XMLNode("ImagenFondo");
    XMLText* imageFondoText = new XMLText(rutaFondo);
    imageFondoNode->LinkEndChild(imageFondoText);

    // Creo el nodo de la imagen del suelo.
    XMLNode* imageSueloNode = new XMLNode("ImagenSuelo");
    // FIXME(eze) Esperar a que Tomás agrege el suelo para serializarlo en el XML.
    XMLText* imageSueloText = new XMLText(rutaSuelo);
    imageSueloNode->LinkEndChild(imageSueloText);

    // Creo el nodo con la cantidad de jugadores.
    XMLNode* jugadoresNode = new XMLNode("Jugadores");
    // Convierto el numero de jugadores a string.
    std::string sJugadores = cfd::intToString(cantidadJugadores);
    XMLText* jugadoresText = new XMLText(sJugadores);
    jugadoresNode->LinkEndChild(jugadoresText);

    // Linkeo los atributos del Escenario
    escenarioNode->LinkEndChild(imageFondoNode);
    escenarioNode->LinkEndChild(imageSueloNode);
    escenarioNode->LinkEndChild(jugadoresNode);

    // Linkeo el nodo de escenario en el nodo del nivel.
    nivelNode->LinkEndChild(escenarioNode);

    // Guardo el documento.
    doc.SaveFile();
}