Пример #1
0
void liberarRecursosDelPersonaje(t_list * recursos){

	while(list_size(recursos)!=0){
		char * unElemento=list_remove(recursos, 0);
		sumarRecurso(items, unElemento[0],1);
	}
}
Пример #2
0
void agregarRecursosLista(ITEM_NIVEL *ListaItems,t_queue *cola)
{
        t_log *log = log_create(logName,"Nivel",FALSE,LOG_LEVEL_INFO);
        recursoStruct *unRecurso;
        cajaStruct *unaCaja;

        bool condicionAgregar(void* caja) {
                return (((cajaStruct*) caja)->simbolo == unRecurso->recurso);
        }

        while (!queue_is_empty(cola))
        {
                unRecurso = queue_pop(cola);

                unaCaja = list_find(nivel.cajas,condicionAgregar);
                unaCaja->instancias++;
                sumarRecurso(ListaItems,unaCaja->simbolo);
                nivel_gui_dibujar(ListaItems);
        }
        log_destroy(log);
}
Пример #3
0
void mensajesConPlataforma(int32_t socketEscucha) {//ATIENDE LA RECEPCION Y POSTERIOR RESPUESTA DE MENSAJES DEL ORQUESTADOR
	enum tipo_paquete unMensaje = PER_conexionNivel_ORQ;
	char* elMensaje=NULL;

	pthread_mutex_lock(&mutex_log);
	log_info(logger,"Voy a esperar recibir un mensaje de %d", socketEscucha);
	pthread_mutex_unlock(&mutex_log);

	pthread_mutex_lock(&mutex_mensajes); //(matyx)
	recibirMensaje(socketEscucha, &unMensaje,&elMensaje);
	pthread_mutex_unlock(&mutex_mensajes);

	sleep(1);

		pthread_mutex_lock(&mutex_log);
		log_info(logger, "Llego el tipo de paquete: %s .",obtenerNombreEnum(unMensaje));
		log_info(logger, "Llego este mensaje: %s .",elMensaje);
		pthread_mutex_unlock(&mutex_log);

		switch (unMensaje) {

			case PLA_movimiento_NIV: {//graficar y actualizar la lista RECIBE "@,1,3"

				char ** mens = string_split(elMensaje,",");

				char idPers = mens[0][0];


				if(huboCambios==true){

					pthread_mutex_lock(&mutex_log);
					log_info(logger,"envio los cambios de configuracion");
					pthread_mutex_unlock(&mutex_log);

					pthread_mutex_lock(&mutex_mensajes);
					enviarMensaje(socketDeEscucha, NIV_cambiosConfiguracion_PLA,buffer1);
					pthread_mutex_unlock(&mutex_mensajes);

					huboCambios=false;

					pthread_mutex_lock(&mutex_log);
					log_info(logger,"me preparo para recibir el ok");
					pthread_mutex_unlock(&mutex_log);

					pthread_mutex_lock(&mutex_mensajes);
					recibirMensaje(socketEscucha, &unMensaje,&elMensaje);
					pthread_mutex_unlock(&mutex_mensajes);

					pthread_mutex_lock(&mutex_log);
					log_info(logger,"deberia haber recibido el OK1");
					pthread_mutex_unlock(&mutex_log);

					if(unMensaje==OK1){
						pthread_mutex_lock(&mutex_log);
						log_info(logger,"ya envie el cambio de configuracion, y me dieron el ok");
						pthread_mutex_unlock(&mutex_log);

						if(existePersonajeEnListaItems(idPers)){

							pthread_mutex_lock(&mutex_listas);
							MoverPersonaje(items, idPers,atoi(mens[1]), atoi(mens[2]));
							pthread_mutex_unlock(&mutex_listas);

							pthread_mutex_lock(&mutex_log);
							log_info(logger, "El personaje %s se movio a %s %s ",mens[0],mens[1],mens[2]);
							pthread_mutex_unlock(&mutex_log);

							if(graficar)
								nivel_gui_dibujar(items,nombre);
							}

						pthread_mutex_lock(&mutex_mensajes);
						enviarMensaje(socketEscucha,NIV_movimiento_PLA,"0"); //"0" SI ES VALIDO
						pthread_mutex_unlock(&mutex_mensajes);


						} else {
							pthread_mutex_lock(&mutex_log);
							log_info(logger,"no recibi OK1,recibi cualquiera");
							pthread_mutex_unlock(&mutex_log);
						}
					} else {

						if(existePersonajeEnListaItems(idPers)){

							pthread_mutex_lock(&mutex_listas);
							MoverPersonaje(items, elMensaje[0],atoi(mens[1]), atoi(mens[2]));
							pthread_mutex_unlock(&mutex_listas);

							pthread_mutex_lock(&mutex_log);
							log_info(logger, "El personaje %s se movio a %s %s ",mens[0],mens[1],mens[2]);
							pthread_mutex_unlock(&mutex_log);

							if(graficar)
								nivel_gui_dibujar(items,nombre);
						}

						pthread_mutex_lock(&mutex_log);
						log_info(logger, "Confirmo que el personaje %s puede moverse",mens[0]);
						pthread_mutex_unlock(&mutex_log);

						pthread_mutex_lock(&mutex_mensajes);
						enviarMensaje(socketEscucha,NIV_movimiento_PLA,"0"); //"0" SI ES VALIDO
						pthread_mutex_unlock(&mutex_mensajes);

					}

				break;
			}
			case PLA_personajeMuerto_NIV:{ //RECIBE "@" MUERTE POR ENEMIGOS
				char id=elMensaje[0];
				t_personaje_niv1 * personaje = malloc(sizeof(t_personaje_niv1));

				personaje = buscarPersonajeListaPersonajes(listaPersonajesRecursos,string_substring_until(elMensaje,1));

				pthread_mutex_lock(&mutex_listas);
//				liberarRecursosDelPersonaje(personaje->recursosActuales); // tambien suma sus recursos a disponible
				borrarPersonajeListaPersonajes(listaPersonajesRecursos,elMensaje);

				pthread_mutex_unlock(&mutex_listas);

				pthread_mutex_lock(&mutex_log);
				log_info(logger, "El personaje %c ha muerto ",id);
				pthread_mutex_unlock(&mutex_log);



				break;
			}
			case PLA_nuevoPersonaje_NIV:{ //RECIBE "@" LA POSICION DE INICIO SERA SIEMPRE 0,0 POR LO QUE NO LA RECIBE


				char * simbolo = malloc(strlen(elMensaje)+1);
				strcpy(simbolo,elMensaje);

				pthread_mutex_lock(&mutex_listas);
				CrearPersonaje(items,elMensaje[0],0,0);
				pthread_mutex_unlock(&mutex_listas);

				//ACA CREO UNA LISTA DE PERSONAJES CON SUS RESPECTIVOS RECURSOS ASIGNADOS
				t_personaje_niv1 * personaje = malloc(sizeof(t_personaje_niv1));
				personaje->simbolo = string_substring_until(elMensaje,1);
				personaje->recursosActuales = list_create();
				personaje->recursoBloqueante = string_new();
				personaje->posicion = posicion_create_pos(0,0);
				personaje->ingresoSistema = ingresoAlSistema;
				ingresoAlSistema++;

				pthread_mutex_lock(&mutex_listas);
				list_add(listaPersonajesRecursos,personaje);
				pthread_mutex_unlock(&mutex_listas);

				if(graficar)
					nivel_gui_dibujar(items,nombre);

				pthread_mutex_lock(&mutex_log);
				log_info(logger, "El nuevo personaje %c se dibujo en el mapa",elMensaje[0]);
				pthread_mutex_unlock(&mutex_log);

				break;

			}
			case PLA_posCaja_NIV:{ // RECIBE "F" SI ESTA SOLICITANDO UNA FLOR, POR EJEMPLO

				char * pos = string_new();
				ITEM_NIVEL * caja = buscarRecursoEnLista(items, elMensaje);

				string_append(&pos, string_from_format("%d",caja->posx));
				string_append(&pos, ",");
				string_append(&pos, string_from_format("%d",caja->posy));

				pthread_mutex_lock(&mutex_log);
				log_info(logger,"enviare la posicion de la caja");
				pthread_mutex_unlock(&mutex_log);

				pthread_mutex_lock(&mutex_mensajes);
				enviarMensaje(socketEscucha, NIV_posCaja_PLA,pos); //"X,Y"
				pthread_mutex_unlock(&mutex_mensajes);

				pthread_mutex_lock(&mutex_log);
				log_info(logger, "Envio posicion del recurso %s coordenadas %s ",elMensaje,pos);
				pthread_mutex_unlock(&mutex_log);

				free(pos);
				break;

			}
			case PLA_solicitudRecurso_NIV:{ // LE CONTESTO SI EL RECURSOS ESTA DISPONIBLE




				// El mensaje de ejemplo es : "@,H"

				char * rta;
				bool hayRecurso = determinarRecursoDisponible (string_substring_from(elMensaje, 2)); //SI ESTA EL RECURSO TMB LO RESTA
				t_personaje_niv1 * pers = buscarPersonajeListaPersonajes(listaPersonajesRecursos, string_substring_until(elMensaje,1));

				if (hayRecurso){
					rta = "0";

					pthread_mutex_lock(&mutex_listas);
					list_add(pers->recursosActuales, string_substring_from(elMensaje, 2));
					pers->recursoBloqueante = string_new();

					pthread_mutex_unlock(&mutex_listas);

				}else{

					pthread_mutex_lock(&mutex_listas);
					pers->recursoBloqueante = string_substring_from(elMensaje, 2);
					rta = "1";
					pthread_mutex_unlock(&mutex_listas);
				}


				pthread_mutex_lock(&mutex_mensajes);
				enviarMensaje(socketEscucha, NIV_recursoConcedido_PLA,rta);//"0" CONCEDIDO, "1" NO CONCEDIDO
				pthread_mutex_unlock(&mutex_mensajes);

				break;
			}

			case PLA_personajesDesbloqueados_NIV:{//"5,@,#,....." recorro lista personaje recursos y actualizo recBloqueante a vacio
				char ** mens = string_split(elMensaje,",");
				int i;

				int cantPersonajes=atoi(mens[0]);
				for(i=1;i<=cantPersonajes;i++){
					char * unPersDesbloqueado=mens[i];

					t_personaje_niv1 * unPers=buscarPersonajeListaPersonajes(listaPersonajesRecursos,unPersDesbloqueado);

					pthread_mutex_lock(&mutex_listas);
					unPers->recursoBloqueante=string_new();
					pthread_mutex_unlock(&mutex_listas);

					pthread_mutex_lock(&mutex_log);
					log_info(logger, "Personajes %s desbloqueados",mens[i]);
					pthread_mutex_unlock(&mutex_log);

				}


				break;
			}

			case PLA_actualizarRecursos_NIV:{ //"3;F,1;C,3;....." actualizo la lista de recursos sumandole esas cantidades
				char ** mens = string_split(elMensaje,";");
				int cantRecursos= atoi(mens[0]);
				int i;
				pthread_mutex_lock(&mutex_log);
				log_info(logger, "Recursos desbloqueados: %s",elMensaje);
				pthread_mutex_unlock(&mutex_log);

				for(i=1;i<=cantRecursos;i++){
					char** mensajeIndividual= string_split(mens[i],",");
					pthread_mutex_lock(&mutex_listas);
					int cantidad=atoi(mensajeIndividual[1]);
					sumarRecurso(items, mensajeIndividual[0][0],cantidad);
					pthread_mutex_unlock(&mutex_listas);

					if(graficar)
						nivel_gui_dibujar(items,nombre);
				}


				break;
			}
			case PLA_nivelFinalizado_NIV:{  //recibe personaje que termino el nivel ej: "@"
				char id=elMensaje[0];
				t_personaje_niv1 * personaje = malloc(sizeof(t_personaje_niv1));

				personaje = buscarPersonajeListaPersonajes(listaPersonajesRecursos,string_substring_until(elMensaje,1));

				pthread_mutex_lock(&mutex_listas);
	//			liberarRecursosDelPersonaje(personaje->recursosActuales);
				BorrarItem(items,id);
				borrarPersonajeListaPersonajes(listaPersonajesRecursos,elMensaje);
				pthread_mutex_unlock(&mutex_listas);

				pthread_mutex_lock(&mutex_log);
				log_info(logger, "El personaje %c ha terminado el nivel ",id);
				pthread_mutex_unlock(&mutex_log);

				if(graficar){

					nivel_gui_dibujar(items,nombre);

				}

				break;
			}


			case PLA_perMuereInterbloqueo_NIV:{
				char id=elMensaje[0];
				t_personaje_niv1 * personaje = malloc(sizeof(t_personaje_niv1));

				personaje = buscarPersonajeListaPersonajes(listaPersonajesRecursos,string_substring_until(elMensaje,1));

				pthread_mutex_lock(&mutex_listas);
//				liberarRecursosDelPersonaje(personaje->recursosActuales);
				BorrarItem(items,id);
				borrarPersonajeListaPersonajes(listaPersonajesRecursos,elMensaje);
				pthread_mutex_unlock(&mutex_listas);

				pthread_mutex_lock(&mutex_log);
				log_info(logger, "El personaje %c ha muerto por interbloqueo ",id);
				pthread_mutex_unlock(&mutex_log);

				if(graficar)
					nivel_gui_dibujar(items,nombre);

				break;
			}

			case PLA_perMuereNaturalmente_NIV: {
				char id = elMensaje[0];
				t_personaje_niv1 * personaje = malloc(sizeof(t_personaje_niv1));

				personaje = buscarPersonajeListaPersonajes(listaPersonajesRecursos,string_substring_until(elMensaje, 1));

				pthread_mutex_lock(&mutex_listas);
				liberarRecursosDelPersonaje(personaje->recursosActuales);
				BorrarItem(items, id);
				borrarPersonajeListaPersonajes(listaPersonajesRecursos, elMensaje);
				pthread_mutex_unlock(&mutex_listas);

				pthread_mutex_lock(&mutex_log);
				log_info(logger, "El personaje %c ha muerto por causas externas", id);
				pthread_mutex_unlock(&mutex_log);

				if (graficar)
					nivel_gui_dibujar(items, nombre);

				break;
			}

			{
				default:
					pthread_mutex_lock(&mutex_log);
					log_info(logger, "Recibi mensaje inexistente, la ejecucion del nivel finalizara");
					pthread_mutex_unlock(&mutex_log);

					eliminarEstructuras();

					break;
			}


			free(elMensaje);

		}


}