ObstaculoEntidad::ObstaculoEntidad(Posicion posicionOrigen, RenderizadorVentana *renderizadorVentana){ this->renderizador = new RenderizadorObstaculo(renderizadorVentana, "img/tree.png"); this->renderizador->Iniciar(posicionOrigen.obtenerX(), posicionOrigen.obtenerY()); }
void SimuladorSalida::liberarLugar(int numeroPosicion) { stringstream mensajeLog; MemoriaCompartida<Posicion> memoria; Posicion posicion; //Bloqueo la posicion semaforos[numeroPosicion].p(); mensajeLog << "Estacionamiento " << this->numeroEstacionamiento << " - Salida " << this->getNumeroSalida() << " - Tome el semaforo de posicion " << numeroPosicion; Log::getInstance()->loguear(mensajeLog.str()); memoria = this->vectorMemoriaPosiciones[numeroPosicion]; posicion = (Posicion) memoria.leer(); posicion.setEstadoOcupado(false); memoria.escribir(posicion); this->vectorMemoriaPosiciones[numeroPosicion] = memoria; mensajeLog.str(""); mensajeLog << "Estacionamiento " << this->numeroEstacionamiento << " - Salida " << this->getNumeroSalida() << " - Libero el semaforo de posicion " << numeroPosicion; Log::getInstance()->loguear(mensajeLog.str()); //Desbloqueo la posicion semaforos[numeroPosicion].v(); mensajeLog.str(""); mensajeLog << "Estacionamiento " << this->numeroEstacionamiento << " - Salida " << this->getNumeroSalida() << " - Modifico la posicion " << numeroPosicion <<" poniendola como ocupada en el vector de posiciones."; Log::getInstance()->loguear(mensajeLog.str()); }
void Vista::dibujar_personaje(Personaje* personaje) { int img_personaje_x, img_personaje_y; double personaje_x = personaje->getReferenciaMapaX(); double personaje_y = personaje->getReferenciaMapaY(); this->corregir_referencia_coordenadas_mapa_pantalla(personaje_x, personaje_y); this->transformador->transformar_isometrica_pantalla(personaje_x, personaje_y, img_personaje_x, img_personaje_y); shared_ptr<DibujoPersonaje> dibujo_pers_anterior = dynamic_pointer_cast< DibujoPersonaje>( this->factory->get_dibujo(personaje->getDibujoAnterior())); shared_ptr<DibujoPersonaje> dibujo_pers = dynamic_pointer_cast< DibujoPersonaje>(this->factory->get_dibujo(personaje->dibujar())); dibujo_pers->setMovimientoActual( dibujo_pers_anterior->getMovimientoActual()); dibujo_pers->set_posicion_default(img_personaje_x, img_personaje_y); if (esta_en_seleccion(img_personaje_x, img_personaje_y) && termino_de_elegir) { modelo->seleccionar(personaje->getReferenciaMapaX(), personaje->getReferenciaMapaY()); } Posicion destino = personaje->get_camino(); double mover_x = destino.get_x_exacta(); double mover_y = destino.get_y_exacta(); if (!adentro_del_mapa(mover_x, mover_y)) { mover_x = personaje->getReferenciaMapaX(); mover_y = personaje->getReferenciaMapaY(); } if (personaje->estaCongelado()) { dibujo_pers->congelar(); } else { dibujo_pers->descongelar(); } //cambio para mover por coordenadas personaje_x = personaje->get_posicion().get_x_exacta(); personaje_y = personaje->get_posicion().get_y_exacta(); //la vista recibe destinos pequenios double destino_x = personaje->get_destino().get_x_exacta(); double destino_y = personaje->get_destino().get_y_exacta(); if (personaje->estaAtacandoCliente()) { dibujo_pers->playMusic(); destino_x=personaje->getDondeMira().get_x_exacta(); destino_y=personaje->getDondeMira().get_y_exacta(); if(personaje->esUnBote()){ double aux=destino_x; destino_x=(-1*destino_y); destino_y=aux; } printf("Donde Estoy %g, %g",personaje_x,personaje_y); printf("Donde miro %g, %g",destino_x,destino_y); } dibujo_pers->elegir_frame((destino_x - personaje_x), (destino_y - personaje_y)); dibujo_pers->render(gRenderer); }
// Calcula la distancia hamiltoniana entre una posicion y una entidad. int Matriz::distanciaEntre(Posicion pos, Entidad* ent) { int distX = 0; int distY = 0; int minX = ent->verPosicion()->getRoundX(); int minY = ent->verPosicion()->getRoundY(); int maxX = minX + ent->verTamX(); int maxY = minY + ent->verTamY(); int actX = pos.getRoundX(); int actY = pos.getRoundY(); if (actX < maxX && actX >= minX) distX = 0; else if (actX >= maxX) distX = actX - maxX + 1; else distX = minX - actX; if (actY < maxY && actY >= minY) distY = 0; else if (actY >= maxY) distY = actY - maxY + 1; else distY = minY - actY; return distX + distY; }
bool Matriz::quitarEntidad(Entidad* elemento){ if (!elemento || !elemento->verPosicion()) { // ErrorLog::getInstance()->escribirLog("Error al querer remover [" + elemento->name + "]: No se encuentra en el mapa.", LOG_ERROR); return false; } Posicion* pos = elemento->verPosicion(); if (! posicionPertenece(pos)) return false; // Obtengo el tamanio de la entidad a quitar int altura_x = elemento->verTamX(); int ancho_y = elemento->verTamY(); // Por ahora solo desreferencio a la entidad en las posiciones en que estaba ubicada for(int i = 0; i < altura_x; i++){ for(int j = 0; j < ancho_y; j++) { casillas[pos->getRoundX() + i][pos->getRoundY() + j] = nullptr; mapDeOcupaciones[pos->getRoundX() + i][pos->getRoundY() + j] = 0; // cout << "Se vació la posicion: " << pos->toStrRound() << endl; } } this->cantidad_entidades--; return true; }
int ProcesadorConsulta::procesarPosiciones(list<Posicion> & posiciones) { list<Posicion> :: iterator itPosiciones = posiciones.begin(); list<int> pos; list<Posicion> posicionesMinimas; int distancia = -1; Posicion posicionActual = *itPosiciones; ++itPosiciones; Posicion posicionSiguiente; Posicion posicionCalculada; bool procesar = true; while(itPosiciones != posiciones.end() && procesar) { posicionSiguiente = *itPosiciones; posicionCalculada = this->compararPosiciones(posicionActual,posicionSiguiente,posicionesMinimas); posicionActual = posicionCalculada; if(posicionCalculada.getPosiciones().size() == 0) procesar = false; ++itPosiciones; } //Actualizo la lista de posiciones con la minima. posiciones.clear(); list<Posicion> :: iterator itPosicionesMinimas = posicionesMinimas.begin(); while(itPosicionesMinimas != posicionesMinimas.end()) { Posicion posActual = *itPosicionesMinimas; posiciones.push_back(posActual); itPosicionesMinimas++; } itPosicionesMinimas = posicionesMinimas.begin(); //Una vez que tenemos todas las posiciones en una misma lista las comparamos while(itPosicionesMinimas != posicionesMinimas.end()) { Posicion posicionActual = *itPosicionesMinimas; this->filtrarPosiciones(pos,posicionActual); ++itPosicionesMinimas; } if(procesar) distancia = compararPosiciones(pos); return distancia; }
list<Posicion*> Matriz::caminoMinimo(Posicion posAct, Posicion posDest, terrain_type_t validTerrain){ int actX = posAct.getRoundX(); int actY = posAct.getRoundY(); int destX = posDest.getRoundX(); int destY = posDest.getRoundY(); this->actualizarMapDeOcupaciones(); return this->calculadorCamino->calcularCaminoMinimo(actX,actY,destX,destY,this->mapDeOcupaciones, this->mapDeTerreno, validTerrain); }
void ProcesadorConsulta::filtrarPosiciones(list<int> & posiciones, Posicion posicion) { list<int> pos = posicion.getPosiciones(); list<int> :: iterator itPosiciones = pos.begin(); posiciones.push_back(*itPosiciones); }
bool SimuladorEntrada::modificarPosicionCompartida(int numeroPosicion) { stringstream mensajeLog; bool pude = false; MemoriaCompartida<Posicion> memoria; Posicion posicion; //Bloqueo la posicion semaforos[numeroPosicion].p(); mensajeLog << "Estacionamiento " << this->numeroEstacionamiento << " - Entrada " << this->getNumeroEntrada() << " - Tome el semaforo de posicion " << numeroPosicion; Log::getInstance()->loguear(mensajeLog.str()); memoria = this->vectorMemoriaPosiciones[numeroPosicion]; posicion = (Posicion)memoria.leer(); //Si la posicion ya no fue ocupada if(!posicion.getEstadoOcupado()) { posicion.setEstadoOcupado(true); memoria.escribir(posicion); this->vectorMemoriaPosiciones[numeroPosicion] = memoria; pude = true; } mensajeLog.str(""); mensajeLog << "Estacionamiento " << this->numeroEstacionamiento << " - Entrada " << this->getNumeroEntrada() << " - Libero el semaforo de posicion " << numeroPosicion; Log::getInstance()->loguear(mensajeLog.str()); //Desbloqueo la posicion semaforos[numeroPosicion].v(); if(pude) { mensajeLog.str(""); mensajeLog << "Estacionamiento " << this->numeroEstacionamiento << " - Entrada " << this->getNumeroEntrada() << " - Modifico la posicion " << numeroPosicion <<" poniendola como ocupada en el vector de posiciones."; Log::getInstance()->loguear(mensajeLog.str()); } //Si devuelve true es que pudo ocupar la posicion, sino no pudo y devuelve false. return pude; }
Posicion* Matriz::adyacenteCercana(Entidad* destino, Entidad* origen) { list<Posicion> adyacentes = this->adyacentesVacias(destino); Posicion pos; if (adyacentes.empty()) return nullptr; pos = adyacentes.front(); adyacentes.pop_front(); int dist = this->distanciaEntre(pos, origen); while (!adyacentes.empty()) { Posicion aux = adyacentes.front(); adyacentes.pop_front(); int distTmp = this->distanciaEntre(aux, origen); if (distTmp < dist) { pos = aux; dist = distTmp; } } return new Posicion(pos.getX(), pos.getY()); }
bool Matriz::ubicarEntidad(Entidad* elemento, Posicion* pos){ // TODO: levantar error o warning cuando pase esto if (!elemento) { return false; // ErrorLog::getInstance()->escribirLog("Se quiso agregar un elemento vacio al mapa.", LOG_WARNING); } if (!posicionPertenece(pos)) { // ErrorLog::getInstance()->escribirLog("Error al querer asignar posicion a [" + elemento->verNombre() + "]. Posicion " + pos->toStrRound() + " inexistente.", LOG_WARNING); return false; } // Obtengo el tamanio de la entidad int altura_x = elemento->verTamX(); int ancho_y = elemento->verTamY(); // Primero chequeo que las posiciones esten libres, y que caigan dentro del mapa for(int i = 0; i < altura_x; i++) for(int j = 0; j < ancho_y; j++) { Posicion act = Posicion(pos->getX() + i, pos->getRoundY() + j); if ((!posicionPertenece(&act)) || (this->filas == act.getX()) || (this->columnas == act.getY())) { // ErrorLog::getInstance()->escribirLog("No se puede agregar entidad [" + elemento->verNombre() +"] en " + pos->toStrRound() + ". Posición no pertenece al mapa.", LOG_WARNING); return false; } if(casillas[pos->getRoundX() + i][pos->getRoundY() + j] != nullptr) { Posicion tmp = Posicion(pos->getRoundX() + i,pos->getRoundY() + j); // ErrorLog::getInstance()->escribirLog("No se puede agregar entidad [" + elemento->verNombre() +"] en " + pos->toStrRound() + ". Colisiona con otra entidad en" + tmp.toStrRound() +".", LOG_WARNING); return false; } } // Si llego acá es porque todas las posiciones están libres for(int i = 0; i < altura_x; i++) for(int j = 0; j < ancho_y; j++){ casillas[pos->getRoundX() + i][pos->getRoundY() + j] = elemento; mapDeOcupaciones[pos->getRoundX() + i][pos->getRoundY() + j]= 1; } this->cantidad_entidades++; return true; }
void GameControllerServer::generarRecursoRandom(SDL_mutex *mutex) { for (int i = 0; i <= MAX_RECURSOS; i++) { Posicion pos = this->modelo->mapa->posicionVacia(); recurso_t tipo = this->modelo->generarRecursoRandom(pos); //creacion mensaje si creo recurso if (tipo.cantidad > 0) { msg_t mensaje; mensaje.type = CREAR_RECURSO; memcpy(mensaje.paramNombre, string_to_char_array(tipo.nombre), sizeof(mensaje.paramNombre)); mensaje.paramInt1 = tipo.cantidad; mensaje.paramDouble1 = pos.getX(); mensaje.paramDouble2 = pos.getY(); this->agregarMensaje(mensaje, mutex); mensaje.type = SET_ID_RECURSO; mensaje.paramInt1 = this->modelo->mapa->entidad_celda( pos.get_x_exacta(), pos.get_y_exacta())->getId(); this->agregarMensaje(mensaje, mutex); } } }
bool diccMatriz<T>::enRango(Posicion P) const { return (1<=P.Y() && P.Y()<=filas && 1<=P.X() && P.X()<=cols); }
list<int> ProcesadorConsulta::filtrarRanqueada(Palabra palabra) { list<int> documentos; // cantidadApariciones representa la cantidad de libros donde hay coincidencias int cantidadApariciones = (palabra.getApariciones()).size(); int frecTerminoEnDoc = 0; list<Aparicion>::iterator itAparicionFiltrada; list<Posicion> posicionEnDoc; list<Posicion>::iterator itPosicionEnDoc; list<int>::iterator itPosicionDocumentos; Aparicion aparicion; Posicion posicion; float pesoGlobal, mayorPeso, pesoTerminosEnDocumento, normaDocumento, sumaParcial; CalculadorDePesoGlobal calcPesoGlobal; int cantPalabras = 0; int cantDocumentosTermino = 0; list<Aparicion> apariciones = palabra.getApariciones(); ProcesadorNorma procesadorNorma; itAparicionFiltrada = apariciones.begin(); // por cada documento hay una aparicion for (int a = 0; a<cantidadApariciones; a++){ sumaParcial = 0; pesoTerminosEnDocumento = 0; aparicion = *itAparicionFiltrada; // Calculo el peso: // para eso recorro la lista de posiciones (cada una representa a una palabra) y calculo su peso y su frecuencia cantPalabras = (aparicion.getPosiciones()).size(); posicionEnDoc = aparicion.getPosiciones(); itPosicionEnDoc = posicionEnDoc.begin(); for (int c = 0; c < cantPalabras; c++){ posicion = *itPosicionEnDoc; frecTerminoEnDoc = (posicion.getPosiciones()).size(); cantDocumentosTermino = procesadorNorma.buscarPesoTermino(posicion.getIdPalabra()); pesoGlobal = calcPesoGlobal.calcularPesoGlobalTermino(cantDocumentosTermino); sumaParcial += frecTerminoEnDoc * pesoGlobal; ++itPosicionEnDoc; } normaDocumento = procesadorNorma.consultarNorma(aparicion.getIdDocumento()); pesoTerminosEnDocumento = sumaParcial / normaDocumento; // Si la lista de documentos esta vacia, no importa el peso que tenga, sera siempre el de mayor peso hasta ahora if (documentos.empty()){ documentos.push_back(aparicion.getIdDocumento()); mayorPeso = pesoTerminosEnDocumento; } else { // Comparo pesos if (pesoTerminosEnDocumento > mayorPeso){ int cantDocumentosADevolver = documentos.size(); // Vacio la lista de documentos for (int d = 0; d<cantDocumentosADevolver; d++){ documentos.pop_back(); } // Inserto el id del documento con mayor peso documentos.push_back(aparicion.getIdDocumento()); mayorPeso = pesoTerminosEnDocumento; } else if (pesoTerminosEnDocumento == mayorPeso){ // Si el peso es el mismo, agrego el id del documento a la lista documentos.push_back(aparicion.getIdDocumento()); } } ++itAparicionFiltrada; } return documentos; }
void diccMatriz<T>::Definir(Posicion P, const T& elem) { Matriz[P.Y()-1].Definir(P.X()-1, elem); }
Posicion ProcesadorConsulta::compararPosiciones(Posicion posicionActual, Posicion posicionSiguiente, list<Posicion> & posicionesMinimas) { list<int> posiciones1 = posicionActual.getPosiciones(); list<int> posiciones2 = posicionSiguiente.getPosiciones(); list<int> :: iterator itPosiciones1 = posiciones1.begin(); list<int> :: iterator itPosiciones2; int distanciaMinima = 0; int distanciaMinimaAnterior = 0; Posicion posicionMinima; while(itPosiciones1!= posiciones1.end()) { int pos1Actual = *itPosiciones1; itPosiciones2 = posiciones2.begin(); while(itPosiciones2 != posiciones2.end()) { int pos2Actual = *itPosiciones2; if(pos1Actual < pos2Actual) { distanciaMinima = abs(pos2Actual - pos1Actual); if(distanciaMinimaAnterior == 0) distanciaMinimaAnterior = distanciaMinima; if(distanciaMinima < distanciaMinimaAnterior) { distanciaMinimaAnterior = distanciaMinima; posicionesMinimas.clear(); crearPosicionesNuevas(posicionActual.getPalabra(),pos1Actual,posicionSiguiente.getPalabra(),pos2Actual,posicionesMinimas); } else if(distanciaMinima == distanciaMinimaAnterior) crearPosicionesNuevas(posicionActual.getPalabra(),pos1Actual,posicionSiguiente.getPalabra(),pos2Actual,posicionesMinimas); } itPosiciones2++; } itPosiciones1++; } list<Posicion> :: iterator itPosicionesMinimas = posicionesMinimas.begin(); bool encontrado = false; while(itPosicionesMinimas != posicionesMinimas.end() && !encontrado) { Posicion posicionActual = *itPosicionesMinimas; if(posicionActual.getPalabra() == posicionSiguiente.getPalabra()) { posicionMinima = posicionActual; encontrado = true; } itPosicionesMinimas++; } return posicionMinima; }
void ProcesadorConsulta::crearPosicionesNuevas(string palabra1,int posicion1, string palabra2,int posicion2, list<Posicion> & posicionesMinimas) { Posicion pos1; Posicion pos2; list<Posicion> :: iterator itPosiciones = posicionesMinimas.begin(); pos1.setPalabra(palabra1); pos1.agregarPosicion(posicion1); pos2.setPalabra(palabra2); pos2.agregarPosicion(posicion2); bool encontrado = false; list<Posicion> actuales1; list<Posicion> actuales2; if(posicionesMinimas.size() > 0) { //Agrego todos los elementos en mi nueva lista while(itPosiciones != posicionesMinimas.end()) { Posicion posicionActual = *itPosiciones; list<int> pos; if(posicionActual.getPalabra() == palabra1) { pos.push_back(posicion1); posicionActual.agregarPosiciones(pos); encontrado = true; } actuales1.push_back(posicionActual); itPosiciones++; } if(!encontrado) actuales1.push_back(pos1); encontrado = false; itPosiciones = actuales1.begin(); while(itPosiciones != actuales1.end()) { Posicion posicionActual = *itPosiciones; list<int> pos; if(posicionActual.getPalabra() == palabra2) { pos.push_back(posicion2); posicionActual.agregarPosiciones(pos); encontrado = true; } actuales2.push_back(posicionActual); itPosiciones++; } if(!encontrado) actuales2.push_back(pos2); posicionesMinimas.clear(); itPosiciones = actuales2.begin(); while(itPosiciones != actuales2.end()) { Posicion actual = *itPosiciones; posicionesMinimas.push_back(actual); itPosiciones++; } } else { posicionesMinimas.push_back(pos1); posicionesMinimas.push_back(pos2); } }
terrain_type_t Matriz::verTipoTerreno(Posicion pos) { if (this->posicionPertenece(&pos)) { return mapDeTerreno[pos.getRoundX()][pos.getRoundY()]; } return TERRAIN_GRASS; }
void Matriz::settearTipoTerreno(Posicion pos, terrain_type_t tipo) { if (this->posicionPertenece(&pos)) { mapDeTerreno[pos.getRoundX()][pos.getRoundY()] = tipo; } }
int MainCliente::conectarYEjecutar(){ //----------------------CONECTAR-BEGIN------------------ #ifdef FAKE_DEBUG_CLIENTE VistaJuego::getInstance()->getJugador()->nombreDeUsuario.assign("Cliente-A"); #else VistaJuego * visJue = VistaJuego::getInstance(); VistaInicio * visIni = VistaInicio::getInstance(); this->ip = visIni->getIP(); this->port = visIni->getPuerto(); visJue->getJugador()->nombreDeUsuario.assign(visIni->getUsuario()); #endif inicializarConexion(); if(conectado == true){ Log::getInstance()->warn(" el cliente ya se encuentra conectado."); printf("ya se encuentra conectado \n"); } else{ //Intentamos establecer la conexión int conex=connect(sock,(sockaddr *)&direc, sizeof(sockaddr)); if (conex==-1) //si no se ha podido conectar porque no se ha encontrado el host o no está el puerto abierto { Log::getInstance()->error(" no se ha podido conectar."); printf("No se ha podido conectar\n"); printf("%i", conex); return -1; } else{ // Se envia un mensaje al servidor para que valide el nombre de usuario MensajeXml mensajeUsuario; mensajeUsuario.setValor((char*)VistaJuego::getInstance()->getJugador()->nombreDeUsuario.c_str(), strlen(VistaJuego::getInstance()->getJugador()->nombreDeUsuario.c_str())); mensajeUsuario.setTipo(TIPO_STRING); mensajeUsuario.calculateSizeBytes(); char bufferSalida [MAX_BUFFER]; int size = Protocolo::codificar(mensajeUsuario, bufferSalida); MensajeSeguro::enviar(sock, bufferSalida, size); char bufferEntrada[MAX_BUFFER]; // Se recibe la confirmación de la validación del nombre de usuario int len2 = MensajeSeguro::recibir(sock,bufferEntrada); if (len2 <= 0){// Es un error chequearConexion(len2); } else{ //decodificar el mensaje MensajeXml mensaXmlRespuestaUsuario; int offset = Protocolo::decodificar(bufferEntrada,&mensaXmlRespuestaUsuario); char * respuesta = mensaXmlRespuestaUsuario.getValor(); if (strcmp(respuesta,MSJ_CONEX_ACEPT) == 0){ char* idUsuario; Posicion posicion; Posicion posicionMapa; // Si el server nos envia respuesta, es que la conexion ha sido satisfactoria Log::getInstance()->info("El cliente se ha conectado correctamente."); conectado = true; MainCliente::serverDesconectado = false; MainCliente::cerrarConexion = false; // Decodifica cómo se juega MensajeXml mensaXmlModoDeJuego; offset += Protocolo::decodificar(bufferEntrada + offset,&mensaXmlModoDeJuego); char * modoDeJuego = mensaXmlModoDeJuego.getValor(); if (strcmp(modoDeJuego, MODO_EQUIPO) == 0) { // Decodifica si hay equipos libres MensajeXml mensaXmlDisponibilidadEquipos; offset += Protocolo::decodificar(bufferEntrada + offset,&mensaXmlDisponibilidadEquipos); char * disponibilidadEquipos = mensaXmlDisponibilidadEquipos.getValor(); if (strcmp(disponibilidadEquipos, HAY_DISPONIBILIDAD) == 0) { VistaInicio::getInstance()->mostrarSeleccionDeEquipos(); string equipo = VistaInicio::getInstance()->getEquipo(); // Envio qué equipo se seleccionó MensajeXml mensajeEquipo; mensajeEquipo.setValor((char*)equipo.c_str(), strlen(equipo.c_str())); mensajeEquipo.setTipo(TIPO_STRING); mensajeEquipo.calculateSizeBytes(); char bufferSalida [MAX_BUFFER]; int size = Protocolo::codificar(mensajeEquipo, bufferSalida); MensajeSeguro::enviar(sock, bufferSalida, size); } MensajeXml mensaXml; offset += Protocolo::decodificar(bufferEntrada + offset,&mensaXml); char* idUsuarioXml = mensaXml.getValor(); idUsuario= new char[strlen(idUsuarioXml) + 1]; std::copy(idUsuarioXml, idUsuarioXml + strlen(idUsuarioXml), idUsuario); // Se decodifica la posicion inicial desde donde arranca el avión offset += Protocolo::decodificar(bufferEntrada + offset, &posicion); // Se decodifica la posicion del mapa, que tiene solo una componente: Y offset += Protocolo::decodificar(bufferEntrada + offset, &posicionMapa); //se procede a decodificar el resto del mensaje //se decodifica el escenario completo offset += Protocolo::decodificar(bufferEntrada + offset,this->servidorXml); } else { // Se juega sin equipos MensajeXml mensaXml; offset += Protocolo::decodificar(bufferEntrada + offset,&mensaXml); char* idUsuarioXml = mensaXml.getValor(); idUsuario= new char[strlen(idUsuarioXml) + 1]; std::copy(idUsuarioXml, idUsuarioXml + strlen(idUsuarioXml), idUsuario); // Se decodifica la posicion inicial desde donde arranca el avión offset += Protocolo::decodificar(bufferEntrada + offset, &posicion); // Se decodifica la posicion del mapa, que tiene solo una componente: Y offset += Protocolo::decodificar(bufferEntrada + offset, &posicionMapa); //se procede a decodificar el resto del mensaje //se decodifica el escenario completo offset += Protocolo::decodificar(bufferEntrada + offset,this->servidorXml); } // Se cierra la ventana del menu de inicio VistaInicio::getInstance()->close(); // Creo un hilo para escuchar los mensajes receptor=SDL_CreateThread(fun_recibirMensajes, "recibirMensajes", &sock); //----------------------CONECTAR-END------------------ VistaJuego *visJuego = VistaJuego::getInstance(); visJuego->getJugador()->nombreDeUsuario.assign(VistaInicio::getInstance()->getUsuario()); visJuego->getJugador()->setIdCliente(atoi(idUsuario)); visJuego->getJugador()->setPosicionAvion(posicion); visJuego->readServidorXml(this->servidorXml); visJuego->agregarObservador(this); //----------------------EJECUTAR-BEGIN------------------ visJuego->inicializar(); visJuego->ejecutar(this->servidorXml, posicionMapa.getPosY()); // se termina el programa cuando el usuario hace click en x del SDL_window //----------------------EJECUTAR-END------------------ terminarElCliente(); } else if (strcmp(respuesta,MSJ_SUPERO_MAX) == 0){ // El server envia un mensaje al superar la cantidad de clientes Log::getInstance()->error(bufferEntrada); #ifndef FAKE_DEBUG_CLIENTE VistaInicio::getInstance()->mostrarMensajeInformacion(MSJ_SUPERO_MAX); #endif shutdown(sock,2); closesocket(sock); terminarElCliente(); } else if (strcmp(respuesta, MSJ_USR_YA_CONECT) == 0) { // El server ya tiene un usuario igual y está conectado Log::getInstance()->error(bufferEntrada); #ifndef FAKE_DEBUG_CLIENTE VistaInicio::getInstance()->mostrarMensajeInformacion(MSJ_USR_YA_CONECT); #endif desconectar(); terminarElCliente(); } } } } return 0; }
bool operator==(const Posicion& una, const Posicion& otra){ return una.X() == otra.X() && una.Y() == otra.Y(); }
queue<msg_t> GameControllerServer::inicializacion() { queue<msg_t> colaInicializacion; msg_t mapa; mapa.type = PARAM_MAPA; mapa.paramDouble1 = this->modelo->get_ancho_mapa(); mapa.paramDouble2 = this->modelo->get_alto_mapa(); colaInicializacion.push(mapa); msg_t conf; conf.type = CONFIGURACION; conf.paramDouble1 = this->modelo->juego->conf->get_margen_scroll(); conf.paramDouble2 = this->modelo->juego->conf->get_vel_personaje(); colaInicializacion.push(conf); vector<Entidad*> entidades = this->modelo->obtenerEntidadesDeInicializacion(); vector<Entidad*>::iterator it = entidades.begin(); for (; it != entidades.end(); it++) { msg_t entidad; Entidad* ent = (*it); memcpy(entidad.paramNombre, string_to_char_array(ent->objetoMapa->nombre), sizeof(entidad.paramNombre)); entidad.paramDouble1 = ent->posicion->getX(); entidad.paramDouble2 = ent->posicion->getY(); //problema no puede pasar los id de los recursos if (!ent->esUnRecurso()) { entidad.type = CREAR_ENTIDAD_CONSTRUIDA; entidad.paramInt1 = ent->getId(); colaInicializacion.push(entidad); } else { int cant = ((Recurso*) ent)->obtenerRecurso(); entidad.paramInt1 = cant; entidad.type = CREAR_RECURSO; colaInicializacion.push(entidad); entidad.type = SET_ID_RECURSO; entidad.paramInt1 = ent->getId(); colaInicializacion.push(entidad); } } vector<Personaje*> personajes = this->modelo->devolverTodosLosPersonajes(); vector<Personaje*>::iterator iter = personajes.begin(); for (; iter != personajes.end(); iter++) { msg_t msg_crear_personaje; Personaje* personaje = (*iter); msg_crear_personaje.type = NUEVO_PERSONAJE; Posicion pos = personaje->get_posicion(); memcpy(msg_crear_personaje.paramTipo, string_to_char_array(personaje->objetoMapa->nombre), sizeof(msg_crear_personaje.paramTipo)); memcpy(msg_crear_personaje.paramNombre, string_to_char_array(personaje->getNombreJugador()), sizeof(msg_crear_personaje.paramNombre)); msg_crear_personaje.paramDouble1 = pos.get_x_exacta(); msg_crear_personaje.paramDouble2 = pos.get_y_exacta(); msg_crear_personaje.paramInt1 = personaje->getId(); colaInicializacion.push(msg_crear_personaje); if (personaje->estaCongelado()) { msg_t mensajeDesconexion; mensajeDesconexion.type = QUIT; memcpy(mensajeDesconexion.paramNombre, string_to_char_array(personaje->getNombreJugador()), sizeof(mensajeDesconexion.paramNombre)); colaInicializacion.push(mensajeDesconexion); } } return colaInicializacion; }