Ampliacion5

plataformas/Actor.cpp

@@ -20,7 +20,7 @@ Actor::Actor(string filename, float x, float y, int width, int height, Game* gam
 	this->height = height;
 }
 
-void Actor::draw(float scrollX) {
+void Actor::draw(float scrollX, float scrollY) {
 	// Recorte en el fichero de la imagen
 	SDL_Rect source;
 	source.x = 0;
@@ -31,7 +31,7 @@ void Actor::draw(float scrollX) {
 	// Donde se va a pegar en el renderizador
 	SDL_Rect destination;
 	destination.x = x - width / 2 - scrollX;
-	destination.y = y - height / 2;
+	destination.y = y - height / 2 - scrollY;
 	destination.w = width;
 	destination.h = height;
 	// Modificar para que la referencia sea el punto central

plataformas/Actor.h

@@ -7,7 +7,7 @@ class Actor
 public:
 	Actor(string filename, float x, float y, int width, int height, Game* game);
 	~Actor();
-	virtual void draw(float scrollX = 0);
+	virtual void draw(float scrollX = 0, float scrollY = 0);
 	bool isOverlap(Actor* actor);
 	bool isInRender(float scrollX = 0);
 	bool containsPoint(int pointX, int pointY); // contiene punto

plataformas/Background.cpp

@@ -32,7 +32,7 @@ void Background::update() {
 	}
 }
 
-void Background::draw(float scrollX) {
+void Background::draw(float scrollX, float scrollY) {
 	Actor::draw(); // llamar al metodo del hijo
 
 	if (backgroundAux != NULL) {
@@ -46,6 +46,16 @@ void Background::draw(float scrollX) {
 			// pintar aux por la derecha
 			backgroundAux->x = x + width;
 		}
+		// zona sin cubrir por abajo
+		if (y - height / 2 > 0) {
+			// pintar aux por abajo
+			backgroundAux->y = y - height;
+		}
+		// zona sin cubrir por arriba
+		if (y + height / 2 < HEIGHT) {
+			// pintar aux por arriba
+			backgroundAux->y = y + height;
+		}
 		backgroundAux->draw();
 	}
 

plataformas/Background.h

@@ -7,7 +7,7 @@ class Background : public Actor
 public:
 	Background(string filename, float x, float y, Game* game);
 	Background(string filename, float x, float y, float vx, Game* game);
-	void draw(float scrollX = 0) override; // Va a sobrescribir
+	void draw(float scrollX = 0, float scrollY = 0) override; // Va a sobrescribir
 	void update();
 	Background* backgroundAux = nullptr;
 

plataformas/Debug/plataformas.exe.recipe

@@ -2,7 +2,7 @@
 <Project>
   <ProjectOutputs>
     <ProjectOutput>
-      <FullPath>C:\Users\uo276406\Desktop\plataformas\Debug\plataformas.exe</FullPath>
+      <FullPath>C:\Users\diego\OneDrive\Escritorio\SEV\plataformas\Debug\plataformas.exe</FullPath>
     </ProjectOutput>
   </ProjectOutputs>
   <ContentFiles />

plataformas/Debug/plataformas.tlog/plataformas.lastbuildstate

@@ -1,2 +1,2 @@
-PlatformToolSet=v142:VCToolArchitecture=Native32Bit:VCToolsVersion=14.29.30037:TargetPlatformVersion=10.0.19041.0:
-Debug|Win32|C:\Users\uo276406\Desktop\plataformas\|
+PlatformToolSet=v142:VCToolArchitecture=Native32Bit:VCToolsVersion=14.29.30133:TargetPlatformVersion=10.0.18362.0:
+Debug|Win32|C:\Users\diego\OneDrive\Escritorio\SEV\plataformas\|

plataformas/Enemy.cpp

@@ -1,5 +1,7 @@
+#include "Actor.h"
 #include "Enemy.h"
 
+
 Enemy::Enemy(float x, float y, Game* game)
 	: Actor("res/enemigo.png", x, y, 36, 40, game) {
 
@@ -61,8 +63,8 @@ void Enemy::impacted() {
 }
 
 
-void Enemy::draw(float scrollX) {
-	animation->draw(x - scrollX, y);
+void Enemy::draw(float scrollX, float scrollY) {
+	animation->draw(x - scrollX, y-scrollY);
 }
 
 

plataformas/Enemy.h

@@ -7,7 +7,8 @@ class Enemy : public Actor
 {
 public:
 	Enemy(float x, float y, Game* game);
-	void draw(float scrollX = 0) override; // Va a sobrescribir
+
+	void draw(float scrollX = 0, float scrollY = 0) override; // Va a sobrescribir
 	void update();
 	void impacted(); // Recibe impacto y pone animaci�n de morir
 	float vxIntelligence;

plataformas/GameLayer.cpp

@@ -15,6 +15,7 @@ void GameLayer::init() {
 
 	space = new Space(1);
 	scrollX = 0;
+	scrollY = 0;
 	tiles.clear();
 
 	audioBackground = new Audio("res/musica_ambiente.mp3", true);
@@ -24,13 +25,20 @@ void GameLayer::init() {
 	textPoints = new Text("hola", WIDTH * 0.92, HEIGHT * 0.04, game);
 	textPoints->content = to_string(points);
 
-
+	pointsRecolectable = 0;
+	textPointsRecolectable = new Text("hola", WIDTH * 0.92, HEIGHT * 0.14, game);
+	textPointsRecolectable->content = to_string(pointsRecolectable);
+
 	background = new Background("res/fondo_2.png", WIDTH * 0.5, HEIGHT * 0.5, -1, game);
 	backgroundPoints = new Actor("res/icono_puntos.png",
 		WIDTH * 0.85, HEIGHT * 0.05, 24, 24, game);
 
+	recolectable = new Item(WIDTH * 0.85, HEIGHT * 0.15, game);
+
 	enemies.clear(); // Vaciar por si reiniciamos el juego
+	recolectables.clear();
 	projectiles.clear(); // Vaciar por si reiniciamos el juego
+	destructibles.clear();
 
 	loadMap("res/" + to_string(game->currentLevel) + ".txt");
 }
@@ -73,6 +81,22 @@ void GameLayer::loadMapObject(char character, float x, float y)
 		space->addDynamicActor(cup); // Realmente no hace falta
 		break;
 	}
+	case 'R': {
+		Tile* recolectable = new Tile("res/icono_recolectable.png", x, y, game);
+		// modificaci�n para empezar a contar desde el suelo.
+		recolectable->y = recolectable->y - recolectable->height / 2;
+		recolectables.push_back(recolectable);
+		space->addDynamicActor(recolectable); 
+		break;
+	}
+	case 'W': {
+		Tile* destructible = new Tile("res/bloque_metal.png", x, y, game);
+		// modificaci�n para empezar a contar desde el suelo.
+		destructible->y = destructible->y - destructible->height / 2;
+		destructibles.push_back(destructible);
+		space->addStaticActor(destructible); 
+		break;
+	}
 	case 'E': {
 		Enemy* enemy = new Enemy(x, y, game);
 		// modificaci�n para empezar a contar desde el suelo.
@@ -245,18 +269,18 @@ void GameLayer::update() {
 	}
 
 
-	// Colisiones
 	for (auto const& enemy : enemies) {
+
 		if (player->isOverlap(enemy)) {
-			player->loseLife();
+				player->loseLife();
+
 			if (player->lifes <= 0) {
 				init();
 				return;
 			}
 		}
 	}
 
-	// Colisiones , Enemy - Projectile
 
 	list<Enemy*> deleteEnemies;
 	list<Projectile*> deleteProjectiles;
@@ -273,7 +297,33 @@ void GameLayer::update() {
 		}
 	}
 
+	//Colisiones, Player - Recolectable
+	list<Tile*> deleteRecolectables;
+	for (auto const& recolectable : recolectables) {
+		if (player->isOverlap(recolectable)) {
+			bool rInList = std::find(deleteRecolectables.begin(),
+				deleteRecolectables.end(),
+				recolectable) != deleteRecolectables.end();
+
+			if (!rInList) {
+				deleteRecolectables.push_back(recolectable);
+			}
+
+
+			pointsRecolectable++;
+			if (pointsRecolectable % 4 == 0) {
+				textPointsRecolectable->content = to_string(pointsRecolectable/4);
+				this->recolectable->idle->currentFrame = 2;
+			}
+
+			this->recolectable->update();
+
+		}
+
+	}
 
+	// Colisiones , Enemy - Projectile
+	//				Player(saltando) - enemy
 
 	for (auto const& enemy : enemies) {
 		for (auto const& projectile : projectiles) {
@@ -294,8 +344,43 @@ void GameLayer::update() {
 
 			}
 		}
+		if (player->vy > 0 && player->y < enemy->y
+			&& player->isOverlap(enemy)
+			&& player->lifes > 0) {
+
+			enemy->impacted();
+			player->lifes++;
+			player->invulnerableTime = 0;
+			points++;
+			textPoints->content = to_string(points);
+		}
+	}
+
+	//Tiles destructibles
+	list<Tile*> deleteDestructibles;
+	for (auto const& destructible : destructibles) {
+
+		if ((player->y - destructible->y) < 10 && 
+			abs(player->x - destructible->x) < 10 &&
+			destructionTime % 10 == 0) {
+
+			space->addDynamicActor(destructible);
+			space->removeStaticActor(destructible);
+
+			bool dInList = std::find(deleteDestructibles.begin(),
+				deleteDestructibles.end(),
+				destructible) != deleteDestructibles.end();
+
+			if (!dInList) {
+				deleteDestructibles.push_back(destructible);
+			}
+
+			destructionTime = 10;
+		}
 	}
 
+	destructionTime--;
+
 	for (auto const& enemy : enemies) {
 		if (enemy->state == game->stateDead) {
 			bool eInList = std::find(deleteEnemies.begin(),
@@ -308,6 +393,18 @@ void GameLayer::update() {
 		}
 	}
 
+	for (auto const& delRecolectable : deleteRecolectables) {
+		recolectables.remove(delRecolectable);
+		space->removeDynamicActor(delRecolectable);
+	}
+	deleteRecolectables.clear();
+
+	for (auto const& delDestructible : deleteDestructibles) {
+		destructibles.remove(delDestructible);
+		space->removeDynamicActor(delDestructible);
+	}
+	deleteDestructibles.clear();
+
 	for (auto const& delEnemy : deleteEnemies) {
 		enemies.remove(delEnemy);
 		space->removeDynamicActor(delEnemy);
@@ -339,6 +436,20 @@ void GameLayer::calculateScroll() {
 			scrollX = player->x - WIDTH * 0.7;
 		}
 	}
+
+	// limite abajo
+	if (player->y > HEIGHT * 0.3) {
+		if (player->y - scrollY < HEIGHT * 0.3) {
+			scrollY = player->y - HEIGHT * 0.3;
+		}
+	}
+
+	// limite arriba
+	if (player->y < mapWidth - HEIGHT * 0.3) {
+		if (player->y - scrollY > HEIGHT * 0.7) {
+			scrollY = player->y - HEIGHT * 0.7;
+		}
+	}
 }
 
 
@@ -347,23 +458,34 @@ void GameLayer::draw() {
 
 	background->draw();
 	for (auto const& tile : tiles) {
-		tile->draw(scrollX);
+		tile->draw(scrollX, scrollY);
+	}
+
+	for (auto const& recolectable : recolectables) {
+		recolectable->draw(scrollX, scrollY);
+	}
+
+	for (auto const& destructible : destructibles) {
+		destructible->draw(scrollX, scrollY);
 	}
 
 	for (auto const& projectile : projectiles) {
-		projectile->draw(scrollX);
+		projectile->draw(scrollX, scrollY);
 	}
 
-	cup->draw(scrollX);
-	player->draw(scrollX);
+	cup->draw(scrollX, scrollY);
+	player->draw(scrollX, scrollY);
 
 	for (auto const& enemy : enemies) {
-		enemy->draw(scrollX);
+		enemy->draw(scrollX, scrollY);
 	}
 
 	backgroundPoints->draw();
 	textPoints->draw();
 
+	textPointsRecolectable->draw();
+	recolectable->draw();
+
 	// HUD
 	if (game->input == game->inputMouse) {
 		buttonJump->draw(); // NO TIENEN SCROLL, POSICION FIJA

plataformas/GameLayer.h

@@ -11,6 +11,7 @@
 
 #include "Audio.h"
 #include "Space.h" // importar
+#include "Item.h"
 
 #include "Pad.h"
 
@@ -35,17 +36,27 @@ class GameLayer : public Layer
 	void calculateScroll();
 	Space* space;
 	float scrollX;
+	float scrollY;
 	int mapWidth;
 	list<Tile*> tiles;
+
+	list<Tile*> destructibles;
+	int destructionTime = 9;
 
 	Audio* audioBackground;
 	Text* textPoints;
 	int points;
+
+	Text* textPointsRecolectable;
+	int pointsRecolectable;
+	Item* recolectable;
+
 	int newEnemyTime = 0;
 	Player* player;
 	Background* background;
 	Actor* backgroundPoints;
 	list<Enemy*> enemies;
+	list<Tile*> recolectables;
 	list<Projectile*> projectiles;
 	Tile* cup; // Elemento de final de nivel
 
@@ -56,7 +67,7 @@ class GameLayer : public Layer
 	// Elementos de interfaz
 	Actor* buttonJump;
 	Actor* buttonShoot;
-	Pad* pad;
+	Pad* pad; 
 
 };
 

plataformas/GenericEnemy.cpp

@@ -0,0 +1 @@
+#include "GenericEnemy.h"

plataformas/GenericEnemy.h

@@ -0,0 +1,13 @@
+#pragma once
+#include "Actor.h"
+class GenericEnemy :
+    public Actor
+{
+
+    void virtual draw() = 0; // Va a sobrescribir
+    void virtual update() = 0;
+
+    GenericEnemy(string filename, float x, float y, int width, int height, Game* game);
+
+};
+