Agapito ALFA 1!

!1!!1!!!!!!1

ColeccionPantallas.cpp

+#include "ColeccionPantallas.h"
+#include "PantallaPrincipal.h"
+#include "PantallaPrincipal2.h"
+
+
+PantallaPrincipal pant;
+PantallaPrincipal2 pant2;
+vector<shared_ptr<Pantalla>> colPantallas={make_shared<PantallaPrincipal>(pant),make_shared<PantallaPrincipal2>(pant2)};

ColeccionPantallas.h

+#pragma once
+#include <vector>
+#include <memory>
+#include "GestorPantallas.h"
+using namespace std;
+
+extern vector<shared_ptr<Pantalla>> colPantallas;
\ No newline at end of file

Objeto.h

@@ -32,4 +32,12 @@ public:
 
 
     void setEstado(State estado_){estado=estado_;}
     void setEstado(State estado_){estado=estado_;}
     State getEstado(){return estado;}
     State getEstado(){return estado;}
+    
+    void setX(int x) {
+    	this->x = x;
+    }
+    
+    void setY(int y) {
+    	this->y = y;
+    }
 };
 };

PantallaPrincipal.cpp

 #include "PantallaPrincipal.h"
 #include "PantallaPrincipal.h"
+#include "PantallaPrincipal2.h"
+#include "ColeccionPantallas.h"
+#include "Video.h"
+
 
 
 PantallaPrincipal::PantallaPrincipal() :
 PantallaPrincipal::PantallaPrincipal() :
 	fuente1("assets/OpenSans-Italic.ttf", 100),
 	fuente1("assets/OpenSans-Italic.ttf", 100),
-	Fondo1("assets/fondoHabitacion.jpg")
+	Fondo1("assets/fondoHabitacion.jpg"),
+	colisionCambioPantalla(1500,-1500,2000,1300)
 {
 {
 	Sprite sprPlanta("assets/planta.png");
 	Sprite sprPlanta("assets/planta.png");
 	Sprite sprInterfaz("assets/InterfazPrincipal.png");
 	Sprite sprInterfaz("assets/InterfazPrincipal.png");
+
 	Sprite sprOjoAbierto("assets/ojoAbierto.png");
 	Sprite sprOjoAbierto("assets/ojoAbierto.png");
 	Sprite sprOjoCerrado("assets/ojoCerrado.png");
 	Sprite sprOjoCerrado("assets/ojoCerrado.png");
 	Hitbox hitPlanta(0,-10,1200,-1000000000);
 	Hitbox hitPlanta(0,-10,1200,-1000000000);
@@ -64,6 +70,10 @@ void PantallaPrincipal::manejarEntrada(Handle &handle) {
 						Agapito.move(Frente);
 						Agapito.move(Frente);
 						break;
 						break;
 				}
 				}
+				if(Agapito.comprobarColisionPasiva(colisionCambioPantalla)){
+					PantallaPrincipal2 pant;
+					handle.reemplazamePor(colPantallas[1]);
+				}
 				for(int i=0;i<colisionesActivas.size();i++){
 				for(int i=0;i<colisionesActivas.size();i++){
 					Agapito.comprobarColision(colisionesActivas[i]);
 					Agapito.comprobarColision(colisionesActivas[i]);
 					}
 					}
@@ -89,7 +99,9 @@ void PantallaPrincipal::manejarEntrada(Handle &handle) {
 						cout<<"Raton x "<<xRaton<<" Raton z "<<zRaton<<endl;
 						cout<<"Raton x "<<xRaton<<" Raton z "<<zRaton<<endl;
 						if(colisionesInterfaz[0].colisiona(xRaton, zRaton) && objetos[indice_ojo].getEstado()==overworld){
 						if(colisionesInterfaz[0].colisiona(xRaton, zRaton) && objetos[indice_ojo].getEstado()==overworld){
 							Agapito.inventario[Agapito.numObjetos]=objetos[2];
 							Agapito.inventario[Agapito.numObjetos]=objetos[2];
+							Agapito.numObjetos++;
 							objetos.pop_back();
 							objetos.pop_back();
+							play_video("assets/videoPrueba", "es");
 						}
 						}
 					}
 					}
 				break;
 				break;
@@ -110,6 +122,8 @@ void PantallaPrincipal::renderizar(SDL_Renderer *renderer, int tamx, int tamy) {
 		objetos[i].renderizar(renderer, tamx, tamy);
 		objetos[i].renderizar(renderer, tamx, tamy);
 	}
 	}
 
 
+	Agapito.renderizar_inventario(renderer, tamx, tamy);
+
 
 
 	texto.renderizar(renderer, 50, 50, tamx, tamy);
 	texto.renderizar(renderer, 50, 50, tamx, tamy);
 }
 }

PantallaPrincipal.h

@@ -13,6 +13,7 @@ class PantallaPrincipal : public Pantalla {
 	vector<Hitbox> colisionesActivas;
 	vector<Hitbox> colisionesActivas;
 	vector<Hitbox> colisionesPasivas;
 	vector<Hitbox> colisionesPasivas;
 	vector<Hitbox> colisionesInterfaz;
 	vector<Hitbox> colisionesInterfaz;
+	Hitbox colisionCambioPantalla;
 	Fuente fuente1;
 	Fuente fuente1;
 	Sprite Fondo1;
 	Sprite Fondo1;
 	Personaje Agapito;
 	Personaje Agapito;

PantallaPrincipal2.cpp

+#include "PantallaPrincipal2.h"
+#include "PantallaPrincipal.h"
+#include "ColeccionPantallas.h"
+
+PantallaPrincipal2::PantallaPrincipal2() :
+	fuente1("assets/OpenSans-Italic.ttf", 100),
+	Fondo1("assets/fondoPuerta.jpg"),
+    colisionCambioPantalla(1500,-1500,2000,1300)
+{
+
+	Sprite sprInterfaz("assets/InterfazPrincipal.png");
+	Sprite sprOjoAbierto("assets/ojoAbierto.png");
+	Sprite sprOjoCerrado("assets/ojoCerrado.png");
+	Hitbox hitInterfaz(1920,0,900,700);
+
+
+	Hitbox hitOjo(1630,1248,997,839);
+	Objeto Ojo(sprOjoCerrado,sprOjoAbierto,sprOjoAbierto,hitOjo,1300,890,400,170,normal);
+	Objeto Interfaz(sprInterfaz,sprInterfaz,sprInterfaz,hitInterfaz,0,870,1920,216,normal);
+	
+
+
+	objetos.push_back(Interfaz);
+
+	indice_ojo = objetos.size();
+	objetos.push_back(Ojo);
+
+	
+	
+	colisionesInterfaz.push_back(hitOjo);
+
+}
+
+void PantallaPrincipal2::manejarEntrada(Handle &handle) {
+	SDL_Event event;
+	while (SDL_PollEvent(&event)) {
+		switch (event.type) {
+			case SDL_KEYDOWN:
+				switch (event.key.keysym.sym) {
+					case SDLK_LEFT:
+						Agapito.move(Izquierda);
+						break;
+					case SDLK_RIGHT:
+						Agapito.move(Derecha);
+						break;
+					case SDLK_UP:
+						Agapito.move(Fondo);
+						break;
+					case SDLK_DOWN:
+						Agapito.move(Frente);
+						break;
+				}
+                if(Agapito.comprobarColisionPasiva(colisionCambioPantalla)){
+					handle.reemplazamePor(colPantallas[0]);
+				}
+				for(int i=0;i<colisionesActivas.size();i++){
+					Agapito.comprobarColision(colisionesActivas[i]);
+					}
+				{
+					bool checkColision=false;
+					int i=0;
+					while(!checkColision && i<colisionesPasivas.size()){
+						checkColision |= Agapito.comprobarColisionPasiva(colisionesPasivas[i]);
+						i++;
+					}
+					if(checkColision){
+						objetos[indice_ojo].setEstado(overworld);
+					}else objetos[indice_ojo].setEstado(normal);
+				}
+				break;
+			case SDL_MOUSEBUTTONDOWN:
+					{
+						int xRaton=0;
+						int zRaton=0;
+						SDL_GetMouseState(&xRaton, &zRaton);
+						xRaton*=(1920.0/handle.getTamX());
+						zRaton*=(1080.0/handle.getTamY());
+						cout<<"Raton x "<<xRaton<<" Raton z "<<zRaton<<endl;
+						if(colisionesInterfaz[0].colisiona(xRaton, zRaton) && objetos[indice_ojo].getEstado()==overworld){
+							Agapito.inventario[Agapito.numObjetos]=objetos[2];
+							objetos.pop_back();
+						}
+					}
+				break;
+			case SDL_QUIT:
+				handle.removeAll();
+		}
+	}
+}
+
+void PantallaPrincipal2::renderizar(SDL_Renderer *renderer, int tamx, int tamy) {
+	Texto texto(fuente1, "AGAPITO 3D", {255, 255, 255});
+
+	Fondo1.renderizar(renderer, 0, 0,1920,1080, tamx, tamy);
+
+	Agapito.renderizar(renderer, tamx, tamy);
+
+	for(int i=0;i<objetos.size();i++){
+		objetos[i].renderizar(renderer, tamx, tamy);
+	}
+
+
+	texto.renderizar(renderer, 50, 50, tamx, tamy);
+}

PantallaPrincipal2.h

+#pragma once
+
+#include "GestorPantallas.h"
+#include <vector>
+#include "Objeto.h"
+#include "Sprite.h"
+#include "Texto.h"
+#include "Fuente.h"
+#include "Personaje.h"
+
+class PantallaPrincipal2 : public Pantalla {
+	vector<Objeto> objetos;
+	vector<Hitbox> colisionesActivas;
+	vector<Hitbox> colisionesPasivas;
+	vector<Hitbox> colisionesInterfaz;
+    Hitbox colisionCambioPantalla;
+	Fuente fuente1;
+	Sprite Fondo1;
+	Personaje Agapito;
+
+	int indice_ojo = 0;
+
+public:
+	PantallaPrincipal2();
+
+	void manejarEntrada(Handle &) override;
+
+	void renderizar(SDL_Renderer *, int tamx, int tamy) override;
+
+	bool transparente() override {
+		return false;
+	};
+};
\ No newline at end of file

Personaje.cpp

@@ -55,6 +55,16 @@ void Personaje::renderizar(SDL_Renderer *renderer, int tamx, int tamy) {
     movimientos[estado][indice_movimiento].renderizar(renderer, x, 100, profundidades, profundidades, tamx, tamy, true);
     movimientos[estado][indice_movimiento].renderizar(renderer, x, 100, profundidades, profundidades, tamx, tamy, true);
 }
 }
 
 
+
+void Personaje::renderizar_inventario(SDL_Renderer *renderer, int tamx, int tamy) {
+    for (int i = 0; i < numObjetos; i++) {
+        inventario[i]->setX(50 + i * 325);
+        inventario[i]->setY(800);
+
+        inventario[i]->renderizar(renderer, tamx, tamy);
+    }
+}
+
 void Personaje::comprobarColision(Hitbox &hitbox){
 void Personaje::comprobarColision(Hitbox &hitbox){
     if(hitbox.colisiona(x, profundidades)){
     if(hitbox.colisiona(x, profundidades)){
         switch (estado) {
         switch (estado) {

Personaje.h

+#pragma once
 #include <array>
 #include <array>
 #include <optional>
 #include <optional>
 #include <SDL2/SDL.h>
 #include <SDL2/SDL.h>
@@ -29,18 +30,20 @@ class Personaje {
     int indice_movimiento = 0;
     int indice_movimiento = 0;
     
     
 
 
+    int x = -100;
+    int profundidades = 600;
     
     
 
 
 public:
 public:
-array<optional<Objeto>, 3> inventario;
-int numObjetos=0;
-int x = -100;
-    int profundidades = 600;
+    array<optional<Objeto>, 3> inventario;
+    int numObjetos=0;
+
     Personaje();
     Personaje();
 
 
     void move(Facing direcion);
     void move(Facing direcion);
 
 
     void renderizar(SDL_Renderer *renderer, int tamx, int tamy);
     void renderizar(SDL_Renderer *renderer, int tamx, int tamy);
+    void renderizar_inventario(SDL_Renderer *renderer, int tamx, int tamy);
 
 
     void comprobarColision (Hitbox &hitbox);
     void comprobarColision (Hitbox &hitbox);
 
 

Sprite.cpp

@@ -6,6 +6,11 @@ Sprite::Sprite(std::string camino) : camino(camino) {
 
 
 }
 }
 
 
+
+Sprite::Sprite(const Sprite &other) : camino(other.camino) {
+
+}
+
 SDL_Texture *Sprite::get_textura(SDL_Renderer *Renderer) {
 SDL_Texture *Sprite::get_textura(SDL_Renderer *Renderer) {
     if (this->texture == nullptr) {
     if (this->texture == nullptr) {
         this->texture = IMG_LoadTexture(Renderer, camino.c_str());
         this->texture = IMG_LoadTexture(Renderer, camino.c_str());

Sprite.h

@@ -14,6 +14,8 @@ class Sprite {
 public:
 public:
     Sprite(std::string camino);
     Sprite(std::string camino);
 
 
+    Sprite(const Sprite &other);
+
     void renderizar(SDL_Renderer *Renderer, int x, int y, int w, int h, int tamx, int tamy,bool centrar = false);
     void renderizar(SDL_Renderer *Renderer, int x, int y, int w, int h, int tamx, int tamy,bool centrar = false);
 
 
     ~Sprite();
     ~Sprite();

Video.cpp

+#include "Video.h"
+#include <iostream>
+#include <string>
+
+void play_video(const char *nombre_video, const char *idioma_subtitulos) {
+	std::string nombre_video_str(nombre_video);
+
+	std::string nombre_archivo_video = nombre_video_str + ".mp4";
+	std::string nombre_archivo_subtitulos = ((nombre_video_str + "_") + idioma_subtitulos) + ".vtt";
+
+	std::string comando = "ffplay -vf \"subtitles=" + nombre_archivo_subtitulos + "\" -autoexit \"" + nombre_archivo_video + "\" &";
+
+	system(comando.c_str());
+};

Video.h

+#pragma once
+
+/// Nombre e idioma_subtitulos tienen que ser strings en los que se confian
+/// Ya que en otro caso se tiene ejecución de código arbitrario
+void play_video(const char *nombre, const char *idioma_subtitulos);

assets/videoPrueba_es.vtt

+WEBVTT
+
+1
+00:00:02.500 --> 00:00:04.000
+Este es un video de prueba
+
+2
+00:00:04.000 --> 00:00:06.000
+Y esta es mi planta

makefile

 CC = g++
 CC = g++
-CodeFiles = main.cpp Personaje.cpp Sprite.cpp Objeto.cpp Hitbox.cpp Texto.cpp GestorPantallas.cpp PantallaPrincipal.cpp
+CodeFiles = main.cpp Personaje.cpp Sprite.cpp Objeto.cpp Hitbox.cpp Texto.cpp GestorPantallas.cpp PantallaPrincipal.cpp PantallaPrincipal2.cpp ColeccionPantallas.cpp Video.cpp
 bin = Executable
 bin = Executable
 
 
 objdir = obj
 objdir = obj