void Controlador_juego::dibujar(DLibV::Pantalla& pantalla)
{
	using namespace App_Interfaces;

	//Pantalla...
	pantalla.limpiar(128, 128, 128, 255);

	//Recolectar representables...
	std::vector<const Representable_I *> vr=(*sala_actual).obtener_vector_representables();
	vr.push_back(&jugador);

	for(const auto& p : proyectiles_jugador) vr.push_back(p.get());
	for(const auto& p : proyectiles_enemigos) vr.push_back(p.get());

	//TODO: Ordenar la vista.
	
	//Generar vista.
	representador.generar_vista(pantalla, vr);

	//Hud
	std::stringstream ss;
	ss<<jugador.acc_espaciable_x()<<","<<jugador.acc_espaciable_y()<<std::endl<<" HULL: "<<jugador.acc_salud()<<" SHIELD: "<<jugador.acc_escudo();

	DLibV::Representacion_texto_auto_estatica rep_hud(pantalla.acc_renderer(), DLibV::Gestor_superficies::obtener(App::Recursos_graficos::RS_FUENTE_BASE), ss.str());
	rep_hud.establecer_posicion(16, 16);
	rep_hud.volcar(pantalla);

	//Contador de tiempo...
	rep_hud.asignar(contador_tiempo.formatear_tiempo_restante());
	rep_hud.establecer_posicion(16, 32);
	rep_hud.volcar(pantalla);

	//Automapa	
	representador.dibujar_marco_automapa(pantalla);

	const auto& v=automapa.acc_vista();
	int x=0, y=0;

	for(const auto& u : v)
	{
		representador.dibujar_pieza_automapa(pantalla, x, y, u.visitado ? u.tipo : App_Definiciones::direcciones::nada);
		if(++x==App_Juego_Automapa::Definiciones_automapa::ANCHO)
		{
			x=0; ++y;
		}
	}
}
Example #2
0
void  Controlador_principal::dibujar(DLibV::Pantalla& pantalla)
{
	if(centrar)
	{
		auto fcentrar=[this](DLibV::Representacion_TTF * txt)
		{
			int ancho=txt->acc_posicion().w;
			int x=camara.acc_pos_x()+(camara.acc_caja_foco().w /2)-(ancho/2);
			txt->establecer_posicion(x, 0, 0, 0, DLibV::Representacion::FRECT_X);
		};

		try
		{
			auto * txt_jap=static_cast<DLibV::Representacion_TTF *>(vista.obtener_por_id("txt_japones"));
			auto * txt_rom=static_cast<DLibV::Representacion_TTF *>(vista.obtener_por_id("txt_romaji"));
			auto * txt_tra=static_cast<DLibV::Representacion_TTF *>(vista.obtener_por_id("txt_traduccion"));

			txt_jap->preparar(pantalla.acc_renderer());	
			txt_rom->preparar(pantalla.acc_renderer());
			txt_tra->preparar(pantalla.acc_renderer());
	
			fcentrar(txt_jap);
			fcentrar(txt_rom);
			fcentrar(txt_tra);
		

			centrar=false;
		}
		catch(std::exception& e)
		{
			std::string err="Error al centrar interface: ";
			err+=e.what();
			throw std::runtime_error(err);
		}

	}

	vista.volcar(pantalla, camara);
}
Example #3
0
void  Controlador_menu::dibujar(DLibV::Pantalla& pantalla)
{
	if(centrar)
	{
		try
		{
			auto fcentrar=[](DLibV::Representacion_TTF * txt, int x, int w, int flags)
			{
				int fac=txt->acc_posicion().w;
				int px=x+(w /2)-(fac/2);
				txt->establecer_posicion(px, px, 0, 0, flags);
			};

			std::map<std::string, DLibV::Representacion_TTF *> map={
				{"txt_iniciar", nullptr}, {"txt_etiquetas", nullptr}, 
				{"txt_config_ejercicio", nullptr}, {"txt_config_app", nullptr}};

			for(auto& p : map) 
			{
				p.second=static_cast<DLibV::Representacion_TTF *>(vista.obtener_por_id(p.first));
				p.second->preparar(pantalla.acc_renderer());
			}

			auto caja_centrar=vista.obtener_por_id("centrar_txt");

			int 	xh=caja_centrar->acc_posicion().x, 
				wh=caja_centrar->acc_posicion().w,
				xv=caja_centrar->acc_posicion().y,
				wv=caja_centrar->acc_posicion().h;    

			fcentrar(map["txt_iniciar"], xh, wh, DLibV::Representacion::FRECT_X);
			fcentrar(map["txt_etiquetas"], xh, wh, DLibV::Representacion::FRECT_X);
			fcentrar(map["txt_config_ejercicio"], xv, wv, DLibV::Representacion::FRECT_Y);
			fcentrar(map["txt_config_app"], xv, wv, DLibV::Representacion::FRECT_Y);

			centrar=false;
		}
		catch(std::exception& e)
		{
			std::string err="Error al despertar controlador menú: ";
			err+=e.what();
			throw std::runtime_error(err);
		}
	}

	vista.volcar(pantalla, camara);
}
void Kernel_base::configurar_entorno_grafico(DLibV::Pantalla& pantalla, unsigned int w, unsigned int h)
{
	pantalla.inicializar(w, h);
	pantalla.establecer_medidas_logicas(w, h);
	pantalla.establecer_modo_ventana(DLibV::Pantalla::M_VENTANA);
}
void Kernel_base::inicializar_entorno_grafico(DLibV::Pantalla& pantalla, unsigned int w, unsigned int h)
{
	configurar_entorno_grafico(pantalla, w, h);
	pantalla.establecer_titulo(acc_titulo_inicial().c_str());
	DLibV::Utilidades_graficas_SDL::mostrar_ocultar_cursor(acc_mostrar_cursor_inicial());
}
Example #6
0
void Controlador_editor::dibujar(DLibV::Pantalla& pantalla)
{
	pantalla.limpiar(0, 0, 0, 255);

	Representador r;
	r.dibujar_rejilla(pantalla, grid, {255, 255, 255, 64}, camara.acc_x(), -camara.acc_y(), camara.acc_zoom(), camara.acc_pos_w(), camara.acc_pos_h());

	auto pt_raton=punto_desde_pos_pantalla(pos_raton.x, pos_raton.y);

	//TODO
	if(ver_flags & fvobstaculos) for(const auto& eo : obstaculos) eo.dibujar(r, pantalla, camara);
	if(ver_flags & fvdeco_fondo) for(const auto& ed : decoraciones) if(!ed.elemento.es_frente()) ed.dibujar(r, pantalla, camara);
	if(ver_flags & fvdeco_frente) for(const auto& ed : decoraciones) if(ed.elemento.es_frente()) ed.dibujar(r, pantalla, camara);
	for(const auto& o : inicios) o.dibujar(r, pantalla, camara);
	for(const auto& o : salidas) o.dibujar(r, pantalla, camara);
	for(const auto& o : piezas) o.dibujar(r, pantalla, camara);
	for(const auto& o : interruptores) o.dibujar(r, pantalla, camara);
	for(const auto& o : puertas) o.dibujar(r, pantalla, camara);
	for(const auto& o : mejoras_velocidad) o.dibujar(r, pantalla, camara);
	for(const auto& o : arboles) o.dibujar(r, pantalla, camara);
	for(const auto& o : ayudas) o.dibujar(r, pantalla, camara);

	for(const auto& oc : objetos_cursor) oc->dibujar(r, pantalla, camara, true);
	for(const auto& os : objetos_seleccionados) os->dibujar(r, pantalla, camara, true);

	for(const auto& s : poligono_construccion.acc_segmentos())
		r.dibujar_segmento(pantalla, s, {0, 255, 0, 128}, camara);
	
	//Segmento en construcción...
	if(poligono_construccion.acc_vertices().size())
	{
		const auto& v=poligono_construccion.acc_vertices().back();
		Segmento_2d<double> s{ {v.x, v.y}, {pt_raton.x, pt_raton.y}};
		r.dibujar_segmento(pantalla, s, {0, 255, 0, 128}, camara);
	}

#ifdef WINCOMPIL
	using namespace parche_mingw;
#else
	using namespace std;
#endif


	std::string texto="GRID: "+to_string((int)grid)
		+" CAM: "+to_string((int)camara.acc_x())+","+to_string((int)camara.acc_y())
		+" POS: "+to_string((int)pt_raton.x)+","+to_string((int)pt_raton.y)
		+(decoracion_frente ? " [foreground] " : " [background]");

	switch(tobjeto)
	{
	//TODO
		case tobjetocreado::obstaculo: texto+=" [geometry]"; break;
		case tobjetocreado::decoracion: texto+=" [decoration]"; break;
		case tobjetocreado::inicio: texto+=" [spawn point]"; break;
		case tobjetocreado::salida: texto+=" [exit]"; break;
		case tobjetocreado::pieza: texto+=" [pieces]"; break;
		case tobjetocreado::interruptor: texto+=" [switch]"; break;
		case tobjetocreado::puerta: texto+=" [door]"; break;
		case tobjetocreado::mejora_velocidad: texto+=" [speed]"; break;
		case tobjetocreado::arbol: texto+=" [tree]"; break;
		case tobjetocreado::ayuda: texto+=" [hint]"; break;
	}

	DLibV::Representacion_TTF txt(fuente_akashi, {255, 255, 255, 255}, texto);
	txt.ir_a(16, camara.acc_pos_h()-32);
	txt.volcar(pantalla);

	r.dibujar_poligono(pantalla, Objeto_editor::cuadrado(pt_raton.x, pt_raton.y, 3), {255, 255, 255, 128}, camara);

	//Color fondo y de línea...
	r.dibujar_poligono_sin_transformar(pantalla, Objeto_editor::cuadrado(570, 30, 10), color_relleno);
	r.dibujar_poligono_sin_transformar(pantalla, Objeto_editor::cuadrado(580, 40, 10), color_linea);

	mensajes.dibujar(pantalla);
	if(widget.get()) widget->dibujar(pantalla);
}
void Controlador_game_over::dibujar(DLibV::Pantalla& pantalla)
{
	pantalla.limpiar(0, 0, 0, 255);
	rep_game_over.volcar(pantalla);
	rep_the_end.volcar(pantalla);
}