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;
}
