diff --git a/Space-Invaders/Header/AnimationSystem/AnimationService.h b/Space-Invaders/Header/AnimationSystem/AnimationService.h new file mode 100644 index 000000000..491cbcccc --- /dev/null +++ b/Space-Invaders/Header/AnimationSystem/AnimationService.h @@ -0,0 +1,36 @@ +#pragma once +#include +#include +#include "../../header/AnimationSystem/AnimationSystem.h" + +namespace Animation +{ + enum class AnimationType + { + EXPLOSION, + }; + + class AnimationService + { + private: + std::vector animation_system_list; + std::vector flagged_animation_system_list; + + AnimationSystemConfig getAnimationSystemConfig(AnimationType animation_type); + void destroyFlaggedAnimationSystem(); + void destroy(); + + public: + AnimationService(); + virtual ~AnimationService(); + + void initialize(); + void update(); + void render(); + + void reset(); + + void spawnAnimationSystem(sf::Vector2f position, AnimationType animation_type); + void destroyAnimationSystem(AnimationSystem* animation_system); + }; +} diff --git a/Space-Invaders/Header/AnimationSystem/AnimationSystem.h b/Space-Invaders/Header/AnimationSystem/AnimationSystem.h new file mode 100644 index 000000000..24cbfd74b --- /dev/null +++ b/Space-Invaders/Header/AnimationSystem/AnimationSystem.h @@ -0,0 +1,33 @@ +#pragma once +#include +#include "../../header/AnimationSystem/AnimationSystemConfig.h" +#include "../../header/UI/UIElement/ImageView.h" + +namespace Animation +{ + class AnimationSystem + { + private: + AnimationSystemConfig animation_system_config; + + sf::Vector2f animation_position; + UI::UIElement::ImageView* animation_image; + + void createUIElements(); + void initializeImage(); + + int current_frame; + sf::Clock clock; + sf::Time frame_time; + + public: + AnimationSystem(AnimationSystemConfig config); + ~AnimationSystem(); + + void initialize(sf::Vector2f position); + void update(); + void render(); + + void destroy(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/AnimationSystem/AnimationSystemConfig.h b/Space-Invaders/Header/AnimationSystem/AnimationSystemConfig.h new file mode 100644 index 000000000..0c1a8cb3e --- /dev/null +++ b/Space-Invaders/Header/AnimationSystem/AnimationSystemConfig.h @@ -0,0 +1,30 @@ +#pragma once + +namespace Animation +{ + struct AnimationSystemConfig + { + sf::String Animation_texture_path; + + float sprite_sheet_width; + float sprite_sheet_height; + + float tile_width; //one frame of the sprite sheet + float tile_height; + + int number_of_animation_frames; //total frames + float frame_duration; //duration of a single frame + + AnimationSystemConfig() = default; // Use default for default constructor + + //this will allow us to initialize an animation with it's configuration. + AnimationSystemConfig(sf::String texture_path, float sprite_width, float sprite_height, float t_width, float t_height, int frames, float duration) : + Animation_texture_path(texture_path), + sprite_sheet_width(sprite_width), + sprite_sheet_height(sprite_height), + tile_width(t_width), + tile_height(t_height), + number_of_animation_frames(frames), + frame_duration(duration) {} + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/AnimationSystem/AnimationSystemConfigData.h b/Space-Invaders/Header/AnimationSystem/AnimationSystemConfigData.h new file mode 100644 index 000000000..c2b9b6b86 --- /dev/null +++ b/Space-Invaders/Header/AnimationSystem/AnimationSystemConfigData.h @@ -0,0 +1,8 @@ +#pragma once +#include "AnimationSystemConfig.h" +#include "../../header/Global/Config.h" + +namespace Animation +{ + const AnimationSystemConfig explosion_animation_config(Global::Config::explosion_texture_path, 70.0f, 80.0f, 14.28f, 20.0f, 7, 0.03f); +} diff --git a/Space-Invaders/Header/Bullet/BulletConfig.h b/Space-Invaders/Header/Bullet/BulletConfig.h new file mode 100644 index 000000000..0227049bc --- /dev/null +++ b/Space-Invaders/Header/Bullet/BulletConfig.h @@ -0,0 +1,28 @@ +#pragma once +#include + +namespace Bullet +{ + enum class BulletType + { + LASER_BULLET, + TORPEDO, + FROST_BULLET, + }; + + enum class MovementDirection + { + UP, + DOWN, + }; + + class BulletConfig + { + public: + static const sf::String laser_bullet_texture_path; + static const sf::String torpedoe_texture_path; + static const sf::String frost_beam_texture_path; + + static sf::String getBulletTexturePath(BulletType bullet_type); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Bullet/BulletController.h b/Space-Invaders/Header/Bullet/BulletController.h new file mode 100644 index 000000000..d6136e4cd --- /dev/null +++ b/Space-Invaders/Header/Bullet/BulletController.h @@ -0,0 +1,47 @@ +#pragma once +#include"../../Header/Projectile/IProjectile.h" +#include"../../Header/Bullet/BulletConfig.h" +#include"../../Header/Entity/EntityConfig.h" +#include"../../Header/Collision/ICollider.h" + +namespace Bullet +{ + class BulletView; + class BulletModel; + + enum class BulletType; + + class BulletController :public Projectile::IProjectile,public Collision::ICollider + { + protected: + BulletView* bullet_view; + BulletModel* bullet_model; + + void updateProjectilePosition() override; + + void processBulletCollision(ICollider* other_collider); + void processEnemyCollision(ICollider* other_collider); + void processPlayerCollision(ICollider* other_collider); + void processBunkerCollision(ICollider* other_collider); + + void moveUP(); + void moveDown(); + void handleOutOfBounds(); + + public: + BulletController(BulletType bullet_type,Entity::EntityType owner_type); + virtual ~BulletController() override; + + void initialize(sf::Vector2f position, Bullet::MovementDirection direction)override; + void update() override; + void render() override; + + sf::Vector2f getProjectilePosition() override; + BulletType getBulletType(); + + Entity::EntityType getOwnerEntityType(); + + const sf::Sprite& getColliderSprite() override; + void onCollision(ICollider* other_collider) override; + }; +} diff --git a/Space-Invaders/Header/Bullet/BulletModel.h b/Space-Invaders/Header/Bullet/BulletModel.h new file mode 100644 index 000000000..d884a1763 --- /dev/null +++ b/Space-Invaders/Header/Bullet/BulletModel.h @@ -0,0 +1,38 @@ +#pragma once +#include +#include"../../Header/Entity/EntityConfig.h" + +namespace Bullet +{ + enum class BulletType; + enum class MovementDirection; + + class BulletModel + { + private: + float movement_speed = 300.f; + sf::Vector2f bullet_position; + + BulletType bullet_type; + Entity::EntityType owner_type; + MovementDirection movement_direction; + + public: + BulletModel(BulletType bullet_type, Entity::EntityType owner_type); + ~BulletModel(); + + void initialize(sf::Vector2f position, MovementDirection direction); + + sf::Vector2f getBulletPosition(); + void setBulletPosition(sf::Vector2f position); + + BulletType getBulletType(); + Entity::EntityType getOwnerEntityType(); + + MovementDirection getMovementDirection(); + void setMovementDirection(MovementDirection direction); + + float getMovementSpeed(); + void setMovementSpeed(float speed); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Bullet/BulletService.h b/Space-Invaders/Header/Bullet/BulletService.h new file mode 100644 index 000000000..84e893c67 --- /dev/null +++ b/Space-Invaders/Header/Bullet/BulletService.h @@ -0,0 +1,42 @@ +#pragma once +#include +#include"SFML/System/Vector2.hpp" +#include"../../Header/Projectile/IProjectile.h" +#include"../../Header/Entity/EntityConfig.h" + +namespace Bullet +{ + + enum class BulletType; + enum class MovementDirection; + class BulletController; + + class BulletService + { + private: + + std::vectorprojectile_list; + std::vectorflagged_bullet_list; + + BulletController* createBullet(BulletType bullet_type,Entity::EntityType owner_type); + + bool isValidBullet(int index_i, std::vector& bullet_list); + void destroyFlaggedBullets(); + + void destroy(); + + public: + BulletService(); + virtual ~BulletService(); + + void initialize(); + void update(); + void render(); + + void reset(); + + BulletController* spawnBullet(BulletType bullet_type,Entity::EntityType owner_type, sf::Vector2f position, MovementDirection direction); + void destroyBullet(BulletController* bullet_controller); + }; + +} \ No newline at end of file diff --git a/Space-Invaders/Header/Bullet/BulletView.h b/Space-Invaders/Header/Bullet/BulletView.h new file mode 100644 index 000000000..6ed2fb273 --- /dev/null +++ b/Space-Invaders/Header/Bullet/BulletView.h @@ -0,0 +1,34 @@ +#pragma once +#include +#include "../../Header/UI/UIElement/ImageView.h" + +namespace Bullet +{ + class BulletController; + + class BulletView + { + private: + const float bullet_sprite_width = 18.f; + const float bullet_sprite_height = 18.f; + + BulletController* bullet_controller; + UI::UIElement::ImageView* bullet_image; + + void initializeImage(); + void createUIElements(); + sf::String getBulletTexturePath(); + + void destroy(); + + public: + BulletView(); + ~BulletView(); + + void initialize(BulletController* controller); + void update(); + void render(); + + const sf::Sprite& getBulletSprite(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Bullet/Controllers/FrostBulletController.h b/Space-Invaders/Header/Bullet/Controllers/FrostBulletController.h new file mode 100644 index 000000000..b8703cc7b --- /dev/null +++ b/Space-Invaders/Header/Bullet/Controllers/FrostBulletController.h @@ -0,0 +1,20 @@ +#pragma once +#include"../../Header/Bullet/BulletController.h" + +namespace Bullet +{ + namespace Controller + { + class FrostBulletController :public BulletController + { + private: + const float frost_bullet_movement_speed = 500.f; + + public: + FrostBulletController(BulletType bullet_type, Entity::EntityType owner_type); + ~FrostBulletController(); + + void initialize(sf::Vector2f position, MovementDirection direction)override; + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Bullet/Controllers/LaserBulletController.h b/Space-Invaders/Header/Bullet/Controllers/LaserBulletController.h new file mode 100644 index 000000000..17806b137 --- /dev/null +++ b/Space-Invaders/Header/Bullet/Controllers/LaserBulletController.h @@ -0,0 +1,17 @@ +#pragma once +#include"../../Header/Bullet/BulletController.h" + +namespace Bullet +{ + namespace Controller + { + class LaserBulletController :public BulletController + { + public: + LaserBulletController(BulletType bullet_type, Entity::EntityType owner_type); + ~LaserBulletController(); + + void initialize(sf::Vector2f position, MovementDirection)override; + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Bullet/Controllers/TorpedoeController.h b/Space-Invaders/Header/Bullet/Controllers/TorpedoeController.h new file mode 100644 index 000000000..2155ed727 --- /dev/null +++ b/Space-Invaders/Header/Bullet/Controllers/TorpedoeController.h @@ -0,0 +1,20 @@ +#pragma once +#include"../../Header/Bullet/BulletController.h" + +namespace Bullet +{ + namespace Controller + { + class TorpedoController :public BulletController + { + private: + const float torpedo_movement_speed = 200.f; + + public: + TorpedoController(BulletType bullet_type,Entity::EntityType owner_type); + ~TorpedoController(); + + void initialize(sf::Vector2f position, MovementDirection direction)override; + }; + } +} diff --git a/Space-Invaders/Header/Collectible/ICollectible.h b/Space-Invaders/Header/Collectible/ICollectible.h new file mode 100644 index 000000000..eac7d98f9 --- /dev/null +++ b/Space-Invaders/Header/Collectible/ICollectible.h @@ -0,0 +1,19 @@ +#pragma once +#include + +namespace Collectible +{ + class ICollectible + { + public: + virtual void onCollected() = 0; + virtual void initialize(sf::Vector2f position) = 0; + virtual void update() = 0; + virtual void render() = 0; + virtual sf::Vector2f getCollectiblePosition() = 0; + + virtual ~ICollectible() {}; + }; + + +} diff --git a/Space-Invaders/Header/Collision/CollisionService.h b/Space-Invaders/Header/Collision/CollisionService.h new file mode 100644 index 000000000..9db69fa76 --- /dev/null +++ b/Space-Invaders/Header/Collision/CollisionService.h @@ -0,0 +1,28 @@ +#pragma once +#include + +namespace Collision +{ + class ICollider; + + class CollisionService + { + private: + std::vector collider_list; + + void processCollision(); + void doCollision(int index_i, int index_j); + bool hasCollisionOccured(int index_i, int index_j); + bool areActiveColliders(int index_i, int index_j); + + public: + CollisionService(); + ~CollisionService(); + + void initialize(); + void update(); + + void addCollider(ICollider* collider); + void removeCollider(ICollider* collider); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Collision/ICollider.h b/Space-Invaders/Header/Collision/ICollider.h new file mode 100644 index 000000000..e8cbf980c --- /dev/null +++ b/Space-Invaders/Header/Collision/ICollider.h @@ -0,0 +1,28 @@ +#pragma once +#include + +namespace Collision +{ + enum class CollisionState + { + ENABLED, + DISABLED, + }; + + class ICollider + { + private: + CollisionState collision_state; + + public: + ICollider(); + virtual ~ICollider(); + + virtual const sf::Sprite& getColliderSprite() = 0; + virtual void onCollision(ICollider* other_collider) = 0; + + void enableCollision(); + void disableCollision(); + CollisionState getCollisionState(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Elements/Bunker/BunkerController.h b/Space-Invaders/Header/Elements/Bunker/BunkerController.h new file mode 100644 index 000000000..9ad5eaf5d --- /dev/null +++ b/Space-Invaders/Header/Elements/Bunker/BunkerController.h @@ -0,0 +1,33 @@ +#pragma once +#include +#include"../../Header/Elements/Bunker/BunkerModel.h" +#include"../../Header/Collision/ICollider.h" + +namespace Element +{ + namespace Bunker + { + class BunkerView; + + class BunkerController : public Collision::ICollider + { + private: + BunkerView* bunker_view; + BunkerData bunker_data; + + public: + BunkerController(); + ~BunkerController(); + + void initialize(BunkerData data); + void update(); + void render(); + + sf::Vector2f getBunkerPosition(); + + const sf::Sprite& getColliderSprite() override; + void onCollision(ICollider* other_collider) override; + }; + } + +} \ No newline at end of file diff --git a/Space-Invaders/Header/Elements/Bunker/BunkerModel.h b/Space-Invaders/Header/Elements/Bunker/BunkerModel.h new file mode 100644 index 000000000..5e1a0f50b --- /dev/null +++ b/Space-Invaders/Header/Elements/Bunker/BunkerModel.h @@ -0,0 +1,14 @@ +#pragma once +#include + +namespace Element +{ + namespace Bunker + { + struct BunkerData + { + sf::Vector2f position;BunkerData(); + BunkerData(sf::Vector2f position); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Elements/Bunker/BunkerView.h b/Space-Invaders/Header/Elements/Bunker/BunkerView.h new file mode 100644 index 000000000..2c3aab987 --- /dev/null +++ b/Space-Invaders/Header/Elements/Bunker/BunkerView.h @@ -0,0 +1,36 @@ +#pragma once +#include +#include"../../Header/UI/UIElement/ImageView.h" + +namespace Element +{ + namespace Bunker + { + class BunkerController; + + class BunkerView + { + private: + const float bunker_sprite_width = 80.f; + const float bunker_sprite_height = 80.f; + + BunkerController* bunker_controller; + UI::UIElement::ImageView* bunker_image; + + void createUIElements(); + void initializeImage(); + + void destroy(); + + public: + BunkerView(); + ~BunkerView(); + + void initialize(BunkerController* controller); + void update(); + void render(); + + const sf::Sprite& getBunkerSprite(); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Elements/ElementService.h b/Space-Invaders/Header/Elements/ElementService.h new file mode 100644 index 000000000..9c6fd7bc1 --- /dev/null +++ b/Space-Invaders/Header/Elements/ElementService.h @@ -0,0 +1,43 @@ +#pragma once +#include +#include +#include"../../Header/Elements/Bunker/BunkerController.h" +#include"../../Header/Elements/Bunker/BunkerModel.h" + +namespace Element +{ + class BunkerController; + + + class ElementService + { + private: + const std::vectorbunker_data_list = { + Bunker::BunkerData(sf::Vector2f(130.f,800.f)), + Bunker::BunkerData(sf::Vector2f(430.0f,800.f)), + Bunker::BunkerData(sf::Vector2f(730.0f,800.f)), + Bunker::BunkerData(sf::Vector2f(1130.0f,800.f)), + Bunker::BunkerData(sf::Vector2f(1430.f,800.f)), + Bunker::BunkerData(sf::Vector2f(1730.0f,800.f)) + }; + + std::vector bunker_list; + std::vector flagged_bunker_list; + + void spawnBunkers(); + void destroyFlaggedBunkers(); + void destroy(); + + public: + ElementService(); + virtual ~ElementService(); + + void initialize(); + void update(); + void render(); + + void reset(); + + void destroyBunker(Bunker::BunkerController* bunker_controller); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/Controllers/SubZeroController.h b/Space-Invaders/Header/Enemy/Controllers/SubZeroController.h new file mode 100644 index 000000000..24ce244d2 --- /dev/null +++ b/Space-Invaders/Header/Enemy/Controllers/SubZeroController.h @@ -0,0 +1,26 @@ +#pragma once +#include "../../header/Enemy/EnemyController.h" + +namespace Enemy +{ + namespace Controller + { + class SubzeroController : public EnemyController + { + private: + float subzero_vertical_movement_speed = 100.f; + const float subzero_rate_of_fire = 2.f; + + void move() override; + void moveDown(); + void fireBullet() override; + void destroy() override; + + public: + SubzeroController(EnemyType type); + ~SubzeroController(); + + void initialize() override; + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/Controllers/ThunderSnakeController.h b/Space-Invaders/Header/Enemy/Controllers/ThunderSnakeController.h new file mode 100644 index 000000000..88fbb86e1 --- /dev/null +++ b/Space-Invaders/Header/Enemy/Controllers/ThunderSnakeController.h @@ -0,0 +1,28 @@ +#pragma once +#include"../../Header/Enemy/EnemyController.h" + +namespace Enemy +{ + namespace Controller + { + class ThunderSnakeController : public EnemyController + { + private: + float thundersnake_horizontal_movement_speed = 250.f; + float thundersnake_vertical_movement_speed = 25.f; + float thundersnake_rate_of_fire = 2.f; + + void move() override; + void moveLeft(); + void moveRight(); + void fireBullet() override; + void destroy() override; + + public: + ThunderSnakeController(EnemyType type); + ~ThunderSnakeController(); + + void initialize() override; + }; + } +} diff --git a/Space-Invaders/Header/Enemy/Controllers/UFOController.h b/Space-Invaders/Header/Enemy/Controllers/UFOController.h new file mode 100644 index 000000000..29a37fb43 --- /dev/null +++ b/Space-Invaders/Header/Enemy/Controllers/UFOController.h @@ -0,0 +1,29 @@ +#pragma once +#include"../../Header/Enemy/EnemyController.h" +#include"../../Header/Powerup/PowerupConfig.h" + +namespace Enemy +{ + namespace Controller + { + class UFOController : public EnemyController + { + private: + void move() override; + void moveLeft(); + void moveRight(); + + void fireBullet() override; + void destroy() override; + Powerup::PowerupType getRandomPowerupType(); + + public: + UFOController(EnemyType type); + ~UFOController(); + + void initialize() override; + + virtual void onCollision(ICollider* other_collider)override; + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/Controllers/ZapperController.h b/Space-Invaders/Header/Enemy/Controllers/ZapperController.h new file mode 100644 index 000000000..9cb93b9b7 --- /dev/null +++ b/Space-Invaders/Header/Enemy/Controllers/ZapperController.h @@ -0,0 +1,28 @@ +#pragma once +#include "../../header/Enemy/EnemyController.h" + +namespace Enemy +{ + namespace Controller + { + class ZapperController : public EnemyController + { + private: + float zapper_vertical_travel_distance = 100.f; + float zapper_rate_of_fire = 2.f; + + void move() override; + void moveLeft(); + void moveRight(); + void moveDown(); + void fireBullet() override; + void destroy() override; + + public: + ZapperController(EnemyType type); + ~ZapperController(); + + void initialize() override; + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/EnemyConfig.h b/Space-Invaders/Header/Enemy/EnemyConfig.h new file mode 100644 index 000000000..435328ee9 --- /dev/null +++ b/Space-Invaders/Header/Enemy/EnemyConfig.h @@ -0,0 +1,26 @@ +#pragma once + +namespace Enemy +{ + enum class EnemyType + { + ZAPPER, + SUBZERO, + UFO, + THUNDER_SNAKE, + }; + + enum class EnemyState + { + PATROLLING, + ATTACK, + DEAD, + }; + + enum class MovementDirection + { + LEFT, + RIGHT, + DOWN, + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/EnemyController.h b/Space-Invaders/Header/Enemy/EnemyController.h new file mode 100644 index 000000000..af678f34c --- /dev/null +++ b/Space-Invaders/Header/Enemy/EnemyController.h @@ -0,0 +1,50 @@ +#pragma once +#include +#include"../../Header/Collision/ICollider.h" + +namespace Enemy +{ + class EnemyView; + class EnemyModel; + + enum class EnemyType; + enum class EnemyState; + + class EnemyController : public Collision::ICollider + { + protected: + + float vertical_movement_speed = 30.f; + float horizontal_movement_speed = 200.f; + + float rate_of_fire = 3.f; + float elapsed_fire_duration = 0.f; + + EnemyView* enemy_view; + EnemyModel* enemy_model; + + virtual void move() = 0; + + void updateFireTimer(); + void processBulletFire(); + virtual void fireBullet() = 0; + + sf::Vector2f getRandomInitialPosition(); + virtual void destroy(); + + public: + EnemyController(EnemyType type); + virtual ~EnemyController(); + + virtual void initialize(); + void update(); + void render(); + + sf::Vector2f getEnemyPosition(); + EnemyState getEnemyState(); + EnemyType getEnemyType(); + + const sf::Sprite& getColliderSprite() override; + virtual void onCollision(ICollider* other_collider)override; + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/EnemyModel.h b/Space-Invaders/Header/Enemy/EnemyModel.h new file mode 100644 index 000000000..f71c62f5b --- /dev/null +++ b/Space-Invaders/Header/Enemy/EnemyModel.h @@ -0,0 +1,50 @@ +#pragma once +#include +#include"../../Header/Entity/EntityConfig.h" + +namespace Enemy +{ + enum class EnemyType; + enum class MovementDirection; + enum class EnemyState; + + class EnemyModel + { + private: + sf::Vector2f reference_position = sf::Vector2f(50.f, 100.f); + sf::Vector2f enemy_position; + + MovementDirection movement_direction; + EnemyType enemy_type; + EnemyState enemy_state; + Entity::EntityType owner_type; + + public: + + const sf::Vector2f left_most_position = sf::Vector2f(50.f, 100.f); + const sf::Vector2f right_most_position = sf::Vector2f(1800.f, 100.f); + const sf::Vector2f barrel_position_offset = sf::Vector2f(20.f, 50.f); + + EnemyModel(EnemyType type); + ~EnemyModel(); + + void initialize(); + + sf::Vector2f getEnemyPosition(); + void setEnemyPosition(sf::Vector2f position); + + sf::Vector2f getReferencePosition(); + void setReferencePosition(sf::Vector2f position); + + EnemyState getEnemyState(); + void setEnemyState(EnemyState state); + + EnemyType getEnemyType(); + void setEnemyType(EnemyType type); + + MovementDirection getMovementDirection(); + void setMovementDirection(MovementDirection direction); + + Entity::EntityType getOwnerEntityType(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/EnemyService.h b/Space-Invaders/Header/Enemy/EnemyService.h new file mode 100644 index 000000000..aa898215c --- /dev/null +++ b/Space-Invaders/Header/Enemy/EnemyService.h @@ -0,0 +1,41 @@ +#pragma once +#include + +namespace Enemy +{ + class EnemyController; + enum class EnemyType; + + class EnemyService + { + private: + + const float spawn_interval = 2.f; + + std::vector enemy_list; + std::vectorflagged_enemy_list; + float spawn_timer; + + EnemyController* createEnemy(EnemyType enemy_type); + EnemyType getRandomEnemyType(); + + void updateSpawnTimer(); + void processEnemySpawn(); + + void destroy(); + void destroyFlaggedEnemies(); + + public: + EnemyService(); + ~EnemyService(); + + void initialize(); + void update(); + void render(); + + void reset(); + + EnemyController* spawnEnemy(); + void destroyEnemy(EnemyController* enemy_controller); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/EnemyView.h b/Space-Invaders/Header/Enemy/EnemyView.h new file mode 100644 index 000000000..ab2bc3fbb --- /dev/null +++ b/Space-Invaders/Header/Enemy/EnemyView.h @@ -0,0 +1,37 @@ +#pragma once +#include +#include"../../Header/UI/UIElement/ImageView.h" + +namespace Enemy +{ + class EnemyController; + enum class EnemyType; + + class EnemyView + { + private: + + const float enemy_sprite_width = 60.f; + const float enemy_sprite_height = 60.f; + + EnemyController* enemy_controller; + UI::UIElement::ImageView* enemy_image; + + + void createUIElements(); + void initializeImage(); + sf::String getEnemyTexturePath(); + + void destroy(); + + public: + EnemyView(); + ~EnemyView(); + + void initialize(EnemyController* controller); + void update(); + void render(); + + const sf::Sprite& getEnemySprite(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Entity/EntityConfig.h b/Space-Invaders/Header/Entity/EntityConfig.h new file mode 100644 index 000000000..214f96778 --- /dev/null +++ b/Space-Invaders/Header/Entity/EntityConfig.h @@ -0,0 +1,13 @@ +#pragma once + +namespace Entity +{ + enum class EntityType + { + PLAYER, + ENEMY, + BULLET, + BUNKER, + DEFAULT, + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Event/EventService.h b/Space-Invaders/Header/Event/EventService.h new file mode 100644 index 000000000..11280206d --- /dev/null +++ b/Space-Invaders/Header/Event/EventService.h @@ -0,0 +1,50 @@ +#pragma once +#include +#include + +namespace Event +{ + enum class ButtonState + { + PRESSED, + HELD, + RELEASED, + }; + class EventService + { + private: + sf::Event game_event; + sf::RenderWindow* game_window; + + bool isGameWindowOpen(); + bool gameWindowWasClosed(); + bool hasQuitGame(); + + ButtonState left_mouse_button_state; + ButtonState right_mouse_button_state; + ButtonState left_arrow_button_state; + ButtonState right_arrow_button_state; + ButtonState A_button_state; + ButtonState D_button_state; + + void updateMouseButtonState(ButtonState& current_button_state, sf::Mouse::Button mouse_button); + void updateKeyboardButtonState(ButtonState& current_button_state, sf::Keyboard::Key keyboard_button); + + public: + EventService(); + ~EventService(); + + void initialize(); + void update(); + void processEvents(); + bool pressedEscapeKey(); + bool isKeyboardEvent(); + bool pressedLeftKey(); + bool pressedRightKey(); + bool pressedLeftMouseButton(); + bool pressedRightMouseButton(); + bool pressedAKey(); + bool pressedDKey(); + + }; +} diff --git a/Space-Invaders/Header/Gameplay/GameplayController.h b/Space-Invaders/Header/Gameplay/GameplayController.h new file mode 100644 index 000000000..558f836d2 --- /dev/null +++ b/Space-Invaders/Header/Gameplay/GameplayController.h @@ -0,0 +1,21 @@ +#pragma once +#include + +namespace Gameplay +{ + class GameplayView; + + class GameplayController + { + private: + GameplayView* gameplay_view; + + public: + GameplayController(); + ~GameplayController(); + + void initialize(); + void update(); + void render(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Gameplay/GameplayService.h b/Space-Invaders/Header/Gameplay/GameplayService.h new file mode 100644 index 000000000..354439365 --- /dev/null +++ b/Space-Invaders/Header/Gameplay/GameplayService.h @@ -0,0 +1,22 @@ +#pragma once + +namespace Gameplay +{ + class GameplayController; + + class GameplayService + { + private: + GameplayController* gameplay_controller; + + public: + GameplayService(); + ~GameplayService(); + + void initialize(); + void update(); + void render(); + + void restart(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Gameplay/GameplayView.h b/Space-Invaders/Header/Gameplay/GameplayView.h new file mode 100644 index 000000000..ca3254ca1 --- /dev/null +++ b/Space-Invaders/Header/Gameplay/GameplayView.h @@ -0,0 +1,29 @@ +#pragma once +#include +#include"../../Header/UI/UIElement/ImageView.h" + +namespace Gameplay +{ + class GamePlayController; + + class GameplayView + { + private: + + sf::RenderWindow* game_window; + sf::Texture background_texture; + sf::Sprite background_sprite; + + GamePlayController* gameplay_controller; + UI::UIElement::ImageView* background_image; + + void initializeBackgroundImage(); + public: + GameplayView(); + ~GameplayView(); + + void initialize(); + void update(); + void render(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Global/Config.h b/Space-Invaders/Header/Global/Config.h new file mode 100644 index 000000000..444d74b59 --- /dev/null +++ b/Space-Invaders/Header/Global/Config.h @@ -0,0 +1,44 @@ +#pragma once +#include + +namespace Global +{ + class Config + { + public: + static const sf::String outscal_logo_texture_path; + static const sf::String background_texture_path; + static const sf::String player_texture_path; + + static const sf::String zapper_texture_path; + static const sf::String thunder_snake_texture_path; + static const sf::String subzero_texture_path; + static const sf::String ufo_texture_path; + static const sf::String bunker_texture_path; + static const sf::String explosion_texture_path; + + static const sf::String shield_texture_path; + static const sf::String tripple_laser_texture_path; + static const sf::String rapid_fire_texture_path; + static const sf::String outscal_bomb_texture_path; + + static const sf::String laser_bullet_texture_path; + static const sf::String torpedoe_texture_path; + static const sf::String frost_beam_texture_path; + + static const sf::String play_button_texture_path; + static const sf::String instructions_button_texture_path; + static const sf::String quit_button_texture_path; + static const sf::String menu_button_texture_path; + + static const sf::String bubble_bobble_font_path; + static const sf::String DS_DIGIB_font_path; + + static const sf::String background_music_path; + static const sf::String button_click_sound_path; + static const sf::String explosion_sound_path; + static const sf::String powerup_enabled_sound_path; + static const sf::String powerup_disabled_sound_path; + static const sf::String bulletfire_sound_path; + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Global/ServiceLocator.h b/Space-Invaders/Header/Global/ServiceLocator.h new file mode 100644 index 000000000..2c5f87bb8 --- /dev/null +++ b/Space-Invaders/Header/Global/ServiceLocator.h @@ -0,0 +1,66 @@ +#pragma once +#include "../../Header/Graphic/GraphicService.h" +#include "../../Header/Event/EventService.h" +#include "../../Header/Player/PlayerService.h" +#include "../../Header/Time/TimeService.h" +#include "../../Header/UI/UIService.h" +#include "../../Header/Enemy/EnemyService.h" +#include "../../Header/Gameplay/GameplayService.h" +#include"../../Header/Elements/ElementService.h" +#include"../../Header/Sound/SoundService.h" +#include"../../Header/Bullet/BulletService.h" +#include"../../Header/Powerup/PowerupService.h" +#include"../../Header/Collision/CollisionService.h" +#include"../../Header/AnimationSystem/AnimationService.h" + +namespace Global +{ + class ServiceLocator + { + private: + + Graphic::GraphicService* graphic_service; + Event::EventService* event_service; + Player::PlayerService* player_service; + Time::TimeService* time_service; + UI::UIService* ui_service; + Enemy::EnemyService* enemy_service; + Gameplay::GameplayService* gameplay_service; + Element::ElementService* element_service; + Sound::SoundService* sound_service; + Bullet::BulletService* bullet_service; + Powerup::PowerupService* powerup_service; + Collision::CollisionService* collision_service; + Animation::AnimationService* animation_service; + + ServiceLocator(); + ~ServiceLocator(); + + // Private Methods: + void createServices(); + void clearAllServices(); + + public: + // Public Methods: + static ServiceLocator* getInstance(); + + void initialize(); + void update(); + void render(); + + // Methods to Get Specific Services: + Event::EventService* getEventService(); + Graphic::GraphicService* getGraphicService(); + Player::PlayerService* getPlayerService(); + Time::TimeService* getTimeService(); + UI::UIService* getUIService(); + Enemy::EnemyService* getEnemyService(); + Gameplay::GameplayService* getGameplayService(); + Element::ElementService* getElementService(); + Sound::SoundService* getSoundService(); + Bullet::BulletService* getBulletService(); + Powerup::PowerupService* getPowerupService(); + Collision::CollisionService* getCollisionService(); + Animation::AnimationService* getAnimationService(); + }; +} diff --git a/Space-Invaders/Header/Graphic/GraphicService.h b/Space-Invaders/Header/Graphic/GraphicService.h new file mode 100644 index 000000000..aee864fc5 --- /dev/null +++ b/Space-Invaders/Header/Graphic/GraphicService.h @@ -0,0 +1,38 @@ +#pragma once +#include + +namespace Graphic +{ + class GraphicService + { + private: + const std::string game_window_title = "Outscal Presents - Alien Invader"; + + const int game_window_width = 1920; + const int game_window_height = 1080; + const int frame_rate = 60; + + const sf::Color window_color = sf::Color::Black; + + sf::VideoMode* video_mode; + sf::RenderWindow* game_window; + + void setVideoMode(); + void onDestroy(); + + public: + GraphicService(); + ~GraphicService(); + + sf::RenderWindow* createGameWindow(); + + void initialize(); + void update(); + void render(); + bool isGameWindowOpen(); + + sf::RenderWindow* getGameWindow(); + sf::Color getWindowColor(); + + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Main/GameService.h b/Space-Invaders/Header/Main/GameService.h new file mode 100644 index 000000000..1c8c7c57c --- /dev/null +++ b/Space-Invaders/Header/Main/GameService.h @@ -0,0 +1,44 @@ +#pragma once +#include + +namespace Global +{ + class ServiceLocator; +} +namespace Main +{ + + enum class GameState + { + BOOT, + MAIN_MENU, + GAMEPLAY, + SPLASH_SCREEN, + INSTRUCTIONS, + CREDITS, + }; + class GameService + { + private: + + Global::ServiceLocator* service_locator; + sf::RenderWindow* game_window; + static GameState current_state; + + void showSplashScreen(); + void initialize(); + void initializeVariables(); + void destroy(); + + public: + GameService(); + ~GameService(); + + void ignite(); + void update(); + void render(); + bool isRunning(); + static void setGameState(GameState new_state); + static GameState getGameState(); + }; +} diff --git a/Space-Invaders/Header/Player/PlayerController.h b/Space-Invaders/Header/Player/PlayerController.h new file mode 100644 index 000000000..4bd4eb437 --- /dev/null +++ b/Space-Invaders/Header/Player/PlayerController.h @@ -0,0 +1,76 @@ +#pragma once +#include +#include"../../Header/Player/PlayerModel.h" +#include"../../Header/Entity/EntityConfig.h" +#include"../../Header/Collision/ICollider.h" +#include"../../Header/Powerup/PowerupConfig.h" + +namespace Player +{ + enum class PlayerState; + class PlayerView; + class PlayerModel; + + class PlayerController : public Collision::ICollider + { + private: + float elapsed_shield_duration; + float elapsed_rapid_fire_duration; + float elapsed_tripple_laser_duration; + + float elapsed_fire_duration; + float elapsed_freez_duration; + + PlayerModel* player_model; + PlayerView* player_view; + + void processPlayerInput(); + void moveLeft(); + void moveRight(); + + bool processBulletCollision(ICollider* other_collider); + bool processPowerupCollision(ICollider* other_collider); + bool processEnemyCollision(ICollider* other_collider); + void updateFreezDuration(); + void freezPlayer(); + + void updateFireDuration(); + void processBulletFire(); + void fireBullet(bool b_tripple_laser = false); + void fireBullet(sf::Vector2f position); + + void updatePowerupDuration(); + + void disableShield(); + void disableRapidFire(); + void disableTrippleLaser(); + + + public: + PlayerController(); + ~PlayerController(); + + + void initialize(); + void update(); + void render(); + + void reset(); + + void enableShield(); + void enableRapidFire(); + void enableTrippleLaser(); + + void decreasePlayerlive(); + inline void increaseEnemiesKilled(int val) { PlayerModel::enemies_killed += val; } + + const sf::Sprite& getColliderSprite() override; + void onCollision(ICollider* other_collider) override; + + sf::Vector2f getPlayerPosition(); + PlayerState getPlayerState(); + + Entity::EntityType getOwnerEntityType(); + + }; +} diff --git a/Space-Invaders/Header/Player/PlayerModel.h b/Space-Invaders/Header/Player/PlayerModel.h new file mode 100644 index 000000000..376291595 --- /dev/null +++ b/Space-Invaders/Header/Player/PlayerModel.h @@ -0,0 +1,86 @@ +#pragma once +#include +#include"../../Header/Entity/EntityConfig.h" +#include"../../Header/UI/GameplayUI/GameplayUIController.h" + +namespace Player +{ + enum class PlayerState + { + ALIVE, + DEAD, + FROZEN, + }; + + class PlayerModel + { + private: + + friend class PlayerController; + + friend void UI::GameplayUI::GameplayUIController::updateEnemiesKilledText(); + friend void UI::GameplayUI::GameplayUIController::drawPlayerLives(); + + const int max_player_lives = 3; + + sf::Vector2f initial_player_position = sf::Vector2f(950.f, 950.f); + sf::Vector2f player_position; + + PlayerState player_state; + Entity::EntityType owner_type; + + static int player_lives; + static int enemies_killed; + static int bullets_fired; + + bool b_shield; + bool b_rapid_fire; + bool b_tripple_laser; + + public: + const float player_movement_speed = 350.0f; + static const int invincible_player_alpha = 170.f; + + const sf::Vector2f left_most_position = sf::Vector2f(50.f, 950.f); + const sf::Vector2f right_most_position = sf::Vector2f(1800.f, 950.f); + const sf::Vector2f barrel_position_offset = sf::Vector2f(20.f, 50.f); + const sf::Vector2f second_weapon_position_offset = sf::Vector2f(45.f, 0.f); + const sf::Vector2f third_weapon_position_offset = sf::Vector2f(-45.f, 0.f); + + const float shield_powerup_duration = 10.f; + const float rapid_fire_powerup_duration = 10.f; + const float tripple_laser_powerup_duration = 10.f; + + const float freez_duration = 2.f; + + const float fire_cooldown_duration = 0.2f; + const float rapid_fire_cooldown_duration = 0.05f; + const float tripple_laser_position_offset = 30.f; + + float elapsedShieldDuration; + float elapsedRapidFireDuration; + float elapsedTrippleLaserDuration; + + PlayerModel(); + ~PlayerModel(); + + void initialize(); + void reset(); + + sf::Vector2f getPlayerPosition(); + void setPlayerPosition(sf::Vector2f position); + + PlayerState getPlayerState(); + void setPlayerState(PlayerState state); + + Entity::EntityType getOwnerEntityType(); + + bool isShieldEnabled(); + bool isRapidFireEnabled(); + bool isTrippleFireEnabled(); + + void setShieldState(bool value); + void setRapidFireState(bool value); + void setTrippleFireState(bool value); + }; +} diff --git a/Space-Invaders/Header/Player/PlayerService.h b/Space-Invaders/Header/Player/PlayerService.h new file mode 100644 index 000000000..362ce8c31 --- /dev/null +++ b/Space-Invaders/Header/Player/PlayerService.h @@ -0,0 +1,32 @@ +#pragma once + +namespace Player +{ + class PlayerController; + + class PlayerService + { + + private: + + PlayerController* player_controller; + + public: + + PlayerService(); + ~PlayerService(); + + void initialize(); + void update(); + void render(); + + void enableShield(); + void enableRapidFire(); + void enableTrippleLaser(); + + void increaseEnemiesKilled(int val); + + void reset(); + }; +} + diff --git a/Space-Invaders/Header/Player/PlayerView.h b/Space-Invaders/Header/Player/PlayerView.h new file mode 100644 index 000000000..cf6ad919a --- /dev/null +++ b/Space-Invaders/Header/Player/PlayerView.h @@ -0,0 +1,37 @@ +#pragma once +#include +#include"../../Header/UI/UIElement/ImageView.h" + +namespace Player +{ + class PlayerController; + + class PlayerView + { + private: + + const float player_sprite_width = 60.0f; + const float player_sprite_height = 60.0f; + + + PlayerController* player_controller; + UI::UIElement::ImageView* player_image; + + void createUIElements(); + void initializeImage(); + + void destroy(); + + public: + PlayerView(); + ~PlayerView(); + + void initialize(PlayerController* controller); + void update(); + void render(); + + void setPlayerHighlight(bool b_highlight); + const sf::Sprite& getPlayerSprite(); + + }; +} diff --git a/Space-Invaders/Header/Powerup/Controllers/OutscalBombController.h b/Space-Invaders/Header/Powerup/Controllers/OutscalBombController.h new file mode 100644 index 000000000..ba814a9bb --- /dev/null +++ b/Space-Invaders/Header/Powerup/Controllers/OutscalBombController.h @@ -0,0 +1,20 @@ +#pragma once +#include"../../Header/Powerup/PowerupController.h" + +namespace Powerup +{ + namespace Controller + { + class OutscalBombController : public PowerupController + { + protected: + void applyPowerup() override; + + public: + OutscalBombController(PowerupType type); + virtual ~OutscalBombController(); + }; + } +} + + diff --git a/Space-Invaders/Header/Powerup/Controllers/RapidFireController.h b/Space-Invaders/Header/Powerup/Controllers/RapidFireController.h new file mode 100644 index 000000000..3793b971f --- /dev/null +++ b/Space-Invaders/Header/Powerup/Controllers/RapidFireController.h @@ -0,0 +1,20 @@ +#pragma once +#include"../../Header/Powerup/PowerupController.h" + +namespace Powerup +{ + namespace Controller + { + class RapidFireController :public PowerupController + { + protected: + void applyPowerup()override; + + public: + RapidFireController(PowerupType type); + virtual ~RapidFireController(); + + + }; + } +} diff --git a/Space-Invaders/Header/Powerup/Controllers/ShieldController.h b/Space-Invaders/Header/Powerup/Controllers/ShieldController.h new file mode 100644 index 000000000..b2275ec19 --- /dev/null +++ b/Space-Invaders/Header/Powerup/Controllers/ShieldController.h @@ -0,0 +1,20 @@ +#pragma once +#include "../../Header/Powerup/PowerupController.h" + +namespace Powerup +{ + namespace Controller + { + class ShieldController :public PowerupController + { + protected: + void applyPowerup()override; + + public: + ShieldController(PowerupType type); + virtual ~ShieldController(); + + + }; + } +} diff --git a/Space-Invaders/Header/Powerup/Controllers/TripleLaserController.h b/Space-Invaders/Header/Powerup/Controllers/TripleLaserController.h new file mode 100644 index 000000000..bce9af8f8 --- /dev/null +++ b/Space-Invaders/Header/Powerup/Controllers/TripleLaserController.h @@ -0,0 +1,21 @@ +#pragma once +#include"../../Header/Powerup/PowerupController.h" + +namespace Powerup +{ + namespace Controller + { + class TripleLaserController : public PowerupController + { + protected: + void applyPowerup()override; + + public: + TripleLaserController(PowerupType type); + virtual ~TripleLaserController(); + + + + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Powerup/PowerupConfig.h b/Space-Invaders/Header/Powerup/PowerupConfig.h new file mode 100644 index 000000000..079692707 --- /dev/null +++ b/Space-Invaders/Header/Powerup/PowerupConfig.h @@ -0,0 +1,13 @@ +#pragma once +namespace Powerup +{ + enum class PowerupType + { + SHIELD, + RAPID_FIRE, + TRIPPLE_LASER, + OUTSCAL_BOMB, + }; +} + + diff --git a/Space-Invaders/Header/Powerup/PowerupController.h b/Space-Invaders/Header/Powerup/PowerupController.h new file mode 100644 index 000000000..0824227a1 --- /dev/null +++ b/Space-Invaders/Header/Powerup/PowerupController.h @@ -0,0 +1,39 @@ +#pragma once +#include"../../Header/Collectible/ICollectible.h" +#include"../../Header/Collision/ICollider.h" + +namespace Powerup +{ + class PowerupView; + class PowerupModel; + + enum class PowerupType; + + class PowerupController :public Collectible::ICollectible, public Collision::ICollider + { + protected: + PowerupView* powerup_view; + PowerupModel* powerup_model; + + virtual void applyPowerup() = 0; + void updatePowerupPosition(); + void handleOutOfBounds(); + + public: + PowerupController(PowerupType type); + virtual ~PowerupController(); + + void initialize(sf::Vector2f position)override; + void update()override; + void render()override; + + void onCollected()override; + + sf::Vector2f getCollectiblePosition()override; + PowerupType getPowerupType(); + + const sf::Sprite& getColliderSprite() override; + void onCollision(ICollider* other_collider)override; + }; +} + diff --git a/Space-Invaders/Header/Powerup/PowerupModel.h b/Space-Invaders/Header/Powerup/PowerupModel.h new file mode 100644 index 000000000..3431de028 --- /dev/null +++ b/Space-Invaders/Header/Powerup/PowerupModel.h @@ -0,0 +1,31 @@ +#pragma once +#include + +namespace Powerup +{ + enum class PowerupType; + + class PowerupModel + { + private: + float movement_speed = 300.f; + + sf::Vector2f powerup_position; + PowerupType powerup_type; + + public: + PowerupModel(PowerupType type); + ~PowerupModel(); + + void initialize(sf::Vector2f position); + + sf::Vector2f getPowerupPosition(); + void setPowerupPosition(sf::Vector2f position); + + PowerupType getPowerupType(); + void setPowerupType(PowerupType type); + + float getMovementSpeed(); + void setMovementSpeed(float speed); + }; +} diff --git a/Space-Invaders/Header/Powerup/PowerupService.h b/Space-Invaders/Header/Powerup/PowerupService.h new file mode 100644 index 000000000..f07043388 --- /dev/null +++ b/Space-Invaders/Header/Powerup/PowerupService.h @@ -0,0 +1,33 @@ +#pragma once +#include"../../Header/Collectible/ICollectible.h" +#include +#include"SFML/System/Vector2.hpp" + +namespace Powerup +{ + enum class PowerupType; + class PowerupController; + enum class MovementDirection; + + class PowerupService + { + private: + std::vector powerup_list; + std::vectorflagged_power_up_list; + + PowerupController* createPowerup(PowerupType powerup_type); + void destroy(); + void destroyFlaggedPowerup(); + + public: + PowerupService(); + ~PowerupService(); + + void initialize(); + void update(); + void render(); + + PowerupController* spawnPowerup(PowerupType powerup_type, sf::Vector2f position); + void destroyPowerup(PowerupController* powerup_controller); + }; +} diff --git a/Space-Invaders/Header/Powerup/PowerupView.h b/Space-Invaders/Header/Powerup/PowerupView.h new file mode 100644 index 000000000..51911efcd --- /dev/null +++ b/Space-Invaders/Header/Powerup/PowerupView.h @@ -0,0 +1,35 @@ +#pragma once +#include +#include"../../Header/UI/UIElement/ImageView.h" + +namespace Powerup +{ + class PowerupController; + enum class PowerupType; + + class PowerupView + { + private: + const float powerup_sprite_width = 30.f; + const float powerup_sprite_height = 30.f; + + PowerupController* powerup_controller; + UI::UIElement::ImageView* powerup_image; + + void createUIElements(); + void initializeImage(); + sf::String getPowerupTexturePath(); + + void destroy(); + + public: + PowerupView(); + ~PowerupView(); + + void initialize(PowerupController* controller); + void update(); + void render(); + + const sf::Sprite& getPowerupSprite(); + }; +} diff --git a/Space-Invaders/Header/Projectile/IProjectile.h b/Space-Invaders/Header/Projectile/IProjectile.h new file mode 100644 index 000000000..52cf8083c --- /dev/null +++ b/Space-Invaders/Header/Projectile/IProjectile.h @@ -0,0 +1,21 @@ +#pragma once +#include +#include"../../Header/Bullet/BulletConfig.h" + +namespace Projectile +{ + enum class MovementDirection; + + class IProjectile + { + public: + virtual void initialize(sf::Vector2f position, Bullet::MovementDirection direction) = 0; + virtual void update() = 0; + virtual void render() = 0; + + virtual void updateProjectilePosition() = 0; + virtual sf::Vector2f getProjectilePosition() = 0; + + virtual ~IProjectile() {}; + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Sound/SoundService.h b/Space-Invaders/Header/Sound/SoundService.h new file mode 100644 index 000000000..6e47cac0b --- /dev/null +++ b/Space-Invaders/Header/Sound/SoundService.h @@ -0,0 +1,38 @@ +#pragma once +#include"SFML/Audio.hpp" + +namespace Sound +{ + enum class SoundType + { + BUTTON_CLICK, + EXPLOSION, + POWERUP_ENABLED, + POWERUP_DISABLED, + BULLET_FIRE, + }; + + class SoundService + { + private: + const int background_music_volume = 30; + + sf::Music background_music; + sf::Sound sound_effect; + sf::SoundBuffer buffer_button_click; + sf::SoundBuffer buffer_explosion_sound; + sf::SoundBuffer buffer_powerup_enabled; + sf::SoundBuffer buffer_powerup_disabled; + sf::SoundBuffer buffer_bullet_fire; + + + void loadBackgroundMusicFromFile(); + void loadSoundFromFile(); + + public: + void initialize(); + + void playSound(SoundType soundType); + void playBackgroundMusic(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Time/TimeService.h b/Space-Invaders/Header/Time/TimeService.h new file mode 100644 index 000000000..04b3d72ad --- /dev/null +++ b/Space-Invaders/Header/Time/TimeService.h @@ -0,0 +1,25 @@ +#pragma once +#include + +namespace Time +{ + class TimeService + { + private: + std::chrono::time_pointprevious_time; + + float delta_time; + + void updateDeltaTime(); + float calculateDeltaTime(); + void updatePreviousTime(); + + public: + void initialize(); + void update(); + + float getDeltaTime(); + + }; +} + diff --git a/Space-Invaders/Header/UI/GameplayUI/GameplayUIController.h b/Space-Invaders/Header/UI/GameplayUI/GameplayUIController.h new file mode 100644 index 000000000..353174f53 --- /dev/null +++ b/Space-Invaders/Header/UI/GameplayUI/GameplayUIController.h @@ -0,0 +1,50 @@ +#pragma once +#include"../../Header/UI/Interface/IUIController.h" +#include"../../Header/UI/UIElement/ImageView.h" +#include"../../Header/UI/UIElement/ButtonView.h" +#include"../../Header/UI/UIElement/TextView.h" + +namespace UI +{ + namespace GameplayUI + { + class GameplayUIController : public Interface::IUIController + { + private: + const float font_size = 40.f; + + const float text_y_position = 15.f; + const float enemies_killed_text_x_position = 60.f; + + const float player_lives_y_offset = 25.f; + const float player_lives_x_offset = 1850.f; + const float player_lives_spacing = 60.f; + + const float player_sprite_width = 30.f; + const float player_sprite_height = 30.f; + + const sf::Color text_color = sf::Color::White; + + UI::UIElement::ImageView* player_image; + UI::UIElement::TextView* enemies_killed_text; + + void createUIElements(); + void initializeImage(); + void initializeText(); + + void destroy(); + + public: + GameplayUIController(); + ~GameplayUIController(); + + void initialize(); + void update(); + void render(); + void show(); + + void updateEnemiesKilledText(); + void drawPlayerLives(); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/UI/Interface/IUIController.h b/Space-Invaders/Header/UI/Interface/IUIController.h new file mode 100644 index 000000000..cd4bd7d05 --- /dev/null +++ b/Space-Invaders/Header/UI/Interface/IUIController.h @@ -0,0 +1,18 @@ +#pragma once + +namespace UI +{ + namespace Interface + { + class IUIController + { + public: + virtual void initialize() = 0; + virtual void update() = 0; + virtual void render() = 0; + virtual void show() = 0; + + virtual ~IUIController(){} + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/UI/MainMenuUI/MainMenuUIController.h b/Space-Invaders/Header/UI/MainMenuUI/MainMenuUIController.h new file mode 100644 index 000000000..e026aee85 --- /dev/null +++ b/Space-Invaders/Header/UI/MainMenuUI/MainMenuUIController.h @@ -0,0 +1,56 @@ +#pragma once +#include +#include"../../Header/UI/Interface/IUIController.h" +#include"../../Header/UI/UIElement/ImageView.h" +#include"../../Header/UI/UIElement/ButtonView.h" +#include"../../Header/UI/UIElement/TextView.h" + +namespace UI +{ + namespace MainMenu + { + class MainMenuUIController : public Interface::IUIController + { + private: + const sf::Color text_color = sf::Color::White; + + const float button_width = 400.f; + const float button_height = 140.f; + + const float play_button_y_position = 300.f; + const float instructions_button_y_position = 500.f; + const float quit_button_y_position = 700.f; + + const float background_alpha = 90.f; + + UIElement::ImageView* background_image; + + UIElement::ButtonView* play_button; + UIElement::ButtonView* instructions_button; + UIElement::ButtonView* quit_button; + + void createImage(); + void createButtons(); + + void initializeBackgroundImage(); + void initializeButtons(); + + void registerButtonCallback(); + void playButtonCallback(); + void instructionsButtonCallback(); + void quitButtonCallback(); + + void destroy(); + + public: + MainMenuUIController(); + ~MainMenuUIController(); + + void initialize() override; + void update() override; + void render() override; + void show() override; + + }; + } +} diff --git a/Space-Invaders/Header/UI/SplashScreenUI/SplashScreenUIController.h b/Space-Invaders/Header/UI/SplashScreenUI/SplashScreenUIController.h new file mode 100644 index 000000000..fe276f992 --- /dev/null +++ b/Space-Invaders/Header/UI/SplashScreenUI/SplashScreenUIController.h @@ -0,0 +1,34 @@ +#pragma once +#include"../../Header/UI/UIElement/AnimatedImageView.h" +#include"../../Header/UI/Interface/IUIController.h" + +namespace UI +{ + namespace SplashScreen + { + class SplashScreenUIController : public Interface::IUIController + { + private: + + const float logo_animation_duration = 2.0f; + const float logo_width = 600.f; + const float logo_height = 134.f; + + UIElement::AnimatedImageView* outscal_logo_view; + + void initializeOutscalLogo(); + void fadeInAnimationCallback(); + void fadeOutAnimationCallback(); + sf::Vector2f getLogoPosition(); + + public: + SplashScreenUIController(); + ~SplashScreenUIController(); + + void initialize() override; + void update() override; + void render() override; + void show() override; + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/UI/UIElement/AnimatedImageView.h b/Space-Invaders/Header/UI/UIElement/AnimatedImageView.h new file mode 100644 index 000000000..0db6e50f0 --- /dev/null +++ b/Space-Invaders/Header/UI/UIElement/AnimatedImageView.h @@ -0,0 +1,54 @@ +#pragma once +#include"../../Header/UI/UIElement/ImageView.h" +#include + +namespace UI +{ + namespace UIElement + { + enum class AnimationType + { + FADE_IN, + FADE_OUT, + }; + + class AnimatedImageView : public ImageView + { + private: + using CallbackFunction = std::function; + + CallbackFunction callback_function = nullptr; + + void updateElapsedDuration(); + void handleAnimationProgress(); + void updateAnimation(); + + protected: + const float default_animation_duration = 2.0f; + + AnimationType animation_type; + float animation_duration; + float elapsed_duration; + sf::Clock clock; + + virtual void reset(); + void setAnimationDuration(float duration); + void setAnimationType(AnimationType type); + + virtual void fadeIn(); + virtual void fadeOut(); + + public: + AnimatedImageView(); + virtual ~AnimatedImageView(); + + virtual void initialize(sf::String texture_path, float image_width, float image_height, sf::Vector2f position) override; + virtual void update() override; + virtual void render() override; + + virtual void playAnimation(AnimationType type, float duration, CallbackFunction animation_end_callback); + + void registerCallbackFuntion(CallbackFunction animation_end_callback); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/UI/UIElement/ButtonView.h b/Space-Invaders/Header/UI/UIElement/ButtonView.h new file mode 100644 index 000000000..e9b2a08fd --- /dev/null +++ b/Space-Invaders/Header/UI/UIElement/ButtonView.h @@ -0,0 +1,35 @@ +#pragma once +#include"../../Header/UI/UIElement/ImageView.h" +#include + +namespace UI +{ + namespace UIElement + { + class ButtonView : public UIElement::ImageView + { + private: + using CallbackFunction = std::function; + + CallbackFunction callback_function = nullptr; + + void printButtonClicked(); + + protected: + sf::String button_title; + + virtual void handleButtonInteraction(); + virtual bool clickedButton(sf::Sprite* button_sprite, sf::Vector2f mouse_position); + + public: + ButtonView(); + virtual ~ButtonView(); + + virtual void initialize(sf::String title, sf::String texture_path, float button_width, float button_height, sf::Vector2f position); + virtual void update() override; + virtual void render() override; + + void registerCallbackFunction(CallbackFunction button_callback); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/UI/UIElement/ImageView.h b/Space-Invaders/Header/UI/UIElement/ImageView.h new file mode 100644 index 000000000..11e839714 --- /dev/null +++ b/Space-Invaders/Header/UI/UIElement/ImageView.h @@ -0,0 +1,35 @@ +#pragma once +#include"../../Header/UI/UIElement/UIView.h" + +namespace UI +{ + namespace UIElement + { + class ImageView : public UIView + { + protected: + sf::Texture image_texture; + sf::Sprite image_sprite; + + public: + ImageView(); + virtual ~ImageView(); + + const virtual sf::Sprite& getSprite(); + + virtual void initialize(sf::String texture_path, float image_width, float image_height, sf::Vector2f position); + virtual void update() override; + virtual void render() override; + + virtual void setTexture(sf::String texture_path); + virtual void setTextureRect(sf::IntRect texture_rect); + virtual void setScale(float width, float height); + virtual void setScale(float width, float height, float title_width, float tile_height); + virtual void setPosition(sf::Vector2f position); + virtual void setRotation(float rotation_angle); + virtual void setOriginAtCentre(); + virtual void setImageAlpha(float alpha); + virtual void setCentreAlinged(); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/UI/UIElement/TextView.h b/Space-Invaders/Header/UI/UIElement/TextView.h new file mode 100644 index 000000000..dddc376d4 --- /dev/null +++ b/Space-Invaders/Header/UI/UIElement/TextView.h @@ -0,0 +1,45 @@ +#pragma once +#include"../../Header/UI/UIElement/UIView.h" + +namespace UI +{ + namespace UIElement + { + enum class FontType + { + BUBBLE_BOBBLE, + DS_DIGIB, + }; + + class TextView : public UIView + { + private: + static const int default_font_size = 55; + + static sf::Font font_bubble_bobble; + static sf::Font font_DS_DIGIB; + + sf::Text text; + + static void loadFont(); + + void setFont(FontType font_type); + void setFontSize(int font_size); + void setTextPosition(sf::Vector2f position); + void setTextColor(sf::Color color); + + public: + TextView(); + virtual ~TextView(); + + static void initializeTextView(); + + virtual void initialize(sf::String text_value, sf::Vector2f position, FontType font_type = FontType::BUBBLE_BOBBLE, int font_size = default_font_size, sf::Color color = sf::Color::White); + virtual void update() override; + virtual void render() override; + + void setText(sf::String text_value); + void setTextCentreAligned(); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/UI/UIElement/UIView.h b/Space-Invaders/Header/UI/UIElement/UIView.h new file mode 100644 index 000000000..64f3850c8 --- /dev/null +++ b/Space-Invaders/Header/UI/UIElement/UIView.h @@ -0,0 +1,32 @@ +#pragma once +#include +#include"../../Header/Graphic/GraphicService.h" + +namespace UI +{ + namespace UIElement + { + enum class UIState + { + VISIBLE, + HIDDEN, + }; + + class UIView + { + protected: + sf::RenderWindow* game_window; + UIState ui_state; + + public: + UIView(); + virtual ~UIView(); + + virtual void initialize(); + virtual void update(); + virtual void render(); + virtual void show(); + virtual void hide(); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/UI/UIService.h b/Space-Invaders/Header/UI/UIService.h new file mode 100644 index 000000000..8b1fe9d5b --- /dev/null +++ b/Space-Invaders/Header/UI/UIService.h @@ -0,0 +1,36 @@ +#pragma once +#include "../../Header/UI/MainMenuUI/MainMenuUIController.h" +#include"../../Header/UI/Interface/IUIController.h" +#include"../../Header/UI/GameplayUI/GameplayUIController.h" +#include"../../Header/UI/SplashScreenUI/SplashScreenUIController.h" + +namespace UI +{ + class UIService + { + private: + + MainMenu::MainMenuUIController* main_menu_controller; + GameplayUI::GameplayUIController* gameplayUIController; + SplashScreen::SplashScreenUIController* splash_screen_ui_controller; + + + void createControllers(); + void initializeControllers(); + + Interface::IUIController* getCurrentUIController(); + + void destory(); + + + public: + UIService(); + ~UIService(); + + void initialize(); + void update(); + void render(); + void showScreen(); + + }; +} diff --git a/Space-Invaders/Source/AnimationSystem/AnimationService.cpp b/Space-Invaders/Source/AnimationSystem/AnimationService.cpp new file mode 100644 index 000000000..20c3b7129 --- /dev/null +++ b/Space-Invaders/Source/AnimationSystem/AnimationService.cpp @@ -0,0 +1,63 @@ +#include "../../header/AnimationSystem/AnimationService.h" +#include "../../header/AnimationSystem/AnimationSystemConfigData.h" + +namespace Animation +{ + AnimationService::AnimationService() { } + + AnimationService::~AnimationService() { destroy(); } + + void AnimationService::initialize() { } + + void AnimationService::update() + { + for (AnimationSystem* animation_system : animation_system_list) + animation_system->update(); + + destroyFlaggedAnimationSystem(); + } + + void AnimationService::render() + { + for (AnimationSystem* animation_system : animation_system_list) + animation_system->render(); + } + + void AnimationService::spawnAnimationSystem(sf::Vector2f position, AnimationType animation_type) + { + AnimationSystem* animation_system = new AnimationSystem(getAnimationSystemConfig(animation_type)); + animation_system->initialize(position); + animation_system_list.push_back(animation_system); + } + + void AnimationService::destroyAnimationSystem(AnimationSystem* animation_system) + { + flagged_animation_system_list.push_back(animation_system); + animation_system_list.erase(std::remove(animation_system_list.begin(), animation_system_list.end(), animation_system), animation_system_list.end()); + } + + AnimationSystemConfig AnimationService::getAnimationSystemConfig(AnimationType animation_type) + { + switch (animation_type) + { + case Animation::AnimationType::EXPLOSION: + return explosion_animation_config; + } + } + + void AnimationService::destroyFlaggedAnimationSystem() + { + for (AnimationSystem* particle_system : flagged_animation_system_list) + delete (particle_system); + + flagged_animation_system_list.clear(); + } + + void AnimationService::reset() { destroy(); } + + void AnimationService::destroy() + { + for (AnimationSystem* animation_system : animation_system_list) + delete (animation_system); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/AnimationSystem/AnimationSystem.cpp b/Space-Invaders/Source/AnimationSystem/AnimationSystem.cpp new file mode 100644 index 000000000..9b38ae4fc --- /dev/null +++ b/Space-Invaders/Source/AnimationSystem/AnimationSystem.cpp @@ -0,0 +1,72 @@ +#include "../../header/AnimationSystem/AnimationSystem.h" +#include "../../header/Global/Config.h" +#include "../../header/Global/ServiceLocator.h" +#include "../../header/AnimationSystem/AnimationService.h" + +namespace Animation +{ + using namespace Global; + using namespace UI::UIElement; + + AnimationSystem::AnimationSystem(AnimationSystemConfig config) + { + animation_system_config = config; + createUIElements(); + } + + AnimationSystem::~AnimationSystem() + { + delete(animation_image); + } + + void AnimationSystem::initialize(sf::Vector2f position) + { + animation_position = position; + current_frame = 0; + frame_time = sf::seconds(animation_system_config.frame_duration); + + initializeImage(); + } + + void AnimationSystem::createUIElements() + { + animation_image = new ImageView(); + } + + void AnimationSystem::initializeImage() + { + animation_image->initialize(Config::explosion_texture_path, 0, 0, animation_position); + animation_image->setTextureRect(sf::IntRect(0, 0, animation_system_config.tile_width, animation_system_config.tile_height)); + + animation_image->setScale(animation_system_config.sprite_sheet_width, animation_system_config.sprite_sheet_height, animation_system_config.tile_width, animation_system_config.tile_height); + } + + void AnimationSystem::update() + { + if (clock.getElapsedTime() >= frame_time) + { + if (current_frame + 1 >= animation_system_config.number_of_animation_frames) + destroy(); + + current_frame = (current_frame + 1) % animation_system_config.number_of_animation_frames; + clock.restart(); + + animation_image->setTextureRect(sf::IntRect( + current_frame * animation_system_config.tile_width, + 0, + animation_system_config.tile_width, + animation_system_config.tile_height)); + } + animation_image->update(); + } + + void AnimationSystem::render() + { + animation_image->render(); + } + + void AnimationSystem::destroy() + { + ServiceLocator::getInstance()->getAnimationService()->destroyAnimationSystem(this); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Bullet/BulletConfig.cpp b/Space-Invaders/Source/Bullet/BulletConfig.cpp new file mode 100644 index 000000000..d0fea8c16 --- /dev/null +++ b/Space-Invaders/Source/Bullet/BulletConfig.cpp @@ -0,0 +1,26 @@ +#include"../../Header/Bullet/BulletConfig.h" + +namespace Bullet +{ + const sf::String BulletConfig::laser_bullet_texture_path = "assets/textures/laser_bullet.png"; + + const sf::String BulletConfig::torpedoe_texture_path = "assets/textures/torpedoe.png"; + + const sf::String BulletConfig::frost_beam_texture_path = "assets/textures/frost_beam.png"; + + sf::String BulletConfig::getBulletTexturePath(BulletType bullet_type) + { + + switch (bullet_type) + { + case::Bullet::BulletType::LASER_BULLET: + return laser_bullet_texture_path; + + case::Bullet::BulletType::FROST_BULLET: + return frost_beam_texture_path; + + case::Bullet::BulletType::TORPEDO: + return torpedoe_texture_path; + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Bullet/BulletController.cpp b/Space-Invaders/Source/Bullet/BulletController.cpp new file mode 100644 index 000000000..ce323c613 --- /dev/null +++ b/Space-Invaders/Source/Bullet/BulletController.cpp @@ -0,0 +1,164 @@ +#include"../../Header/Bullet/BulletController.h" +#include"../../Header/Bullet/BulletView.h" +#include"../../Header/Bullet/BulletModel.h" +#include"../../Header/Bullet/BulletConfig.h" +#include"../../Header/Global/ServiceLocator.h" +#include"../../Header/Player/PlayerController.h" +#include"../../Header/Enemy/EnemyController.h" +#include"../../Header/Elements/Bunker/BunkerController.h" + + +namespace Bullet +{ + using namespace Global; + using namespace Entity; + using namespace Player; + using namespace Enemy; + using namespace Element::Bunker; + + BulletController::BulletController(BulletType bullet_type,EntityType owner_type) + { + bullet_view = new BulletView(); + bullet_model = new BulletModel(bullet_type, owner_type); + } + + BulletController::~BulletController() + { + delete(bullet_view); + delete(bullet_model); + } + + void BulletController::initialize(sf::Vector2f position, Bullet::MovementDirection direction) + { + + bullet_view->initialize(this); + bullet_model->initialize(position, direction); + } + + + void BulletController::update() + { + + updateProjectilePosition(); + bullet_view->update(); + handleOutOfBounds(); + } + + void BulletController::render() + { + + bullet_view->render(); + } + + void BulletController::moveUP() + { + + sf::Vector2f currentPosition = bullet_model->getBulletPosition(); + currentPosition.y -= bullet_model->getMovementSpeed() * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + bullet_model->setBulletPosition(currentPosition); + } + + void BulletController::moveDown() + { + + sf::Vector2f currentPosition = bullet_model->getBulletPosition(); + currentPosition.y += bullet_model->getMovementSpeed() * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + bullet_model->setBulletPosition(currentPosition); + } + + void BulletController::handleOutOfBounds() + { + sf::Vector2f bulletPosition = getProjectilePosition(); + sf::Vector2u windowSize = ServiceLocator::getInstance()->getGraphicService()->getGameWindow()->getSize(); + + if (bulletPosition.x < 0 || bulletPosition.x > windowSize.x || + bulletPosition.y < 0 || bulletPosition.y > windowSize.y) + { + ServiceLocator::getInstance()->getBulletService()->destroyBullet(this); + } + } + + sf::Vector2f BulletController::getProjectilePosition() + { + + return bullet_model->getBulletPosition(); + } + + BulletType BulletController::getBulletType() + { + + return bullet_model->getBulletType(); + } + + Entity::EntityType BulletController::getOwnerEntityType() + { + + return bullet_model->getOwnerEntityType(); + } + + const sf::Sprite& BulletController::getColliderSprite() + { + + return bullet_view->getBulletSprite(); + } + + void BulletController::onCollision(ICollider* other_collider) + { + + processPlayerCollision(other_collider); + processEnemyCollision(other_collider); + processBunkerCollision(other_collider); + processBulletCollision(other_collider); + } + + void BulletController::updateProjectilePosition() + { + + switch (bullet_model->getMovementDirection()) + { + case::Bullet::MovementDirection::UP: + moveUP(); + break; + + case::Bullet::MovementDirection::DOWN: + moveDown(); + break; + } + } + + void BulletController::processBulletCollision(ICollider* other_collider) + { + BulletController* bullet_controller = dynamic_cast(other_collider); + + if (bullet_controller) + ServiceLocator::getInstance()->getBulletService()->destroyBullet(this); + } + + void BulletController::processEnemyCollision(ICollider* other_collider) + { + EnemyController* enemy_controller = dynamic_cast(other_collider); + + if (enemy_controller && getOwnerEntityType() != EntityType::ENEMY) + { + ServiceLocator::getInstance()->getBulletService()->destroyBullet(this); + } + } + + void BulletController::processPlayerCollision(ICollider* other_collider) + { + PlayerController* player_controller = dynamic_cast(other_collider); + + if (player_controller && getOwnerEntityType() != EntityType::PLAYER) + { + ServiceLocator::getInstance()->getBulletService()->destroyBullet(this); + } + } + + void BulletController::processBunkerCollision(ICollider* other_collider) + { + BunkerController* bunker_controller = dynamic_cast(other_collider); + + if (bunker_controller) + ServiceLocator::getInstance()->getBulletService()->destroyBullet(this); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Bullet/BulletModel.cpp b/Space-Invaders/Source/Bullet/BulletModel.cpp new file mode 100644 index 000000000..9091a59fc --- /dev/null +++ b/Space-Invaders/Source/Bullet/BulletModel.cpp @@ -0,0 +1,69 @@ +#include"../../Header/Bullet/BulletModel.h" +#include"../../Header/Bullet/BulletConfig.h" + +namespace Bullet +{ + using namespace Entity; + + BulletModel::BulletModel(BulletType bullet_type,Entity::EntityType owner_type) + { + this->bullet_type = bullet_type; + this->owner_type = owner_type; + } + + BulletModel::~BulletModel() + { + + } + + void BulletModel::initialize(sf::Vector2f position, MovementDirection direction) + { + + movement_direction = direction; + bullet_position = position; + } + + sf::Vector2f BulletModel::getBulletPosition() + { + + return bullet_position; + } + + void BulletModel::setBulletPosition(sf::Vector2f position) + { + + bullet_position = position; + } + + Entity::EntityType BulletModel::getOwnerEntityType() + { + + return owner_type; + } + + BulletType BulletModel::getBulletType() + { + + return bullet_type; + } + + void BulletModel::setMovementDirection(MovementDirection direction) + { + movement_direction = direction; + } + + MovementDirection BulletModel::getMovementDirection() + { + return movement_direction; + } + + float BulletModel::getMovementSpeed() + { + return movement_speed; + } + + void BulletModel::setMovementSpeed(float speed) + { + movement_speed = speed; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Bullet/BulletService.cpp b/Space-Invaders/Source/Bullet/BulletService.cpp new file mode 100644 index 000000000..9e552436f --- /dev/null +++ b/Space-Invaders/Source/Bullet/BulletService.cpp @@ -0,0 +1,123 @@ +#include"../../Header/Bullet/BulletService.h" +#include"../../Header/Bullet/BulletController.h" +#include"../../Header/Bullet/BulletConfig.h" +#include"../../Header/Bullet/Controllers/FrostBulletController.h" +#include"../../Header/Bullet/Controllers/LaserBulletController.h" +#include"../../Header/Bullet/Controllers/TorpedoeController.h" +#include"../../Header/Collision/ICollider.h" +#include"../../Header/Global/ServiceLocator.h" + +namespace Bullet +{ + using namespace Controller; + using namespace Global; + using namespace Collision; + using namespace Entity; + using namespace Projectile; + + BulletService::BulletService() + { + + } + + BulletService::~BulletService() + { + destroy(); + } + + void BulletService::initialize() + { + projectile_list.clear(); + flagged_bullet_list.clear(); + } + + void BulletService::update() + { + for (int i = 0; i < projectile_list.size(); i++) + { + projectile_list[i]->update(); + } + } + + void BulletService::render() + { + + for (int i = 0; i < projectile_list.size(); i++) + { + projectile_list[i]->render(); + } + } + + BulletController* BulletService::createBullet(BulletType bullet_type,EntityType owner_type) + { + + switch (bullet_type) + { + case Bullet::BulletType::LASER_BULLET: + return new LaserBulletController(bullet_type,owner_type); + break; + + case Bullet::BulletType::TORPEDO: + return new TorpedoController(bullet_type, owner_type); + break; + + case Bullet::BulletType::FROST_BULLET: + return new FrostBulletController(bullet_type, owner_type); + break; + + } + } + + bool BulletService::isValidBullet(int index_i, std::vector& bullet_list) + { + + return index_i >= 0 && index_i < bullet_list.size() && bullet_list[index_i] != nullptr; + + } + + void BulletService::destroyFlaggedBullets() + { + + for (int i = 0; i < flagged_bullet_list.size(); i++) + { + if (!isValidBullet(i, flagged_bullet_list)) continue; + + ServiceLocator::getInstance()->getCollisionService()->removeCollider(dynamic_cast(flagged_bullet_list[i])); + delete (flagged_bullet_list[i]); + } + flagged_bullet_list.clear(); + } + + void BulletService::destroy() + { + for (int i= 0; i < flagged_bullet_list.size(); i++) + { + delete(projectile_list[i]); + } + } + + BulletController* BulletService::spawnBullet(BulletType bullet_type,EntityType owner_type, sf::Vector2f position, MovementDirection direction) + { + + BulletController* bullet_controller = createBullet(bullet_type,owner_type); + bullet_controller->initialize(position, direction); + + ServiceLocator::getInstance()->getCollisionService()->addCollider(dynamic_cast(bullet_controller)); + projectile_list.push_back(bullet_controller); + return bullet_controller; + } + + void BulletService::destroyBullet(BulletController* bullet_controller) + { + if (std::find(flagged_bullet_list.begin(), flagged_bullet_list.end(), bullet_controller) == flagged_bullet_list.end()) + { + //flagged_bullet_list.push_back(bullet_controller); + //projectile_list.erase(std::remove(projectile_list.begin(), projectile_list.end(), bullet_controller), projectile_list.end()); + } + } + + void BulletService::reset() + { + destroy(); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Bullet/BulletView.cpp b/Space-Invaders/Source/Bullet/BulletView.cpp new file mode 100644 index 000000000..39dddd78f --- /dev/null +++ b/Space-Invaders/Source/Bullet/BulletView.cpp @@ -0,0 +1,83 @@ +#include"../../Header/Bullet/BulletView.h" +#include"../../Header/Bullet/BulletController.h" +#include"../../Header/Global/ServiceLocator.h" +#include"../../Header/Global/Config.h" +#include"../../Header/Bullet/BulletConfig.h" + +namespace Bullet +{ + using namespace Global; + using namespace UI::UIElement; + + BulletView::BulletView() + { + + createUIElements(); + } + + BulletView::~BulletView() + { + destroy(); + } + + void BulletView::initialize(BulletController* controller) + { + + bullet_controller = controller; + initializeImage(); + } + + void BulletView::createUIElements() + { + + bullet_image = new ImageView(); + } + + void BulletView::initializeImage() + { + + bullet_image->initialize(getBulletTexturePath(), bullet_sprite_width, bullet_sprite_height, bullet_controller->getProjectilePosition()); + } + + void BulletView::update() + { + + bullet_image->setPosition(bullet_controller->getProjectilePosition()); + bullet_image->update(); + } + + void BulletView::render() + { + + bullet_image->render(); + } + + sf::String BulletView::getBulletTexturePath() + { + + switch (bullet_controller->getBulletType()) + { + case::Bullet::BulletType::LASER_BULLET: + return Config::laser_bullet_texture_path; + + case::Bullet::BulletType::FROST_BULLET: + return Config::frost_beam_texture_path; + + case::Bullet::BulletType::TORPEDO: + return Config::torpedoe_texture_path; + + } + } + + const sf::Sprite& BulletView::getBulletSprite() + { + + return bullet_image->getSprite(); + } + + void BulletView::destroy() + { + + delete(bullet_image); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Bullet/Controllers/FrostBulletController.cpp b/Space-Invaders/Source/Bullet/Controllers/FrostBulletController.cpp new file mode 100644 index 000000000..a7489587f --- /dev/null +++ b/Space-Invaders/Source/Bullet/Controllers/FrostBulletController.cpp @@ -0,0 +1,24 @@ +#include"../../Header/Bullet/Controllers/FrostBulletController.h" +#include"../../Header/Bullet/BulletModel.h" + +namespace Bullet +{ + namespace Controller + { + FrostBulletController::FrostBulletController(BulletType bullet_type, Entity::EntityType owner_type) :BulletController(bullet_type,owner_type) + { + + } + + FrostBulletController::~FrostBulletController() + { + + } + + void FrostBulletController::initialize(sf::Vector2f position, MovementDirection direction) + { + BulletController::initialize(position, direction); + bullet_model->setMovementSpeed(frost_bullet_movement_speed); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Bullet/Controllers/LaserBulletController.cpp b/Space-Invaders/Source/Bullet/Controllers/LaserBulletController.cpp new file mode 100644 index 000000000..3dc427c36 --- /dev/null +++ b/Space-Invaders/Source/Bullet/Controllers/LaserBulletController.cpp @@ -0,0 +1,22 @@ +#include"../../Header/Bullet/Controllers/LaserBulletController.h" + +namespace Bullet +{ + namespace Controller + { + LaserBulletController::LaserBulletController(BulletType bullet_type, Entity::EntityType owner_type):BulletController(bullet_type,owner_type) + { + + } + + LaserBulletController::~LaserBulletController() + { + + } + + void LaserBulletController::initialize(sf::Vector2f position, MovementDirection direction) + { + BulletController::initialize(position, direction); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Bullet/Controllers/TorpedoeController.cpp b/Space-Invaders/Source/Bullet/Controllers/TorpedoeController.cpp new file mode 100644 index 000000000..a9b53e77b --- /dev/null +++ b/Space-Invaders/Source/Bullet/Controllers/TorpedoeController.cpp @@ -0,0 +1,24 @@ +#include"../../Header/Bullet/Controllers/TorpedoeController.h" +#include"../../Header/Bullet/BulletModel.h" + +namespace Bullet +{ + namespace Controller + { + TorpedoController::TorpedoController(BulletType bullet_type, Entity::EntityType owner_type) :BulletController(bullet_type,owner_type) + { + + } + + TorpedoController::~TorpedoController() + { + + } + + void TorpedoController::initialize(sf::Vector2f position, MovementDirection direction) + { + BulletController::initialize(position, direction); + bullet_model->setMovementSpeed(torpedo_movement_speed); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Collision/CollisionService.cpp b/Space-Invaders/Source/Collision/CollisionService.cpp new file mode 100644 index 000000000..5bd50c424 --- /dev/null +++ b/Space-Invaders/Source/Collision/CollisionService.cpp @@ -0,0 +1,76 @@ +#include"../../Header/Collision/CollisionService.h" +#include"../../Header/Collision/ICollider.h" + +namespace Collision +{ + CollisionService::CollisionService() + { + + } + + CollisionService::~CollisionService() + { + + } + + void CollisionService::initialize() + { + + } + + void CollisionService::update() + { + processCollision(); + } + + void CollisionService::processCollision() + { + for (int i= 0; i < collider_list.size(); i++) + { + for (int j = i ; j < collider_list.size(); j++) + { + doCollision(i, j); + } + } + } + + void CollisionService::doCollision(int index_i, int index_j) + { + if (collider_list[index_i]->getCollisionState() == CollisionState::DISABLED || + collider_list[index_j]->getCollisionState() == CollisionState::DISABLED)return; + + if (hasCollisionOccured(index_i, index_j)) + { + if (areActiveColliders(index_i, index_j)) + collider_list[index_i]->onCollision(collider_list[index_j]); + + if (areActiveColliders(index_i, index_j)) + collider_list[index_j]->onCollision(collider_list[index_i]); + } + } + + bool CollisionService::hasCollisionOccured(int index_i, int index_j) + { + const sf::Sprite& collider_one_sprite = collider_list[index_i]->getColliderSprite(); + const sf::Sprite& collider_two_sprite = collider_list[index_j]->getColliderSprite(); + + return collider_one_sprite.getGlobalBounds().intersects(collider_two_sprite.getGlobalBounds()); + } + + bool CollisionService::areActiveColliders(int index_i, int index_j) + { + return(index_i < collider_list.size() && index_j < collider_list.size() && + collider_list[index_i] != nullptr && collider_list[index_j] != nullptr); + } + + void CollisionService::addCollider(ICollider* collider) + { + collider_list.push_back(collider); + } + + void CollisionService::removeCollider(ICollider* collider) + { + collider_list.erase(std::remove(collider_list.begin(), collider_list.end(), collider), collider_list.end()); + } + +} \ No newline at end of file diff --git a/Space-Invaders/Source/Collision/ICollider.cpp b/Space-Invaders/Source/Collision/ICollider.cpp new file mode 100644 index 000000000..e0be639b3 --- /dev/null +++ b/Space-Invaders/Source/Collision/ICollider.cpp @@ -0,0 +1,29 @@ +#include"../../Header/Collision/ICollider.h" + +namespace Collision +{ + ICollider::ICollider() + { + collision_state = CollisionState::ENABLED; + } + + ICollider::~ICollider() + { + + } + + void ICollider::enableCollision() + { + collision_state = CollisionState::ENABLED; + } + + void ICollider::disableCollision() + { + collision_state = CollisionState::DISABLED; + } + + CollisionState ICollider::getCollisionState() + { + return collision_state; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/ElementService/Bunker/BunkerController.cpp b/Space-Invaders/Source/ElementService/Bunker/BunkerController.cpp new file mode 100644 index 000000000..78fe3b04d --- /dev/null +++ b/Space-Invaders/Source/ElementService/Bunker/BunkerController.cpp @@ -0,0 +1,62 @@ +#include"../../Header/Elements/Bunker/BunkerController.h" +#include"../../Header/Elements/Bunker/BunkerView.h" +#include "../../../Header/Bullet/BulletController.h" +#include "../../../Header/Entity/EntityConfig.h" +#include "../../Header/Global/ServiceLocator.h" +#include "../../Header/Bullet/BulletConfig.h" + +namespace Element +{ + namespace Bunker + { + using namespace Bullet; + using namespace Entity; + using namespace Global; + + BunkerController::BunkerController() + { + bunker_view = new BunkerView(); + } + + BunkerController::~BunkerController() + { + delete(bunker_view); + } + + void BunkerController::initialize(BunkerData data) + { + bunker_data = data; + bunker_view->initialize(this); + } + + void BunkerController::update() + { + bunker_view->update(); + } + + void BunkerController::render() + { + bunker_view->render(); + } + + const sf::Sprite& BunkerController::getColliderSprite() + { + return bunker_view->getBunkerSprite(); + } + + void BunkerController::onCollision(ICollider* other_collider) + { + BulletController* bullet_controller = dynamic_cast(other_collider); + + if (bullet_controller && bullet_controller->getBulletType() == BulletType::TORPEDO) + { + ServiceLocator::getInstance()->getElementService()->destroyBunker(this); + } + } + + sf::Vector2f BunkerController::getBunkerPosition() + { + return bunker_data.position; + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/ElementService/Bunker/BunkerModel.cpp b/Space-Invaders/Source/ElementService/Bunker/BunkerModel.cpp new file mode 100644 index 000000000..b3a81df5b --- /dev/null +++ b/Space-Invaders/Source/ElementService/Bunker/BunkerModel.cpp @@ -0,0 +1,17 @@ +#include"../../Header/Elements/Bunker/BunkerModel.h" + +namespace Element +{ + namespace Bunker + { + BunkerData::BunkerData() + { + + }; + + BunkerData::BunkerData(sf::Vector2f position) + { + this->position = position; + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/ElementService/Bunker/BunkerView.cpp b/Space-Invaders/Source/ElementService/Bunker/BunkerView.cpp new file mode 100644 index 000000000..9e50e30f0 --- /dev/null +++ b/Space-Invaders/Source/ElementService/Bunker/BunkerView.cpp @@ -0,0 +1,62 @@ +#include"../../Header/Elements/Bunker/BunkerView.h" +#include"../../Header/Global/ServiceLocator.h" +#include"../../Header/Graphic/GraphicService.h" +#include"../../Header/Elements/Bunker/BunkerController.h" +#include"../../Header/Global/Config.h" + +namespace Element +{ + namespace Bunker + { + using namespace Global; + using namespace UI::UIElement; + using namespace Graphic; + + BunkerView::BunkerView() + { + createUIElements(); + } + + BunkerView::~BunkerView() + { + destroy(); + } + + void BunkerView::initialize(BunkerController* controller) + { + bunker_controller = controller; + initializeImage(); + } + + void BunkerView::createUIElements() + { + bunker_image = new ImageView(); + } + + void BunkerView::initializeImage() + { + bunker_image->initialize(Config::bunker_texture_path, bunker_sprite_width, bunker_sprite_height, bunker_controller->getBunkerPosition()); + } + + void BunkerView::update() + { + bunker_image->update(); + } + + void BunkerView::render() + { + bunker_image->render(); + } + + const sf::Sprite& BunkerView::getBunkerSprite() + { + return bunker_image->getSprite(); + } + + void BunkerView::destroy() + { + delete(bunker_image); + } + + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/ElementService/ElementService.cpp b/Space-Invaders/Source/ElementService/ElementService.cpp new file mode 100644 index 000000000..3b41037f2 --- /dev/null +++ b/Space-Invaders/Source/ElementService/ElementService.cpp @@ -0,0 +1,84 @@ +#include"../../Header/Elements/ElementService.h" +#include"../../Header/Global/ServiceLocator.h" +#include"../../Header/Collision/ICollider.h" + +namespace Element +{ + using namespace Bunker; + using namespace Global; + using namespace Collision; + + ElementService::ElementService() + { + + } + + ElementService::~ElementService() + { + destroy(); + } + + void ElementService::initialize() + { + spawnBunkers(); + } + + void ElementService::update() + { + for (Bunker::BunkerController* bunker : bunker_list) + bunker->update(); + + destroyFlaggedBunkers(); + } + + void ElementService::render() + { + for (Bunker::BunkerController* bunker : bunker_list) + bunker->render(); + } + + void ElementService::spawnBunkers() + { + for (int i = 0; i < bunker_data_list.size(); i++) + { + Bunker::BunkerController* bunker_controller = new Bunker::BunkerController(); + + bunker_controller->initialize(bunker_data_list[i]); + bunker_list.push_back(bunker_controller); + + ServiceLocator::getInstance()->getCollisionService()->addCollider(dynamic_cast(bunker_controller)); + } + } + + void ElementService::destroyBunker(Bunker::BunkerController* bunker_controller) + { + flagged_bunker_list.push_back(bunker_controller); + bunker_list.erase(std::remove(bunker_list.begin(), bunker_list.end(), bunker_controller), bunker_list.end()); + } + + void ElementService::destroyFlaggedBunkers() + { + for (int i = 0; i < flagged_bunker_list.size(); i++) + { + ServiceLocator::getInstance()->getCollisionService()->removeCollider(dynamic_cast(flagged_bunker_list[i])); + delete (flagged_bunker_list[i]); + } + flagged_bunker_list.clear(); + } + + void ElementService::destroy() + { + for (int i = 0; i < bunker_list.size(); i++) + { + ServiceLocator::getInstance()->getCollisionService()->removeCollider(dynamic_cast(bunker_list[i])); + delete(bunker_list[i]); + } + bunker_list.clear(); + } + + void ElementService::reset() + { + destroy(); + spawnBunkers(); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Enemy/Controllers/SubZeroController.cpp b/Space-Invaders/Source/Enemy/Controllers/SubZeroController.cpp new file mode 100644 index 000000000..f6d62c3df --- /dev/null +++ b/Space-Invaders/Source/Enemy/Controllers/SubZeroController.cpp @@ -0,0 +1,67 @@ +#include "../../Header/Enemy/Controllers/SubZeroController.h" +#include "../../Header/Enemy/EnemyModel.h" +#include"../../Header/Enemy/EnemyView.h" +#include "../../header/Enemy/EnemyConfig.h" +#include "../../Header/Global/ServiceLocator.h" +#include"../../Header/Bullet/BulletConfig.h" +#include"../../Header/Entity/EntityConfig.h" + +namespace Enemy +{ + + using namespace Global; + using namespace Bullet; + using namespace Time; + + namespace Controller + { + SubzeroController::SubzeroController(EnemyType type) :EnemyController(type) + { + + } + + SubzeroController::~SubzeroController() + { + + } + + void SubzeroController::initialize() + { + EnemyController::initialize(); + enemy_model->setMovementDirection(MovementDirection::DOWN); + + rate_of_fire = subzero_rate_of_fire; + vertical_movement_speed = subzero_vertical_movement_speed; + } + + void SubzeroController::fireBullet() + { + ServiceLocator::getInstance()->getBulletService()->spawnBullet(BulletType::FROST_BULLET,enemy_model->getOwnerEntityType(), + enemy_model->getEnemyPosition() + enemy_model->barrel_position_offset, + Bullet::MovementDirection::DOWN); + } + + void SubzeroController::move() + { + switch (enemy_model->getMovementDirection()) + { + case::Enemy::MovementDirection::DOWN: + moveDown(); + break; + } + } + + void SubzeroController::moveDown() + { + sf::Vector2f currentPosition = enemy_model->getEnemyPosition(); + currentPosition.y += vertical_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + enemy_model->setEnemyPosition(currentPosition); + } + + void SubzeroController::destroy() + { + EnemyController::destroy(); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Enemy/Controllers/ThunderSnakeController.cpp b/Space-Invaders/Source/Enemy/Controllers/ThunderSnakeController.cpp new file mode 100644 index 000000000..e4abf3755 --- /dev/null +++ b/Space-Invaders/Source/Enemy/Controllers/ThunderSnakeController.cpp @@ -0,0 +1,96 @@ +#include"../../Header/Enemy/Controllers/ThunderSnakeController.h" +#include"../../Header/Enemy/EnemyModel.h" +#include"../../Header/Enemy/EnemyConfig.h" +#include"../../Header/Global/ServiceLocator.h" +#include"../../Header/Bullet/BulletConfig.h" +#include"../../Header/Entity/EntityConfig.h" + +namespace Enemy +{ + using namespace Global; + using namespace Bullet; + using namespace Time; + + namespace Controller + { + ThunderSnakeController::ThunderSnakeController(EnemyType type) : EnemyController(type) + { + + } + + ThunderSnakeController::~ThunderSnakeController() + { + + } + + void ThunderSnakeController::initialize() + { + EnemyController::initialize(); + rate_of_fire = thundersnake_rate_of_fire; + } + + void ThunderSnakeController::fireBullet() + { + ServiceLocator::getInstance()->getBulletService()->spawnBullet(BulletType::TORPEDO,enemy_model->getOwnerEntityType(), + enemy_model->getEnemyPosition() + enemy_model->barrel_position_offset, + Bullet::MovementDirection::DOWN); + } + + + void ThunderSnakeController::move() + { + switch (enemy_model->getMovementDirection()) + { + case::Enemy::MovementDirection::LEFT: + moveLeft(); + break; + + case::Enemy::MovementDirection::RIGHT: + moveRight(); + break; + } + } + + void ThunderSnakeController::moveLeft() + { + sf::Vector2f currentPosition = enemy_model->getEnemyPosition(); + currentPosition.y += thundersnake_vertical_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + currentPosition.x -= thundersnake_horizontal_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + if (currentPosition.x <= enemy_model->left_most_position.x) + { + enemy_model->setMovementDirection(MovementDirection::RIGHT); + } + else + { + enemy_model->setEnemyPosition(currentPosition); + } + + } + + + void ThunderSnakeController::moveRight() + { + sf::Vector2f currentPosition = enemy_model->getEnemyPosition(); + currentPosition.y += thundersnake_vertical_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + currentPosition.x += thundersnake_horizontal_movement_speed* ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + if (currentPosition.x >= enemy_model->right_most_position.x) + { + enemy_model->setMovementDirection(MovementDirection::LEFT); + } + else + { + enemy_model->setEnemyPosition(currentPosition); + } + + } + + void ThunderSnakeController::destroy() + { + + EnemyController::destroy(); + } + } +} + diff --git a/Space-Invaders/Source/Enemy/Controllers/UFOController.cpp b/Space-Invaders/Source/Enemy/Controllers/UFOController.cpp new file mode 100644 index 000000000..5c30abab3 --- /dev/null +++ b/Space-Invaders/Source/Enemy/Controllers/UFOController.cpp @@ -0,0 +1,112 @@ +#include"../../Header/Enemy/Controllers/UFOController.h" +#include"../../Header/Enemy/EnemyConfig.h" +#include"../../Header/Enemy/EnemyModel.h" +#include"../../Header/Enemy/EnemyView.h" +#include"../../Header/Global/ServiceLocator.h" +#include"../../Header/Bullet/BulletController.h" +#include"../../Header/Entity/EntityConfig.h" +#include"../../Header/Collision/ICollider.h" +#include"../../Header/Bullet/BulletConfig.h" + +namespace Enemy +{ + using namespace Global; + using namespace Bullet; + using namespace Entity; + using namespace Time; + + namespace Controller + { + UFOController::UFOController(EnemyType type) : EnemyController(type) + { + + } + + UFOController::~UFOController() + { + + } + + void UFOController::initialize() + { + EnemyController::initialize(); + } + + void UFOController::fireBullet() + { + + } + + Powerup::PowerupType UFOController::getRandomPowerupType() + { + std::srand(static_cast(std::time(nullptr))); + + int random_value = std::rand() % (static_cast(Powerup::PowerupType::OUTSCAL_BOMB) + 1); + return static_cast(random_value); + } + + void UFOController::move() + { + switch (enemy_model->getMovementDirection()) + { + case::Enemy::MovementDirection::LEFT: + moveLeft(); + break; + + case::Enemy::MovementDirection::RIGHT: + moveRight(); + break; + } + } + + void UFOController::moveLeft() + { + sf::Vector2f currentposition = enemy_model->getEnemyPosition(); + + currentposition.x -= horizontal_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + if (currentposition.x <= enemy_model -> left_most_position.x) + { + enemy_model->setMovementDirection(MovementDirection::RIGHT); + } + else + { + enemy_model->setEnemyPosition(currentposition); + } + } + + void UFOController::moveRight() + { + sf::Vector2f currentposition = enemy_model->getEnemyPosition(); + + currentposition.x += horizontal_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + if (currentposition.x >= enemy_model->right_most_position.x) + { + enemy_model->setMovementDirection(MovementDirection::LEFT); + } + else + { + enemy_model->setEnemyPosition(currentposition); + } + } + + void UFOController::onCollision(ICollider* other_collider) + { + EnemyController::onCollision(other_collider); + BulletController* bullet_controller = dynamic_cast(other_collider); + + if (bullet_controller && bullet_controller->getOwnerEntityType() != EntityType::ENEMY) + { + ServiceLocator::getInstance()->getPowerupService()->spawnPowerup(getRandomPowerupType(), enemy_model->getEnemyPosition()); + return; + } + } + + void UFOController::destroy() + { + + EnemyController::destroy(); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Enemy/Controllers/ZapperController.cpp b/Space-Invaders/Source/Enemy/Controllers/ZapperController.cpp new file mode 100644 index 000000000..031379333 --- /dev/null +++ b/Space-Invaders/Source/Enemy/Controllers/ZapperController.cpp @@ -0,0 +1,139 @@ +#include "../../Header/Enemy/Controllers/ZapperController.h" +#include "../../Header/Enemy/EnemyModel.h" +#include "../../Header/Enemy/EnemyConfig.h" +#include"../../Header/Enemy/EnemyView.h" +#include "../../Header/Global/ServiceLocator.h" +#include"../../Header/Bullet/BulletConfig.h" + + +namespace Enemy +{ + using namespace Global; + using namespace Bullet; + using namespace Bullet; + + namespace Controller + { + ZapperController::ZapperController(EnemyType type) : EnemyController(type) { } + + ZapperController::~ZapperController() { } + + void ZapperController::initialize() + { + EnemyController::initialize(); + + } + + void ZapperController::fireBullet() + { + ServiceLocator::getInstance()->getBulletService()->spawnBullet(BulletType::LASER_BULLET,enemy_model->getOwnerEntityType(), + enemy_model->getEnemyPosition() + enemy_model->barrel_position_offset, + Bullet::MovementDirection::DOWN); + } + + void ZapperController::move() + { + + switch (enemy_model->getMovementDirection()) + { + + case::Enemy::MovementDirection::LEFT: + moveLeft(); + break; + + + case::Enemy::MovementDirection::RIGHT: + moveRight(); + break; + + + case::Enemy::MovementDirection::DOWN: + moveDown(); + break; + } + } + + + void ZapperController::moveLeft() + { + + sf::Vector2f currentPosition = enemy_model->getEnemyPosition(); + + + currentPosition.x -= horizontal_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + + if (currentPosition.x <= enemy_model->left_most_position.x) + { + + enemy_model->setMovementDirection(MovementDirection::DOWN); + enemy_model->setReferencePosition(currentPosition); + } + else + { + + enemy_model->setEnemyPosition(currentPosition); + } + } + + + void ZapperController::moveRight() + { + + sf::Vector2f currentPosition = enemy_model->getEnemyPosition(); + + + currentPosition.x += horizontal_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + + if (currentPosition.x >= enemy_model->right_most_position.x) + { + + enemy_model->setMovementDirection(MovementDirection::DOWN); + enemy_model->setReferencePosition(currentPosition); + } + else + { + + enemy_model->setEnemyPosition(currentPosition); + } + } + + + void ZapperController::moveDown() + { + + sf::Vector2f currentPosition = enemy_model->getEnemyPosition(); + + + currentPosition.y += horizontal_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + + if (currentPosition.y >= enemy_model->getReferencePosition().y + vertical_movement_speed) + { + + if (enemy_model->getReferencePosition().x <= enemy_model->left_most_position.x) + { + + enemy_model->setMovementDirection(MovementDirection::RIGHT); + } + else + { + + enemy_model->setMovementDirection(MovementDirection::LEFT); + } + } + else + { + + enemy_model->setEnemyPosition(currentPosition); + } + } + + void ZapperController::destroy() + { + + EnemyController::destroy(); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Enemy/EnemyController.cpp b/Space-Invaders/Source/Enemy/EnemyController.cpp new file mode 100644 index 000000000..4efc89131 --- /dev/null +++ b/Space-Invaders/Source/Enemy/EnemyController.cpp @@ -0,0 +1,129 @@ +#include "../../Header/Enemy/EnemyController.h" +#include "../../Header/Enemy/EnemyView.h" +#include "../../Header/Enemy/EnemyModel.h" +#include"../../Header/Enemy/EnemyConfig.h" +#include "../../Header/Global/ServiceLocator.h" +#include "../../Header/Enemy/Controllers/SubZeroController.h" +#include"../../Header/Enemy/Controllers/ZapperController.h" +#include"../../Header/Enemy/Controllers/ThunderSnakeController.h" +#include"../../Header/Bullet/BulletConfig.h" +#include"../../Header/Entity/EntityConfig.h" +#include"../../Header/Bullet/BulletController.h" +#include"../../Header/Player/PlayerController.h" +#include"../../Header/Sound/SoundService.h" + +namespace Enemy +{ + using namespace Global; + using namespace Time; + using namespace Bullet; + using namespace Entity; + using namespace Collision; + using namespace Player; + using namespace Sound; + + EnemyController::EnemyController(EnemyType type) + { + enemy_view = new EnemyView(); + enemy_model = new EnemyModel(type); + } + + EnemyController::~EnemyController() + { + delete (enemy_view); + delete (enemy_model); + } + + void EnemyController::initialize() + { + enemy_model->initialize(); + enemy_model->setEnemyPosition(getRandomInitialPosition()); + enemy_view->initialize(this); + } + + void EnemyController::update() + { + move(); + updateFireTimer(); + processBulletFire(); + enemy_view->update(); + } + + void EnemyController::render() + { + enemy_view->render(); + } + + void EnemyController::updateFireTimer() + { + elapsed_fire_duration += ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + } + + void EnemyController::processBulletFire() + { + if (elapsed_fire_duration >= rate_of_fire) + { + fireBullet(); + elapsed_fire_duration = 0.f; + } + } + + sf::Vector2f EnemyController::getRandomInitialPosition() + { + float x_offset_distance = (std::rand() % static_cast(enemy_model->right_most_position.x - enemy_model->left_most_position.x)); + + float x_position = enemy_model->left_most_position.x + x_offset_distance; + + float y_position = enemy_model->left_most_position.y; + + return sf::Vector2f(x_position, y_position); + } + + + sf::Vector2f EnemyController::getEnemyPosition() + { + return enemy_model->getEnemyPosition(); + } + + EnemyState EnemyController::getEnemyState() + { + return enemy_model->getEnemyState(); + } + + EnemyType EnemyController::getEnemyType() + { + return enemy_model->getEnemyType(); + } + + const sf::Sprite& EnemyController::getColliderSprite() + { + return enemy_view->getEnemySprite(); + } + + void EnemyController::onCollision(ICollider* other_collider) + { + BulletController* bullet_controller = dynamic_cast(other_collider); + if (bullet_controller && bullet_controller->getOwnerEntityType() != EntityType::ENEMY) + { + destroy(); + return; + } + + PlayerController* player_controller = dynamic_cast(other_collider); + if (player_controller) + { + destroy(); + return; + } + } + + void EnemyController::destroy() + { + ServiceLocator::getInstance()->getAnimationService()->spawnAnimationSystem(enemy_model->getEnemyPosition(), + Animation::AnimationType::EXPLOSION); + + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::EXPLOSION); + ServiceLocator::getInstance()->getPlayerService()->increaseEnemiesKilled(1); + ServiceLocator::getInstance()->getEnemyService()->destroyEnemy(this); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Enemy/EnemyModel.cpp b/Space-Invaders/Source/Enemy/EnemyModel.cpp new file mode 100644 index 000000000..bdd0902c5 --- /dev/null +++ b/Space-Invaders/Source/Enemy/EnemyModel.cpp @@ -0,0 +1,76 @@ +#include "../../Header/Enemy/EnemyModel.h" +#include "../../Header/Enemy/EnemyConfig.h" + +namespace Enemy +{ + EnemyModel::EnemyModel(EnemyType type) { + + enemy_type = type; + owner_type = Entity::EntityType::ENEMY; + + } + + EnemyModel::~EnemyModel() { } + + void EnemyModel::initialize() + { + enemy_state = EnemyState::PATROLLING; + movement_direction = MovementDirection::RIGHT; + enemy_position = reference_position; + } + + sf::Vector2f EnemyModel::getEnemyPosition() + { + return enemy_position; + } + + void EnemyModel::setEnemyPosition(sf::Vector2f position) + { + enemy_position = position; + } + + sf::Vector2f EnemyModel::getReferencePosition() + { + return reference_position; + } + + void EnemyModel::setReferencePosition(sf::Vector2f position) + { + reference_position = position; + } + + EnemyState EnemyModel::getEnemyState() + { + return enemy_state; + } + + void EnemyModel::setEnemyState(EnemyState state) + { + enemy_state = state; + } + + EnemyType EnemyModel::getEnemyType() + { + return enemy_type; + } + + void EnemyModel::setEnemyType(EnemyType type) + { + enemy_type = type; + } + + Entity::EntityType EnemyModel::getOwnerEntityType() + { + return owner_type; + } + + MovementDirection EnemyModel::getMovementDirection() + { + return movement_direction; + } + + void EnemyModel::setMovementDirection(MovementDirection direction) + { + movement_direction = direction; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Enemy/EnemyService.cpp b/Space-Invaders/Source/Enemy/EnemyService.cpp new file mode 100644 index 000000000..6604065bf --- /dev/null +++ b/Space-Invaders/Source/Enemy/EnemyService.cpp @@ -0,0 +1,133 @@ +#include "../../Header/Enemy/EnemyService.h" +#include "../../Header/Enemy/EnemyController.h" +#include "../../Header/Global/ServiceLocator.h" +#include "../../Header/Time/TimeService.h" +#include "../../Header/Enemy/EnemyConfig.h" +#include "../../Header/Enemy/Controllers/SubZeroController.h" +#include"../../Header/Enemy/Controllers/ZapperController.h" +#include"../../Header/Enemy/Controllers/ThunderSnakeController.h" +#include"../../Header/Enemy/Controllers/UFOController.h" +#include"../../Header/Collision/ICollider.h" + +namespace Enemy +{ + using namespace Global; + using namespace Time; + using namespace Controller; + using namespace Collision; + + EnemyService::EnemyService() + { + std::srand(static_cast(std::time(nullptr))); + } + + EnemyService::~EnemyService() + { + destroy(); + } + + void EnemyService::initialize() + { + spawn_timer = spawn_interval; + } + + void EnemyService::update() + { + updateSpawnTimer(); + processEnemySpawn(); + + for (EnemyController* enemy : enemy_list) + enemy->update(); + + destroyFlaggedEnemies(); + } + + void EnemyService::render() + { + for (EnemyController* enemy : enemy_list) + enemy->render(); + } + + void EnemyService::updateSpawnTimer() + { + spawn_timer += ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + } + + void EnemyService::processEnemySpawn() + { + if (spawn_timer >= spawn_interval) + { + spawnEnemy(); + spawn_timer = 0.0f; + } + } + + EnemyType EnemyService::getRandomEnemyType() + { + int randomType = std::rand() % 4; + return static_cast(randomType); + } + + EnemyController* EnemyService::spawnEnemy() + { + EnemyController* enemy_controller = createEnemy(getRandomEnemyType()); + enemy_controller->initialize(); + + ServiceLocator::getInstance()->getCollisionService()->addCollider(dynamic_cast(enemy_controller)); + enemy_list.push_back(enemy_controller); + return enemy_controller; + } + + EnemyController* EnemyService::createEnemy(EnemyType enemy_type) + { + switch (enemy_type) + { + case::Enemy::EnemyType::ZAPPER: + return new ZapperController(Enemy::EnemyType::ZAPPER); + + case::Enemy::EnemyType::SUBZERO: + return new SubzeroController(Enemy::EnemyType::SUBZERO); + + case::Enemy::EnemyType::THUNDER_SNAKE: + return new ThunderSnakeController(Enemy::EnemyType::THUNDER_SNAKE); + + case::Enemy::EnemyType::UFO: + return new UFOController(Enemy::EnemyType::UFO); + } + } + + void EnemyService::destroyFlaggedEnemies() + { + for (int i = 0; i < flagged_enemy_list.size(); i++) + { + ServiceLocator::getInstance()->getCollisionService()->removeCollider(dynamic_cast(flagged_enemy_list[i])); + delete (flagged_enemy_list[i]); + } + flagged_enemy_list.clear(); + } + + + void EnemyService::destroyEnemy(EnemyController* enemy_controller) + { + dynamic_cast(enemy_controller)->disableCollision(); + flagged_enemy_list.push_back(enemy_controller); + enemy_list.erase(std::remove(enemy_list.begin(), enemy_list.end(), enemy_controller), enemy_list.end()); + } + + void EnemyService::destroy() + { + for (int i = 0; i < enemy_list.size(); i++) + { + ServiceLocator::getInstance()->getCollisionService()->removeCollider(dynamic_cast(enemy_list[i])); + delete (enemy_list[i]); + } + enemy_list.clear(); + } + + void EnemyService::reset() + { + destroy(); + spawn_timer = 0.f; + } + +} \ No newline at end of file diff --git a/Space-Invaders/Source/Enemy/EnemyView.cpp b/Space-Invaders/Source/Enemy/EnemyView.cpp new file mode 100644 index 000000000..1b7483886 --- /dev/null +++ b/Space-Invaders/Source/Enemy/EnemyView.cpp @@ -0,0 +1,81 @@ +#include "../../Header/Enemy/EnemyView.h" +#include "../../Header/Global/ServiceLocator.h" +#include "../../Header/Graphic/GraphicService.h" +#include "../../Header/Enemy/EnemyController.h" +#include"../../Header/Enemy/EnemyConfig.h" +#include"../../Header/Global/Config.h" + +namespace Enemy +{ + using namespace Global; + using namespace Graphic; + using namespace UI::UIElement; + + + EnemyView::EnemyView() + { + createUIElements(); + } + + EnemyView::~EnemyView() + { + destroy(); + } + + void EnemyView::initialize(EnemyController* controller) + { + enemy_controller = controller; + initializeImage(); + } + + void EnemyView::createUIElements() + { + enemy_image = new ImageView(); + } + + void EnemyView::initializeImage() + { + enemy_image->initialize(getEnemyTexturePath(), enemy_sprite_width, enemy_sprite_height, enemy_controller->getEnemyPosition()); + } + + void EnemyView::update() + { + enemy_image->setPosition(enemy_controller->getEnemyPosition()); + enemy_image->update(); + } + + void EnemyView::render() + { + enemy_image->render(); + } + + const sf::Sprite& EnemyView::getEnemySprite() + { + return enemy_image->getSprite(); + } + + sf::String EnemyView::getEnemyTexturePath() + { + switch (enemy_controller->getEnemyType()) + { + case::Enemy::EnemyType::SUBZERO: + return Config::subzero_texture_path; + + case::Enemy::EnemyType::ZAPPER: + return Config::zapper_texture_path; + + case::Enemy::EnemyType::THUNDER_SNAKE: + return Config::thunder_snake_texture_path; + + case::Enemy::EnemyType::UFO: + return Config::ufo_texture_path; + } + } + + + void EnemyView::destroy() + { + delete(enemy_image); + } + +} diff --git a/Space-Invaders/Source/Event/EventService.cpp b/Space-Invaders/Source/Event/EventService.cpp new file mode 100644 index 000000000..8270c6bf6 --- /dev/null +++ b/Space-Invaders/Source/Event/EventService.cpp @@ -0,0 +1,139 @@ +#include "../../Header/Event/EventService.h" +#include "../../Header/Main/GameService.h" +#include "../../Header/Graphic/GraphicService.h" +#include "../../Header/Global/ServiceLocator.h" + +namespace Event +{ + using namespace Global; + EventService::EventService() + { + game_window = nullptr; + } + + EventService::~EventService() = default; + + void EventService::initialize() + { + game_window = ServiceLocator::getInstance()->getGraphicService()->getGameWindow(); + + } + + void EventService::update() + { + updateMouseButtonState(left_mouse_button_state, sf::Mouse::Left); + updateMouseButtonState(right_mouse_button_state, sf::Mouse::Right); + updateKeyboardButtonState(left_arrow_button_state, sf::Keyboard::Left); + updateKeyboardButtonState(right_arrow_button_state, sf::Keyboard::Right); + updateKeyboardButtonState(A_button_state, sf::Keyboard::A); + updateKeyboardButtonState(D_button_state, sf::Keyboard::D); + } + + void EventService::processEvents() + { + if (isGameWindowOpen()) + { + while (game_window->pollEvent(game_event)) + { + if (gameWindowWasClosed() || hasQuitGame()) + { + game_window->close(); + } + } + } + } + + void EventService::updateMouseButtonState(ButtonState& current_button_state, sf::Mouse::Button mouse_button) + { + if (sf::Mouse::isButtonPressed(mouse_button)) + { + switch (current_button_state) + { + case ButtonState::RELEASED: + current_button_state = ButtonState::PRESSED; + break; + case ButtonState::PRESSED: + current_button_state = ButtonState::HELD; + break; + } + } + else + { + current_button_state = ButtonState::RELEASED; + } + } + + void EventService::updateKeyboardButtonState(ButtonState& current_button_state, sf::Keyboard::Key keyboard_button) + { + if (sf::Keyboard::isKeyPressed(keyboard_button)) + { + switch (current_button_state) + { + case ButtonState::RELEASED: + current_button_state = ButtonState::PRESSED; + break; + case ButtonState::PRESSED: + current_button_state = ButtonState::HELD; + break; + } + } + else + { + current_button_state = ButtonState::RELEASED; + } + } + + bool EventService::hasQuitGame() + { + return(isKeyboardEvent() && pressedEscapeKey()); + } + + bool EventService::isKeyboardEvent() + { + return game_event.type == sf::Event::KeyPressed; + } + + bool EventService::pressedEscapeKey() + { + return game_event.key.code == sf::Keyboard::Escape; + } + + bool EventService::isGameWindowOpen() + { + return game_window != nullptr; + } + + bool EventService::gameWindowWasClosed() + { + return game_event.type == sf::Event::Closed; + } + + bool EventService::pressedLeftKey() + { + return left_arrow_button_state == ButtonState::HELD; + } + + bool EventService::pressedRightKey() + { + return right_arrow_button_state == ButtonState::HELD; + } + + bool EventService::pressedAKey() + { + return A_button_state == ButtonState::HELD; + } + + bool EventService::pressedDKey() + { + return D_button_state == ButtonState::HELD; + } + + bool EventService::pressedLeftMouseButton() + { + return left_mouse_button_state == ButtonState::PRESSED; + } + + bool EventService::pressedRightMouseButton() + { return right_mouse_button_state == ButtonState::PRESSED; + } +} diff --git a/Space-Invaders/Source/Gameplay/GameplayController.cpp b/Space-Invaders/Source/Gameplay/GameplayController.cpp new file mode 100644 index 000000000..e8a642bac --- /dev/null +++ b/Space-Invaders/Source/Gameplay/GameplayController.cpp @@ -0,0 +1,30 @@ +#include"../../Header/Gameplay/GameplayController.h" +#include"../../Header/Gameplay/GameplayView.h" + +namespace Gameplay +{ + GameplayController::GameplayController() + { + gameplay_view = new GameplayView(); + } + + GameplayController::~GameplayController() + { + delete(gameplay_view); + } + + void GameplayController::initialize() + { + gameplay_view->initialize(); + } + + void GameplayController::update() + { + gameplay_view->update(); + } + + void GameplayController::render() + { + gameplay_view->render(); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Gameplay/GameplayService.cpp b/Space-Invaders/Source/Gameplay/GameplayService.cpp new file mode 100644 index 000000000..48bb3559a --- /dev/null +++ b/Space-Invaders/Source/Gameplay/GameplayService.cpp @@ -0,0 +1,45 @@ +#include"../../Header/Gameplay/GameplayService.h" +#include"../../Header/Gameplay/GameplayController.h" +#include"../../Header/Global/ServiceLocator.h" + +namespace Gameplay +{ + using namespace Global; + using namespace Player; + using namespace Enemy; + using namespace Element; + using namespace Bullet; + + GameplayService::GameplayService() + { + gameplay_controller = new GameplayController(); + } + + GameplayService::~GameplayService() + { + delete(gameplay_controller); + } + + void GameplayService::initialize() + { + gameplay_controller->initialize(); + } + + void GameplayService::update() + { + gameplay_controller->update(); + } + + void GameplayService::render() + { + gameplay_controller->render(); + } + + void GameplayService::restart() + { + ServiceLocator::getInstance()->getPlayerService()->reset(); + ServiceLocator::getInstance()->getEnemyService()->reset(); + ServiceLocator::getInstance()->getBulletService()->reset(); + ServiceLocator::getInstance()->getElementService()->reset(); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Gameplay/GameplayView.cpp b/Space-Invaders/Source/Gameplay/GameplayView.cpp new file mode 100644 index 000000000..1bb97f728 --- /dev/null +++ b/Space-Invaders/Source/Gameplay/GameplayView.cpp @@ -0,0 +1,46 @@ +#include"../../Header/Gameplay/GameplayView.h" +#include "../../Header/Global/ServiceLocator.h" +#include"../../Header/Graphic/GraphicService.h" +#include"../../Header/Global/Config.h" + +namespace Gameplay +{ + using namespace Global; + using namespace Graphic; + using namespace UI::UIElement; + + GameplayView::GameplayView() + { + background_image = new ImageView(); + } + + GameplayView::~GameplayView() + { + delete(background_image); + } + + void GameplayView::initialize() + { + initializeBackgroundImage(); + } + + void GameplayView::initializeBackgroundImage() + { + sf::RenderWindow* game_window = ServiceLocator::getInstance()->getGraphicService()->getGameWindow(); + + background_image->initialize(Config::background_texture_path, + game_window->getSize().x, + game_window->getSize().y, + sf::Vector2f(0, 0)); + } + + void GameplayView::update() + { + background_image->update(); + } + + void GameplayView::render() + { + background_image->render(); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Global/Config.cpp b/Space-Invaders/Source/Global/Config.cpp new file mode 100644 index 000000000..0309e7530 --- /dev/null +++ b/Space-Invaders/Source/Global/Config.cpp @@ -0,0 +1,66 @@ +#include "../../header/Global/Config.h" + +namespace Global +{ + const sf::String Config::outscal_logo_texture_path = "assets/textures/outscal_logo.png"; + + const sf::String Config::background_texture_path = "assets/textures/space_invaders_bg.png"; + + const sf::String Config::player_texture_path = "assets/textures/player_ship.png"; + + + const sf::String Config::zapper_texture_path = "assets/textures/zapper.png"; + + const sf::String Config::thunder_snake_texture_path = "assets/textures/thunder_snake.png"; + + const sf::String Config::subzero_texture_path = "assets/textures/subzero.png"; + + const sf::String Config::ufo_texture_path = "assets/textures/ufo.png"; + + const sf::String Config::bunker_texture_path = "assets/textures/bunker.png"; + + const sf::String Config::explosion_texture_path = "assets/textures/explosion.png"; + + + const sf::String Config::shield_texture_path = "assets/textures/shield.png"; + + const sf::String Config::tripple_laser_texture_path = "assets/textures/tripple_laser.png"; + + const sf::String Config::rapid_fire_texture_path = "assets/textures/rapid_fire.png"; + + const sf::String Config::outscal_bomb_texture_path = "assets/textures/outscal_bomb.png"; + + + const sf::String Config::laser_bullet_texture_path = "assets/textures/laser_bullet.png"; + + const sf::String Config::torpedoe_texture_path = "assets/textures/torpedoe.png"; + + const sf::String Config::frost_beam_texture_path = "assets/textures/frost_beam.png"; + + + const sf::String Config::play_button_texture_path = "assets/textures/play_button.png"; + + const sf::String Config::instructions_button_texture_path = "assets/textures/instructions_button.png"; + + const sf::String Config::quit_button_texture_path = "assets/textures/quit_button.png"; + + const sf::String Config::menu_button_texture_path = "assets/textures/menu_button.png"; + + + const sf::String Config::bubble_bobble_font_path = "assets/fonts/bubbleBobble.ttf"; + + const sf::String Config::DS_DIGIB_font_path = "assets/fonts/DS_DIGIB.ttf"; + + + const sf::String Config::background_music_path = "assets/sounds/background_music.mp3"; + + const sf::String Config::button_click_sound_path = "assets/sounds/button_click_sound.wav"; + + const sf::String Config::explosion_sound_path = "assets/sounds/explosion.wav"; + + const sf::String Config::bulletfire_sound_path = "assets/sounds/bullet_fire.ogg"; + + const sf::String Config::powerup_enabled_sound_path = "assets/sounds/powerup_enabled.ogg"; + + const sf::String Config::powerup_disabled_sound_path = "assets/sounds/powerup_disabled.ogg"; +} diff --git a/Space-Invaders/Source/Global/ServiceLocator.cpp b/Space-Invaders/Source/Global/ServiceLocator.cpp new file mode 100644 index 000000000..3dd504e56 --- /dev/null +++ b/Space-Invaders/Source/Global/ServiceLocator.cpp @@ -0,0 +1,205 @@ +#include "../../Header/Global/ServiceLocator.h" +#include "../../Header/Main/GameService.h" + +namespace Global +{ + using namespace Graphic; + using namespace Event; + using namespace Time; + using namespace Player; + using namespace UI; + using namespace Enemy; + using namespace Main; + using namespace Gameplay; + using namespace Element; + using namespace Sound; + using namespace Bullet; + using namespace Powerup; + using namespace Collision; + using namespace Animation; + + ServiceLocator::ServiceLocator() + { + graphic_service = nullptr; + event_service = nullptr; + player_service = nullptr; + time_service = nullptr; + ui_service = nullptr; + enemy_service = nullptr; + gameplay_service = nullptr; + element_service = nullptr; + sound_service = nullptr; + bullet_service = nullptr; + powerup_service = nullptr; + collision_service = nullptr; + animation_service = nullptr; + createServices(); + } + + ServiceLocator::~ServiceLocator() + { + clearAllServices(); + } + + void ServiceLocator::createServices() + { + graphic_service = new GraphicService(); + event_service = new EventService(); + player_service = new PlayerService(); + time_service = new TimeService(); + ui_service = new UIService(); + enemy_service = new EnemyService(); + gameplay_service = new GameplayService(); + element_service = new ElementService(); + bullet_service = new BulletService(); + sound_service = new SoundService(); + powerup_service = new PowerupService(); + collision_service = new CollisionService(); + animation_service = new AnimationService(); + } + + void ServiceLocator::clearAllServices() + { + delete(graphic_service); + delete(event_service); + delete(player_service); + delete(time_service); + delete(ui_service); + delete(enemy_service); + delete(gameplay_service); + delete(element_service); + delete(bullet_service); + delete(sound_service); + delete(powerup_service); + delete(collision_service); + delete(animation_service); + graphic_service = nullptr; + } + + ServiceLocator* ServiceLocator::getInstance() + { + static ServiceLocator instance; + return &instance; + } + + void ServiceLocator::initialize() + { + graphic_service->initialize(); + event_service->initialize(); + player_service->initialize(); + time_service->initialize(); + ui_service->initialize(); + enemy_service->initialize(); + gameplay_service->initialize(); + element_service->initialize(); + sound_service->initialize(); + powerup_service->initialize(); + collision_service->initialize(); + bullet_service->initialize(); + animation_service->initialize(); + } + + void ServiceLocator::update() + { + graphic_service->update(); + time_service->update(); + event_service->update(); + + if (GameService::getGameState() == GameState::GAMEPLAY) + { + gameplay_service->update(); + player_service->update(); + enemy_service->update(); + bullet_service->update(); + element_service->update(); + powerup_service->update(); + collision_service->update(); + animation_service->update(); + } + ui_service->update(); + } + + + + void ServiceLocator::render() + { + graphic_service->render(); + if (GameService::getGameState() == GameState::GAMEPLAY) + { + gameplay_service->render(); + player_service->render(); + enemy_service->render(); + bullet_service->render(); + element_service->render(); + powerup_service->render(); + animation_service->render(); + } + + ui_service->render(); + } + + GraphicService* ServiceLocator::getGraphicService() + { + return graphic_service; + } + + EventService* ServiceLocator::getEventService() + { + return event_service; + } + + PlayerService* ServiceLocator::getPlayerService() + { + return player_service; + } + + TimeService* ServiceLocator::getTimeService() + { + return time_service; + } + + UIService* ServiceLocator::getUIService() + { + return ui_service; + } + + EnemyService* ServiceLocator::getEnemyService() + { + return enemy_service; + } + + GameplayService* ServiceLocator::getGameplayService() + { + return gameplay_service; + } + + ElementService* ServiceLocator::getElementService() + { + return element_service; + } + + SoundService* ServiceLocator::getSoundService() + { + return sound_service; + } + + BulletService* ServiceLocator::getBulletService() + { + return bullet_service; + } + + PowerupService* ServiceLocator::getPowerupService() + { + return powerup_service; + } + + CollisionService* ServiceLocator::getCollisionService() + { + return collision_service; + } + + AnimationService* ServiceLocator::getAnimationService() + { + return animation_service; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Graphic/GraphicService.cpp b/Space-Invaders/Source/Graphic/GraphicService.cpp new file mode 100644 index 000000000..a567cfd16 --- /dev/null +++ b/Space-Invaders/Source/Graphic/GraphicService.cpp @@ -0,0 +1,66 @@ +#include "../../Header/Graphic/GraphicService.h" + +namespace Graphic +{ + + GraphicService::GraphicService() + { + game_window = nullptr; + video_mode = nullptr; + } + + + GraphicService::~GraphicService() + { + onDestroy(); + } + + void GraphicService::initialize() + { + game_window = createGameWindow(); + game_window->setFramerateLimit(frame_rate); + } + + sf::RenderWindow* GraphicService::createGameWindow() + { + setVideoMode(); + return new sf::RenderWindow(*video_mode, game_window_title, sf::Style::Fullscreen); + + } + + void GraphicService::setVideoMode() + { + video_mode = new sf::VideoMode(game_window_width, game_window_height, sf::VideoMode::getDesktopMode().bitsPerPixel); + } + + void GraphicService::onDestroy() + { + delete(video_mode); + delete(game_window); + } + + void GraphicService::update() + { + + } + + void GraphicService::render() + { + + } + + bool GraphicService::isGameWindowOpen() + { + return game_window->isOpen(); //returns the open status of the game window + } + + sf::RenderWindow* GraphicService::getGameWindow() + { + return game_window; + } + + sf::Color GraphicService::getWindowColor() + { + return window_color; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Main/GameService.cpp b/Space-Invaders/Source/Main/GameService.cpp new file mode 100644 index 000000000..7697b97a9 --- /dev/null +++ b/Space-Invaders/Source/Main/GameService.cpp @@ -0,0 +1,82 @@ +#include "../../Header/Main/Gameservice.h" +#include "../../Header/Graphic/GraphicService.h" +#include "../../Header/Event/EventService.h" +#include "../../Header/Global/ServiceLocator.h" +#include "../../Header/UI/UIService.h" + +namespace Main +{ + using namespace Global; + using namespace Graphic; + using namespace Event; + using namespace UI; + + GameState GameService::current_state = GameState::BOOT; + + GameService::GameService() + { + service_locator = nullptr; + } + + GameService::~GameService() + { + destroy(); + } + + void GameService::ignite() + { + service_locator = ServiceLocator::getInstance(); + initialize(); + } + + void GameService::initialize() + { + service_locator->initialize(); + initializeVariables(); + showSplashScreen(); + } + + void GameService::showSplashScreen() + { + setGameState(GameState::SPLASH_SCREEN); + ServiceLocator::getInstance()->getUIService()->showScreen(); + } + + void GameService::initializeVariables() + { + game_window = service_locator->getGraphicService()->getGameWindow(); + } + + void GameService::destroy() + { + + } + + void GameService::update() + { + service_locator->getEventService()->processEvents(); + service_locator->update(); + } + + void GameService::render() + { + game_window->clear(); + service_locator->render(); + game_window->display(); + } + + bool GameService::isRunning() + { + return service_locator->getGraphicService()->isGameWindowOpen(); + } + + void GameService::setGameState(GameState new_state) + { + current_state = new_state; + } + + GameState GameService::getGameState() + { + return current_state; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Player/PlayerController.cpp b/Space-Invaders/Source/Player/PlayerController.cpp new file mode 100644 index 000000000..c3b039209 --- /dev/null +++ b/Space-Invaders/Source/Player/PlayerController.cpp @@ -0,0 +1,329 @@ +#include "../../Header/Player/PlayerController.h" +#include "../../Header/Player/PlayerModel.h" +#include "../../Header/Player/PlayerView.h" +#include "../../Header/Event/EventService.h" +#include "../../Header/Global/ServiceLocator.h" +#include"../../Header/Bullet/BulletConfig.h" +#include"../../Header/Entity/EntityConfig.h" +#include"../../Header/Bullet/BulletController.h" +#include"../../Header/Enemy/EnemyController.h" +#include"../../Header/Powerup/PowerupController.h" +#include"../../Header/Main/GameService.h" +#include"../../Header/Sound/SoundService.h" +#include + +namespace Player +{ + using namespace Global; + using namespace Main; + using namespace Event; + using namespace Bullet; + using namespace Time; + using namespace Entity; + using namespace Enemy; + using namespace Powerup; + using namespace Sound; + using namespace Gameplay; + + PlayerController::PlayerController() + { + player_view = new PlayerView(); + player_model = new PlayerModel(); + } + + PlayerController::~PlayerController() + { + delete(player_view); + delete(player_model); + } + void PlayerController::initialize() + { + player_model->initialize(); + player_view->initialize(this); + } + + void PlayerController::update() + { + switch (player_model->getPlayerState()) + { + case::Player::PlayerState::ALIVE: + processPlayerInput(); + break; + + case::Player::PlayerState::FROZEN: + updateFreezDuration(); + break; + } + + updatePowerupDuration(); + updateFireDuration(); + player_view->update(); + } + + void PlayerController::render() + { + player_view->render(); + } + + void PlayerController::reset() + { + player_model->reset(); + } + + sf::Vector2f PlayerController::getPlayerPosition() + { + return player_model->getPlayerPosition(); + } + + PlayerState PlayerController::getPlayerState() + { + return player_model->getPlayerState(); + } + + const sf::Sprite& PlayerController::getColliderSprite() + { + return player_view->getPlayerSprite(); + } + + Entity::EntityType PlayerController::getOwnerEntityType() + { + return player_model->getOwnerEntityType(); + } + + void PlayerController::onCollision(ICollider* other_collider) + { + if (processPowerupCollision(other_collider)) + return; + + if (processBulletCollision(other_collider)) + return; + + processEnemyCollision(other_collider); + } + + bool PlayerController::processBulletCollision(ICollider* other_collider) + { + if (player_model->isShieldEnabled()) + return false; + + BulletController* bullet_Controller = dynamic_cast(other_collider); + + if (bullet_Controller && bullet_Controller->getOwnerEntityType() != EntityType::PLAYER) + { + if (bullet_Controller->getBulletType() == BulletType::FROST_BULLET) + { + player_model->setPlayerState(PlayerState::FROZEN); + elapsed_freez_duration = player_model->freez_duration; + } + else + { + decreasePlayerlive(); + return true; + } + return false; + } + + } + + bool PlayerController::processEnemyCollision(ICollider* other_collider) + { + if (player_model->isShieldEnabled()) + return false; + + EnemyController* enemy_controller = dynamic_cast(other_collider); + if (enemy_controller) + { + decreasePlayerlive(); + return true; + } + return false; + } + + bool PlayerController::processPowerupCollision(ICollider* other_collider) + { + PowerupController* powerup_controller = dynamic_cast(other_collider); + if (powerup_controller) + { + return true; + } + return false; + } + + void PlayerController::updatePowerupDuration() + { + if (elapsed_shield_duration > 0) + { + elapsed_shield_duration -= ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + if (elapsed_shield_duration <= 0) + disableShield(); + } + + if (elapsed_rapid_fire_duration > 0) + { + elapsed_rapid_fire_duration -= ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + if (elapsed_rapid_fire_duration <= 0) + disableRapidFire(); + } + + if (elapsed_tripple_laser_duration > 0) + { + elapsed_tripple_laser_duration -= ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + if (elapsed_tripple_laser_duration <= 0) + disableTrippleLaser(); + } + } + + void PlayerController::freezPlayer() + { + player_model->setPlayerState(PlayerState::FROZEN); + elapsed_freez_duration = player_model->freez_duration; + player_view->setPlayerHighlight(false); + } + + void PlayerController::enableShield() + { + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::POWERUP_ENABLED); + elapsed_shield_duration = player_model->shield_powerup_duration; + player_model->setShieldState(true); + player_view->setPlayerHighlight(false); + } + + void PlayerController::disableShield() + { + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::POWERUP_DISABLED); + player_model->setShieldState(false); + player_view->setPlayerHighlight(false); + } + + void PlayerController::enableRapidFire() + { + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::POWERUP_ENABLED); + elapsed_rapid_fire_duration = player_model->rapid_fire_powerup_duration; + player_model->setRapidFireState(true); + } + + void PlayerController::disableRapidFire() + { + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::POWERUP_DISABLED); + player_model->setRapidFireState(false); + } + + void PlayerController::enableTrippleLaser() + { + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::POWERUP_ENABLED); + elapsed_tripple_laser_duration = player_model->tripple_laser_powerup_duration; + player_model->setTrippleFireState(true); + } + + void PlayerController::disableTrippleLaser() + { + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::POWERUP_DISABLED); + player_model->setTrippleFireState(false); + } + + void PlayerController::processPlayerInput() + { + EventService* event_service = ServiceLocator::getInstance()->getEventService(); + + if (event_service->pressedLeftKey() || event_service->pressedAKey()) + { + moveLeft(); + } + + if (event_service->pressedRightKey() || event_service->pressedDKey()) + { + moveRight(); + } + + if (event_service->pressedLeftMouseButton()) processBulletFire(); + } + + void PlayerController::moveLeft() + { + sf::Vector2f currentPosition = player_model->getPlayerPosition(); + currentPosition.x -= player_model->player_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + currentPosition.x = std::max(currentPosition.x, player_model->left_most_position.x); + player_model->setPlayerPosition(currentPosition); + } + + void PlayerController::moveRight() + { + sf::Vector2f currentPosition = player_model->getPlayerPosition(); + currentPosition.x += player_model->player_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + currentPosition.x = std::min(currentPosition.x, player_model->right_most_position.x); + player_model->setPlayerPosition(currentPosition); + } + + void PlayerController::updateFireDuration() + { + if (elapsed_fire_duration >= 0) + { + elapsed_fire_duration -= ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + } + } + + void PlayerController::updateFreezDuration() + { + if (elapsed_freez_duration > 0) + { + elapsed_freez_duration -= ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + if (elapsed_freez_duration <= 0) + { + player_model->setPlayerState(PlayerState::ALIVE); + player_view->setPlayerHighlight(false); + } + } + } + + + void PlayerController::processBulletFire() + { + if (elapsed_fire_duration > 0) return; + + if (player_model->isTrippleFireEnabled()) + fireBullet(true); + + else fireBullet(); + + if (player_model->isRapidFireEnabled()) + elapsed_fire_duration = player_model->rapid_fire_cooldown_duration; + + else elapsed_fire_duration = player_model->fire_cooldown_duration; + } + + void PlayerController::fireBullet(bool b_tripple_laser) + { + sf::Vector2f bullet_position = player_model->getPlayerPosition() + player_model->barrel_position_offset; + fireBullet(bullet_position); + + if (b_tripple_laser) + { + fireBullet(bullet_position + player_model->second_weapon_position_offset); + fireBullet(bullet_position + player_model->third_weapon_position_offset); + } + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::BULLET_FIRE); + } + + void PlayerController::fireBullet(sf::Vector2f position) + { + + ServiceLocator::getInstance()->getBulletService()->spawnBullet(BulletType::LASER_BULLET, + player_model->getOwnerEntityType(), position, Bullet::MovementDirection::UP); + } + + void PlayerController::decreasePlayerlive() + { + player_model->player_lives -= 1; + + if (player_model->player_lives <= 0) + { + reset(); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Player/PlayerModel.cpp b/Space-Invaders/Source/Player/PlayerModel.cpp new file mode 100644 index 000000000..d411479be --- /dev/null +++ b/Space-Invaders/Source/Player/PlayerModel.cpp @@ -0,0 +1,90 @@ +#include "../../header/Player/PlayerModel.h" + +namespace Player +{ + int PlayerModel::player_lives; + int PlayerModel::enemies_killed; + + PlayerModel::PlayerModel() + { + owner_type = Entity::EntityType::PLAYER; + } + + PlayerModel::~PlayerModel() + { + + } + + void PlayerModel::initialize() + { + reset(); + } + + void PlayerModel::reset() + { + player_state = PlayerState::ALIVE; + player_position = initial_player_position; + player_lives = max_player_lives; + + enemies_killed = 0; + + b_shield = false; + b_rapid_fire = false; + b_tripple_laser = false; + } + + sf::Vector2f PlayerModel::getPlayerPosition() + { + return player_position; + } + + void PlayerModel::setPlayerPosition(sf::Vector2f position) + { + player_position = position; + } + + PlayerState PlayerModel::getPlayerState() + { + return player_state; + } + + void PlayerModel::setPlayerState(PlayerState state) + { + player_state = state; + } + + Entity::EntityType PlayerModel::getOwnerEntityType() + { + return owner_type; + } + + bool PlayerModel::isShieldEnabled() + { + return b_shield; + } + + bool PlayerModel::isRapidFireEnabled() + { + return b_rapid_fire; + } + + bool PlayerModel::isTrippleFireEnabled() + { + return b_tripple_laser; + } + + void PlayerModel::setShieldState(bool value) + { + b_shield = value; + } + + void PlayerModel::setRapidFireState(bool value) + { + b_rapid_fire = value; + } + + void PlayerModel::setTrippleFireState(bool value) + { + b_tripple_laser = value; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Player/PlayerService.cpp b/Space-Invaders/Source/Player/PlayerService.cpp new file mode 100644 index 000000000..f0e45a284 --- /dev/null +++ b/Space-Invaders/Source/Player/PlayerService.cpp @@ -0,0 +1,63 @@ +#include "../../Header/Player/PlayerService.h" +#include "../../Header/Player/PlayerController.h" +#include"../../Header/Global/ServiceLocator.h" +#include"../../Header/Collision/ICollider.h" + +namespace Player +{ + using namespace Global; + using namespace Collision; + + PlayerService::PlayerService() + { + player_controller = new PlayerController(); + } + + PlayerService::~PlayerService() + { + ServiceLocator::getInstance()->getCollisionService()->removeCollider(dynamic_cast(player_controller)); + delete(player_controller); + } + + void PlayerService::initialize() + { + player_controller->initialize(); + ServiceLocator::getInstance()->getCollisionService()->addCollider(dynamic_cast(player_controller)); + } + + void PlayerService::update() + { + player_controller->update(); + } + + void PlayerService::render() + { + player_controller->render(); + } + + void PlayerService::enableShield() + { + player_controller->enableShield(); + } + + void PlayerService::enableRapidFire() + { + player_controller->enableRapidFire(); + } + + void PlayerService::enableTrippleLaser() + { + player_controller->enableTrippleLaser(); + } + + void PlayerService::increaseEnemiesKilled(int val) + { + player_controller->increaseEnemiesKilled(val); + } + + void PlayerService::reset() + { + player_controller->reset(); + } + +} diff --git a/Space-Invaders/Source/Player/PlayerView.cpp b/Space-Invaders/Source/Player/PlayerView.cpp new file mode 100644 index 000000000..e5c81325b --- /dev/null +++ b/Space-Invaders/Source/Player/PlayerView.cpp @@ -0,0 +1,64 @@ +#include "../../Header/Player/PlayerView.h" +#include"../../Header/Player/PlayerController.h" +#include "../../Header/Global/ServiceLocator.h" +#include"../../Header/Global/Config.h" +#include"../../Header/Graphic/GraphicService.h" +#include"../../Header/Player/PlayerModel.h" + +namespace Player +{ + using namespace Global; + using namespace UI::UIElement; + + PlayerView::PlayerView() + { + createUIElements(); + } + + PlayerView::~PlayerView() + { + destroy(); + } + + void PlayerView::initialize(PlayerController* controller) + { + player_controller = controller; + initializeImage(); + } + + void PlayerView::createUIElements() + { + player_image = new ImageView(); + } + + void PlayerView::initializeImage() + { + player_image->initialize(Config::player_texture_path, player_sprite_width, player_sprite_height, player_controller->getPlayerPosition()); + } + + void PlayerView::update() + { + player_image->setPosition(player_controller->getPlayerPosition()); + player_image->update(); + } + + void PlayerView::render() + { + player_image->render(); + } + + const sf::Sprite& PlayerView::getPlayerSprite() + { + return player_image->getSprite(); + } + + void PlayerView::setPlayerHighlight(bool b_highlight) + { + if (b_highlight)player_image->setImageAlpha(PlayerModel::invincible_player_alpha); + else player_image->setImageAlpha(255); + } + void PlayerView::destroy() + { + delete(player_image); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Powerup/Controllers/OutscaleBombController.cpp b/Space-Invaders/Source/Powerup/Controllers/OutscaleBombController.cpp new file mode 100644 index 000000000..8219f3987 --- /dev/null +++ b/Space-Invaders/Source/Powerup/Controllers/OutscaleBombController.cpp @@ -0,0 +1,25 @@ +#include"../../Header/Powerup/Controllers/OutscalBombController.h" +#include"../../Header/Global/ServiceLocator.h" + +namespace Powerup +{ + namespace Controller + { + using namespace Global; + + OutscalBombController::OutscalBombController(PowerupType type) :PowerupController(type) + { + + } + + OutscalBombController::~OutscalBombController() + { + + } + + void OutscalBombController::applyPowerup() + { + ServiceLocator::getInstance()->getEnemyService()->reset(); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Powerup/Controllers/RapidFireController.cpp b/Space-Invaders/Source/Powerup/Controllers/RapidFireController.cpp new file mode 100644 index 000000000..1d07ba148 --- /dev/null +++ b/Space-Invaders/Source/Powerup/Controllers/RapidFireController.cpp @@ -0,0 +1,25 @@ +#include"../../Header/Powerup/Controllers/RapidFireController.h" +#include"../../Header/Global/ServiceLocator.h" + +namespace Powerup +{ + namespace Controller + { + using namespace Global; + + RapidFireController::RapidFireController(PowerupType type) :PowerupController(type) + { + + } + + RapidFireController::~RapidFireController() + { + + } + + void RapidFireController::applyPowerup() + { + ServiceLocator::getInstance()->getPlayerService()->enableRapidFire(); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Powerup/Controllers/ShieldController.cpp b/Space-Invaders/Source/Powerup/Controllers/ShieldController.cpp new file mode 100644 index 000000000..d714c4888 --- /dev/null +++ b/Space-Invaders/Source/Powerup/Controllers/ShieldController.cpp @@ -0,0 +1,25 @@ +#include"../../Header/Powerup/Controllers/ShieldController.h" +#include"../../Header/Global/ServiceLocator.h" + +namespace Powerup +{ + namespace Controller + { + using namespace Global; + + ShieldController::ShieldController(PowerupType type) :PowerupController(type) + { + + } + + ShieldController::~ShieldController() + { + + } + + void ShieldController::applyPowerup() + { + ServiceLocator::getInstance()->getPlayerService()->enableShield(); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Powerup/Controllers/TripleLaserController.cpp b/Space-Invaders/Source/Powerup/Controllers/TripleLaserController.cpp new file mode 100644 index 000000000..8cd52e9c2 --- /dev/null +++ b/Space-Invaders/Source/Powerup/Controllers/TripleLaserController.cpp @@ -0,0 +1,25 @@ +#include"../../Header/Powerup/Controllers/TripleLaserController.h" +#include"../../Header/Global/ServiceLocator.h" + +namespace Powerup +{ + namespace Controller + { + using namespace Global; + + TripleLaserController::TripleLaserController(PowerupType type) :PowerupController(type) + { + + } + + TripleLaserController::~TripleLaserController() + { + + } + + void TripleLaserController::applyPowerup() + { + ServiceLocator::getInstance()->getPlayerService()->enableTrippleLaser(); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Powerup/PowerupController.cpp b/Space-Invaders/Source/Powerup/PowerupController.cpp new file mode 100644 index 000000000..75d970cad --- /dev/null +++ b/Space-Invaders/Source/Powerup/PowerupController.cpp @@ -0,0 +1,92 @@ +#include"../../Header/Powerup/PowerupController.h" +#include"../../Header/Powerup/PowerupView.h" +#include"../../Header/Powerup/PowerupModel.h" +#include"../../Header/Global/ServiceLocator.h" +#include"../../Header/Player/PlayerController.h" + + +namespace Powerup +{ + using namespace Global; + using namespace Player; + + PowerupController::PowerupController(PowerupType type) + { + powerup_view = new PowerupView(); + powerup_model = new PowerupModel(type); + } + + PowerupController::~PowerupController() + { + delete(powerup_view); + delete(powerup_model); + } + + void PowerupController::initialize(sf::Vector2f position) + { + powerup_model->initialize(position); + powerup_view->initialize(this); + } + + void PowerupController::update() + { + updatePowerupPosition(); + powerup_view->update(); + } + + void PowerupController::render() + { + powerup_view->render(); + } + + void PowerupController::onCollected() + { + applyPowerup(); + } + + void PowerupController::updatePowerupPosition() + { + sf::Vector2f currentPosition = getCollectiblePosition(); + currentPosition.y += powerup_model->getMovementSpeed() * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + powerup_model->setPowerupPosition(currentPosition); + } + + void PowerupController::handleOutOfBounds() + { + sf::Vector2f powerupPosition = getCollectiblePosition(); + sf::Vector2u windowSize = ServiceLocator::getInstance()->getGraphicService()->getGameWindow()->getSize(); + + if (powerupPosition.x < 0 || powerupPosition.x > windowSize.x || + powerupPosition.y < 0 || powerupPosition.y > windowSize.y) + { + ServiceLocator::getInstance()->getPowerupService()->destroyPowerup(this); + } + } + + sf::Vector2f PowerupController::getCollectiblePosition() + { + return powerup_model->getPowerupPosition(); + } + + PowerupType PowerupController::getPowerupType() + { + return powerup_model->getPowerupType(); + } + + const sf::Sprite& PowerupController::getColliderSprite() + { + return powerup_view->getPowerupSprite(); + } + + void PowerupController::onCollision(ICollider* other_collider) + { + PlayerController* player_controller = dynamic_cast(other_collider); + + if (player_controller) + { + onCollected(); + ServiceLocator::getInstance()->getPowerupService()->destroyPowerup(this); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Powerup/PowerupModel.cpp b/Space-Invaders/Source/Powerup/PowerupModel.cpp new file mode 100644 index 000000000..6fd5da899 --- /dev/null +++ b/Space-Invaders/Source/Powerup/PowerupModel.cpp @@ -0,0 +1,50 @@ +#include"../../Header/Powerup/PowerupModel.h" + +namespace Powerup +{ + + PowerupModel::PowerupModel(PowerupType type) + { + powerup_type = type; + } + + PowerupModel::~PowerupModel() + { + + } + + void PowerupModel::initialize(sf::Vector2f position) + { + powerup_position = position; + } + + sf::Vector2f PowerupModel::getPowerupPosition() + { + return powerup_position; + } + + void PowerupModel::setPowerupPosition(sf::Vector2f position) + { + powerup_position = position; + } + + PowerupType PowerupModel::getPowerupType() + { + return powerup_type; + } + + void PowerupModel::setPowerupType(PowerupType type) + { + powerup_type = type; + } + + float PowerupModel::getMovementSpeed() + { + return movement_speed; + } + + void PowerupModel::setMovementSpeed(float speed) + { + movement_speed = speed; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Powerup/PowerupService.cpp b/Space-Invaders/Source/Powerup/PowerupService.cpp new file mode 100644 index 000000000..1b9d8624e --- /dev/null +++ b/Space-Invaders/Source/Powerup/PowerupService.cpp @@ -0,0 +1,90 @@ +#include"../../Header/Powerup/PowerupService.h" +#include"../../Header/Powerup/PowerupConfig.h" +#include"../../Header/Powerup/PowerupController.h" +#include"../../Header/Global/ServiceLocator.h" +#include"../../Header/Collision/ICollider.h" +#include"../../Header/Powerup/Controllers/OutscalBombController.h" +#include"../../Header/Powerup/Controllers/RapidFireController.h" +#include"../../Header/Powerup/Controllers/ShieldController.h" +#include"../../Header/Powerup/Controllers/TripleLaserController.h" + +namespace Powerup +{ + using namespace Controller; + using namespace Global; + using namespace Collectible; + using namespace Collision; + + PowerupService::PowerupService() + { + + } + + PowerupService::~PowerupService() + { + destroy(); + } + + void PowerupService::initialize() + { + + } + + void PowerupService::update() + { + for (Collectible::ICollectible* powerup : powerup_list)powerup->update(); + } + + void PowerupService::render() + { + for (Collectible::ICollectible* powerup : powerup_list)powerup->render(); + } + + PowerupController* PowerupService::createPowerup(PowerupType powerup_type) + { + switch (powerup_type) + { + case::Powerup::PowerupType::SHIELD: + return new ShieldController(Powerup::PowerupType::SHIELD); + + case::Powerup::PowerupType::RAPID_FIRE: + return new RapidFireController(Powerup::PowerupType::RAPID_FIRE); + + case::Powerup::PowerupType::TRIPPLE_LASER: + return new TripleLaserController(Powerup::PowerupType::TRIPPLE_LASER); + + case::Powerup::PowerupType::OUTSCAL_BOMB: + return new OutscalBombController(Powerup::PowerupType::OUTSCAL_BOMB); + } + } + + PowerupController* PowerupService::spawnPowerup(PowerupType powerup_type, sf::Vector2f position) + { + PowerupController* powerup_controller = createPowerup(powerup_type); + powerup_controller->initialize(position); + + ServiceLocator::getInstance()->getCollisionService()->addCollider(dynamic_cast(powerup_controller)); + powerup_list.push_back(powerup_controller); + return powerup_controller; + } + + void PowerupService::destroyFlaggedPowerup() + { + for (Collectible::ICollectible* powerup : flagged_power_up_list)delete(powerup); + + flagged_power_up_list.clear(); + } + + void PowerupService::destroyPowerup(PowerupController* powerup_controller) + { + ServiceLocator::getInstance()->getCollisionService()->removeCollider(dynamic_cast(powerup_controller)); + + flagged_power_up_list.push_back(powerup_controller); + powerup_list.erase(std::remove(powerup_list.begin(), powerup_list.end(), powerup_controller), powerup_list.end()); + } + + void PowerupService::destroy() + { + for (Collectible::ICollectible* powerup : powerup_list) delete (powerup); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Powerup/PowerupView.cpp b/Space-Invaders/Source/Powerup/PowerupView.cpp new file mode 100644 index 000000000..18685c46e --- /dev/null +++ b/Space-Invaders/Source/Powerup/PowerupView.cpp @@ -0,0 +1,73 @@ +#include "../../header/Powerup/PowerupView.h" +#include "../../header/Global/ServiceLocator.h" +#include "../../header/Global/Config.h" +#include "../../header/Powerup/PowerupController.h" +#include "../../header/Powerup/PowerupConfig.h" +#include"../../Header/Bullet/BulletConfig.h" + +namespace Powerup +{ + using namespace Global; + using namespace UI::UIElement; + + PowerupView::PowerupView() { createUIElements(); } + + PowerupView::~PowerupView() { destroy(); } + + void PowerupView::initialize(PowerupController* controller) + { + powerup_controller = controller; + initializeImage(); + } + + void PowerupView::createUIElements() + { + powerup_image = new ImageView(); + } + + void PowerupView::initializeImage() + { + powerup_image->initialize(getPowerupTexturePath(), powerup_sprite_width, powerup_sprite_height, powerup_controller->getCollectiblePosition()); + } + + void PowerupView::update() + { + powerup_image->setPosition(powerup_controller->getCollectiblePosition()); + powerup_image->update(); + } + + void PowerupView::render() + { + powerup_image->render(); + } + + sf::String PowerupView::getPowerupTexturePath() + { + switch (powerup_controller->getPowerupType()) + { + case::Powerup::PowerupType::TRIPPLE_LASER: + return Config::shield_texture_path; + + case::Powerup::PowerupType::SHIELD: + return Config::tripple_laser_texture_path; + + case::Powerup::PowerupType::RAPID_FIRE: + return Config::rapid_fire_texture_path; + + case::Powerup::PowerupType::OUTSCAL_BOMB: + return Config::outscal_bomb_texture_path; + } + } + + const sf::Sprite& PowerupView::getPowerupSprite() + { + return powerup_image->getSprite(); + } + + void PowerupView::destroy() + { + delete(powerup_image); + } + + +} \ No newline at end of file diff --git a/Space-Invaders/Source/Sound/SoundService.cpp b/Space-Invaders/Source/Sound/SoundService.cpp new file mode 100644 index 000000000..f3ef27243 --- /dev/null +++ b/Space-Invaders/Source/Sound/SoundService.cpp @@ -0,0 +1,81 @@ +#include"../../Header/Sound/SoundService.h" +#include"../../Header/Global/Config.h" + +namespace Sound +{ + using namespace Global; + + void SoundService::initialize() + { + loadBackgroundMusicFromFile(); + loadSoundFromFile(); + } + + void SoundService::loadBackgroundMusicFromFile() + { + if (!background_music.openFromFile(Config::background_music_path)) + printf("error loading background music file"); + } + + void SoundService::loadSoundFromFile() + { + if (!buffer_button_click.loadFromFile(Config::button_click_sound_path)) + printf("error loading background music file"); + else + if (!buffer_explosion_sound.loadFromFile(Config::explosion_sound_path)) + printf("error loading bakground music file"); + else + if (!buffer_powerup_enabled.loadFromFile(Config::powerup_enabled_sound_path)) + printf("error loading powerup music file"); + else + if (!buffer_powerup_disabled.loadFromFile(Config::powerup_disabled_sound_path)) + printf("error loading powerup music file"); + else + if (!buffer_bullet_fire.loadFromFile(Config::bulletfire_sound_path)) + printf("error loading bulletfire music file"); + } + + void SoundService::playSound(SoundType soundType) + { + switch (soundType) + { + case SoundType::BUTTON_CLICK: + sound_effect.setBuffer(buffer_button_click); + sound_effect.play(); + break; + + case SoundType::EXPLOSION: + sound_effect.setBuffer(buffer_explosion_sound); + sound_effect.play(); + break; + + case SoundType::POWERUP_ENABLED: + sound_effect.setBuffer(buffer_powerup_enabled); + sound_effect.play(); + break; + + case SoundType::POWERUP_DISABLED: + sound_effect.setBuffer(buffer_powerup_disabled); + sound_effect.play(); + break; + + case SoundType::BULLET_FIRE: + sound_effect.setBuffer(buffer_bullet_fire); + sound_effect.play(); + break; + + default: + printf("invaild sound type"); + return; + } + + + } + + void SoundService::playBackgroundMusic() + { + background_music.setLoop(true); + background_music.setVolume(background_music_volume); + background_music.play(); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Time/TimeService.cpp b/Space-Invaders/Source/Time/TimeService.cpp new file mode 100644 index 000000000..a10ad2e2b --- /dev/null +++ b/Space-Invaders/Source/Time/TimeService.cpp @@ -0,0 +1,37 @@ +#include "../../Header/Time/Timeservice.h" + +namespace Time +{ + void TimeService::initialize() + { + previous_time = std::chrono::steady_clock::now(); + delta_time = 0; + } + + void TimeService::update() + { + updateDeltaTime(); + } + + float TimeService::getDeltaTime() + { + return delta_time; + } + + void TimeService::updateDeltaTime() + { + delta_time = calculateDeltaTime(); + updatePreviousTime(); + } + + float TimeService::calculateDeltaTime() + { + int delta = std::chrono::duration_cast(std::chrono::steady_clock::now() - previous_time).count(); + return static_cast(delta) / static_cast(1000000); + } + + void TimeService::updatePreviousTime() + { + previous_time = std::chrono::steady_clock::now(); + } +} diff --git a/Space-Invaders/Source/UI/GameplayUI/GameplayUIController.cpp b/Space-Invaders/Source/UI/GameplayUI/GameplayUIController.cpp new file mode 100644 index 000000000..4caceeb1d --- /dev/null +++ b/Space-Invaders/Source/UI/GameplayUI/GameplayUIController.cpp @@ -0,0 +1,91 @@ +#include "../../header/UI/GameplayUI/GameplayUIController.h" +#include "../../header/Global/Config.h" +#include "../../header/Global/ServiceLocator.h" +#include "../../header/Gameplay/GameplayService.h" +#include "../../header/Sound/SoundService.h" +#include "../../header/Main/GameService.h" +#include "../../header/Player/PlayerModel.h" + +namespace UI +{ + namespace GameplayUI + { + using namespace Main; + using namespace Sound; + using namespace Global; + using namespace Player; + using namespace UI::UIElement; + + GameplayUIController::GameplayUIController() { createUIElements(); } + + GameplayUIController::~GameplayUIController() { destroy(); } + + void GameplayUIController::initialize() + { + initializeImage(); + initializeText(); + } + + void GameplayUIController::createUIElements() + { + player_image = new ImageView(); + + enemies_killed_text = new TextView(); + } + + void GameplayUIController::initializeImage() + { + player_image->initialize(Config::player_texture_path, player_sprite_width, player_sprite_height, sf::Vector2f(0, 0)); + } + + void GameplayUIController::initializeText() + { + + sf::String enemies_killed_string = "Enemies Killed : 0"; + + + enemies_killed_text->initialize(enemies_killed_string, sf::Vector2f(enemies_killed_text_x_position, text_y_position), FontType::BUBBLE_BOBBLE, font_size, text_color); + } + + void GameplayUIController::update() + { + + updateEnemiesKilledText(); + } + + void GameplayUIController::render() + { + + enemies_killed_text->render(); + drawPlayerLives(); + } + + void GameplayUIController::show() { } + + + + void GameplayUIController::updateEnemiesKilledText() + { + sf::String enemies_killed_string = "Enemies Killed : " + std::to_string(PlayerModel::enemies_killed); + enemies_killed_text->setText(enemies_killed_string); + } + + void GameplayUIController::drawPlayerLives() + { + sf::RenderWindow* game_window = ServiceLocator::getInstance()->getGraphicService()->getGameWindow(); + + for (int i = 0; i < PlayerModel::player_lives; i++) + { + player_image->setPosition(sf::Vector2f(player_lives_x_offset - (i * player_lives_spacing), player_lives_y_offset)); + player_image->render(); + } + } + + void GameplayUIController::destroy() + { + delete(player_image); + + delete(enemies_killed_text); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/UI/MainMenuUI/MainMenuUIController.cpp b/Space-Invaders/Source/UI/MainMenuUI/MainMenuUIController.cpp new file mode 100644 index 000000000..dd52ae2e9 --- /dev/null +++ b/Space-Invaders/Source/UI/MainMenuUI/MainMenuUIController.cpp @@ -0,0 +1,129 @@ +#include "../../Header/UI/MainMenuUI/MainMenuUIController.h" +#include "../../Header/Main/GameService.h" +#include "../../Header/Global/ServiceLocator.h" +#include"../../Header/Graphic/GraphicService.h" +#include"../../Header/Global/Config.h" +#include"../../Header/Sound/SoundService.h" +#include"../../Header/Event/EventService.h" + +namespace UI +{ + namespace MainMenu + { + using namespace Global; + using namespace Main; + using namespace UIElement; + using namespace Sound; + using namespace Graphic; + using namespace Gameplay; + using namespace Event; + + MainMenuUIController::MainMenuUIController() + { + createImage(); + createButtons(); + } + + MainMenuUIController::~MainMenuUIController() + { + destroy(); + } + + + void MainMenuUIController::initialize() + { + initializeBackgroundImage(); + initializeButtons(); + registerButtonCallback(); + } + + void MainMenuUIController::createImage() + { + background_image = new ImageView(); + } + + void MainMenuUIController::createButtons() + { + play_button = new ButtonView(); + instructions_button = new ButtonView(); + quit_button = new ButtonView(); + } + + void MainMenuUIController::initializeBackgroundImage() + { + sf::RenderWindow* game_window = ServiceLocator::getInstance()->getGraphicService()->getGameWindow(); + + background_image->initialize(Config::background_texture_path, game_window->getSize().x, game_window->getSize().y, sf::Vector2f(0, 0)); + + background_image->setImageAlpha(background_alpha); + } + + void MainMenuUIController::initializeButtons() + { + play_button->initialize("Play Button", Config::play_button_texture_path, button_width, button_height, sf::Vector2f(0, play_button_y_position)); + instructions_button->initialize("Instructions Button", Config::instructions_button_texture_path, button_width, button_height, sf::Vector2f(0, instructions_button_y_position)); + quit_button->initialize("Quit button", Config::quit_button_texture_path, button_width, button_height, sf::Vector2f(0, quit_button_y_position)); + + play_button->setCentreAlinged(); + instructions_button->setCentreAlinged(); + quit_button->setCentreAlinged(); + } + + void MainMenuUIController::registerButtonCallback() + { + play_button->registerCallbackFunction(std::bind(&MainMenuUIController::playButtonCallback, this)); + instructions_button->registerCallbackFunction(std::bind(&MainMenuUIController::instructionsButtonCallback, this)); + quit_button->registerCallbackFunction(std::bind(&MainMenuUIController::quitButtonCallback, this)); + } + + void MainMenuUIController::playButtonCallback() + { + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::BUTTON_CLICK); + GameService::setGameState(GameState::GAMEPLAY); + } + + void MainMenuUIController::instructionsButtonCallback() + { + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::BUTTON_CLICK); + GameService::setGameState(GameState::INSTRUCTIONS); + } + + void MainMenuUIController::quitButtonCallback() + { + ServiceLocator::getInstance()->getGraphicService()->getGameWindow()->close(); + } + + void MainMenuUIController::update() + { + background_image->update(); + play_button->update(); + instructions_button->update(); + quit_button->update(); + } + + void MainMenuUIController::render() + { + background_image->render(); + play_button->render(); + instructions_button->render(); + quit_button->render(); + } + + void MainMenuUIController::show() + { + background_image->show(); + play_button->show(); + instructions_button->show(); + quit_button->show(); + + } + + void MainMenuUIController::destroy() + { + delete(play_button); + delete(instructions_button); + delete(quit_button); + delete(background_image); + } + } +} diff --git a/Space-Invaders/Source/UI/SplashScreenUI/SplashScreenUIController.cpp b/Space-Invaders/Source/UI/SplashScreenUI/SplashScreenUIController.cpp new file mode 100644 index 000000000..e3d97cd05 --- /dev/null +++ b/Space-Invaders/Source/UI/SplashScreenUI/SplashScreenUIController.cpp @@ -0,0 +1,76 @@ +#include "../../Header/UI/SplashScreenUI/SplashScreenUIController.h" +#include "../../Header/Main/GameService.h" +#include "../../Header/Global/ServiceLocator.h" +#include "../../Header/Graphic/GraphicService.h" +#include "../../Header/Sound/SoundService.h" +#include "../../Header/Global/Config.h" + +namespace UI +{ + namespace SplashScreen + { + using namespace Main; + using namespace Graphic; + using namespace Global; + using namespace UIElement; + using namespace Sound; + + SplashScreenUIController::SplashScreenUIController() + { + outscal_logo_view = new AnimatedImageView(); + } + + SplashScreenUIController::~SplashScreenUIController() + { + delete (outscal_logo_view); + } + + void SplashScreenUIController::initialize() + { + initializeOutscalLogo(); + } + + void SplashScreenUIController::update() + { + outscal_logo_view->update(); + } + + void SplashScreenUIController::render() + { + outscal_logo_view->render(); + } + + void SplashScreenUIController::initializeOutscalLogo() + { + sf::Vector2f position = getLogoPosition(); + outscal_logo_view->initialize(Config::outscal_logo_texture_path, logo_width, logo_height, position); + + } + + void SplashScreenUIController::fadeInAnimationCallback() + { + outscal_logo_view->playAnimation(AnimationType::FADE_OUT, logo_animation_duration, std::bind(&SplashScreenUIController::fadeOutAnimationCallback, this)); + } + + void SplashScreenUIController::fadeOutAnimationCallback() + { + ServiceLocator::getInstance()->getSoundService()->playBackgroundMusic(); + GameService::setGameState(GameState::MAIN_MENU); + } + + sf::Vector2f SplashScreenUIController::getLogoPosition() + { + sf::RenderWindow* game_window = ServiceLocator::getInstance()->getGraphicService()->getGameWindow(); + + float x_position = (game_window->getSize().x - logo_width) / 2.0f; + float y_position = (game_window->getSize().y - logo_height) / 2.0f; + + return sf::Vector2f(x_position, y_position); + } + + void SplashScreenUIController::show() + { + outscal_logo_view->playAnimation(AnimationType::FADE_IN, logo_animation_duration, std::bind(&SplashScreenUIController::fadeInAnimationCallback, this)); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/UI/UIElement/AnimatedImageView.cpp b/Space-Invaders/Source/UI/UIElement/AnimatedImageView.cpp new file mode 100644 index 000000000..0e3435ac1 --- /dev/null +++ b/Space-Invaders/Source/UI/UIElement/AnimatedImageView.cpp @@ -0,0 +1,104 @@ +#include "../../header/UI/UIElement/AnimatedImageView.h" + +namespace UI +{ + namespace UIElement + { + AnimatedImageView::AnimatedImageView() = default; + + AnimatedImageView::~AnimatedImageView() = default; + + void AnimatedImageView::initialize(sf::String texture_path, float image_width, float image_height, sf::Vector2f position) + { + ImageView::initialize(texture_path, image_width, image_height, position); + } + + void AnimatedImageView::registerCallbackFuntion(CallbackFunction animation_end_callback) + { + callback_function = animation_end_callback; + } + + void AnimatedImageView::update() + { + ImageView::update(); + + if (ui_state == UIState::VISIBLE) + { + updateElapsedDuration(); + handleAnimationProgress(); + updateAnimation(); + } + } + + void AnimatedImageView::render() + { + ImageView::render(); + } + + void AnimatedImageView::playAnimation(AnimationType type, float duration, CallbackFunction animation_end_callback) + { + ImageView::show(); + reset(); + setAnimationType(type); + setAnimationDuration(duration); + registerCallbackFuntion(animation_end_callback); + } + + void AnimatedImageView::updateElapsedDuration() + { + float deltaTime = clock.restart().asSeconds(); + elapsed_duration += deltaTime; + } + + void AnimatedImageView::handleAnimationProgress() + { + if (elapsed_duration >= animation_duration && callback_function) + { + callback_function(); + } + } + + void AnimatedImageView::updateAnimation() + { + switch (animation_type) + { + case AnimationType::FADE_IN: + fadeIn(); + break; + case AnimationType::FADE_OUT: + fadeOut(); + break; + } + } + + void AnimatedImageView::setAnimationDuration(float duration) + { + animation_duration = duration; + } + + void AnimatedImageView::setAnimationType(AnimationType type) + { + animation_type = type; + } + + void AnimatedImageView::fadeIn() + { + float alpha = std::min(1.0f, elapsed_duration / animation_duration); + image_sprite.setColor(sf::Color(255, 255, 255, static_cast(alpha * 255))); + } + + void AnimatedImageView::fadeOut() + { + float alpha = std::max(0.0f, 1.0f - (elapsed_duration / animation_duration)); + image_sprite.setColor(sf::Color(255, 255, 255, static_cast(alpha * 255))); + } + + void AnimatedImageView::reset() + { + animation_duration = default_animation_duration; + animation_type = AnimationType::FADE_IN; + clock.restart(); + elapsed_duration = 0.0f; + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/UI/UIElement/ButtonView.cpp b/Space-Invaders/Source/UI/UIElement/ButtonView.cpp new file mode 100644 index 000000000..594e2bb58 --- /dev/null +++ b/Space-Invaders/Source/UI/UIElement/ButtonView.cpp @@ -0,0 +1,64 @@ +#include"../../Header/UI/UIElement/ButtonView.h" +#include"../../Header/Global/ServiceLocator.h" +#include"../../Header/Event/EventService.h" +#include"../../Header/Sound/SoundService.h" + +namespace UI +{ + namespace UIElement + { + using namespace Event; + using namespace Global; + + ButtonView::ButtonView() = default; + + ButtonView::~ButtonView() = default; + + void ButtonView::initialize(sf::String title, sf::String texture_path, float button_width, float button_height, sf::Vector2f position) + { + button_title = title; + ImageView::initialize(texture_path, button_width, button_height, position); + } + + void ButtonView::update() + { + ImageView::update(); + + if (ui_state == UIState::VISIBLE) + { + handleButtonInteraction(); + } + } + + void ButtonView::render() + { + ImageView::render(); + } + + void ButtonView::registerCallbackFunction(CallbackFunction button_callback) + { + callback_function = button_callback; + } + + void ButtonView::handleButtonInteraction() + { + sf::Vector2f mouse_position = sf::Vector2f(sf::Mouse::getPosition(*game_window)); + + if (clickedButton(&image_sprite, mouse_position)) + { + if (callback_function)callback_function(); + } + } + + bool ButtonView::clickedButton(sf::Sprite* button_sprite, sf::Vector2f mouse_position) + { + return ServiceLocator::getInstance()->getEventService()->pressedLeftMouseButton() && + button_sprite->getGlobalBounds().contains(mouse_position); + } + + void ButtonView::printButtonClicked() + { + printf("Clicked %s\n", button_title.toAnsiString().c_str()); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/UI/UIElement/ImageView.cpp b/Space-Invaders/Source/UI/UIElement/ImageView.cpp new file mode 100644 index 000000000..00eafde12 --- /dev/null +++ b/Space-Invaders/Source/UI/UIElement/ImageView.cpp @@ -0,0 +1,98 @@ +#include"../../Header/UI/UIElement/ImageView.h" + +namespace UI +{ + namespace UIElement + { + ImageView::ImageView() = default; + + ImageView::~ImageView() = default; + + void ImageView::initialize(sf::String texture_path, float image_width, float image_height, sf::Vector2f position) + { + UIView::initialize(); + setTexture(texture_path); + setScale(image_width, image_height); + setPosition(position); + + } + + void ImageView::update() + { + UIView::update(); + } + + void ImageView::render() + { + + UIView::render(); + + if (ui_state == UIState::VISIBLE) + { + game_window->draw(image_sprite); + + } + } + + const sf::Sprite& ImageView::getSprite() + { + return image_sprite; + } + + void ImageView::setTexture(sf::String texture_path) + { + if (image_texture.loadFromFile(texture_path)) + { + image_sprite.setTexture(image_texture); + } + } + + void ImageView::setTextureRect(sf::IntRect texture_rect) + { + image_sprite.setTextureRect(texture_rect); + } + + void ImageView::setScale(float width, float height) + { + setScale(width, height, image_sprite.getTexture()->getSize().x, image_sprite.getTexture()->getSize().y); + } + + void ImageView::setScale(float width, float height, float tile_width, float tile_height) + { + float scale_x = width / tile_width; + float scale_y = height / tile_height; + + image_sprite.setScale(scale_x, scale_y); + } + + void ImageView::setPosition(sf::Vector2f position) + { + image_sprite.setPosition(position); + } + + void ImageView::setRotation(float rotation_angle) + { + image_sprite.setRotation(rotation_angle); + } + + void ImageView::setImageAlpha(float alpha) + { + sf::Color color = image_sprite.getColor(); + color.a = alpha; + image_sprite.setColor(color); + } + + void ImageView::setCentreAlinged() + { + float x_position = (game_window->getSize().x / 2) - (image_sprite.getGlobalBounds().width / 2); + float y_position = image_sprite.getGlobalBounds().getPosition().y; + + image_sprite.setPosition(x_position, y_position); + } + + void ImageView::setOriginAtCentre() + { + image_sprite.setOrigin(image_sprite.getLocalBounds().width / 2, image_sprite.getLocalBounds().height / 2); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/UI/UIElement/TextView.cpp b/Space-Invaders/Source/UI/UIElement/TextView.cpp new file mode 100644 index 000000000..228c32e40 --- /dev/null +++ b/Space-Invaders/Source/UI/UIElement/TextView.cpp @@ -0,0 +1,95 @@ +#include"../../Header/UI/UIElement/TextView.h" +#include"../../Header/Global/Config.h" + +namespace UI +{ + namespace UIElement + { + using namespace Global; + + sf::Font TextView::font_bubble_bobble; + sf::Font TextView::font_DS_DIGIB; + + TextView::TextView() = default; + + TextView::~TextView() = default; + + void TextView::initialize(sf::String text_value, sf::Vector2f position, FontType font_type, int font_size, sf::Color color) + { + UIView::initialize(); + + setText(text_value); + setTextPosition(position); + setFont(font_type); + setFontSize(font_size); + setTextColor(color); + } + + void TextView::update() + { + UIView::update(); + } + + void TextView::render() + { + UIView::render(); + + if (ui_state == UIState::VISIBLE) + { + game_window->draw(text); + } + } + + void TextView::initializeTextView() + { + loadFont(); + } + + void TextView::loadFont() + { + font_bubble_bobble.loadFromFile(Config::bubble_bobble_font_path); + font_DS_DIGIB.loadFromFile(Config::DS_DIGIB_font_path); + } + + void TextView::setText(sf::String text_value) + { + text.setString(text_value); + } + + void TextView::setFont(FontType font_type) + { + switch (font_type) + { + case FontType::BUBBLE_BOBBLE: + text.setFont(font_bubble_bobble); + break; + case FontType::DS_DIGIB: + text.setFont(font_DS_DIGIB); + break; + } + } + + void TextView::setFontSize(int font_size) + { + text.setCharacterSize(font_size); + } + + void TextView::setTextPosition(sf::Vector2f position) + { + text.setPosition(position); + } + + void TextView::setTextColor(sf::Color color) + { + text.setFillColor(color); + } + + void TextView::setTextCentreAligned() + { + float x_position = (game_window->getSize().x - text.getLocalBounds().width) / 2; + float y_position = text.getGlobalBounds().getPosition().y; + + text.setPosition(sf::Vector2f(x_position, y_position)); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/UI/UIElement/UIView.cpp b/Space-Invaders/Source/UI/UIElement/UIView.cpp new file mode 100644 index 000000000..c22fc536a --- /dev/null +++ b/Space-Invaders/Source/UI/UIElement/UIView.cpp @@ -0,0 +1,43 @@ +#include"../../Header/UI/UIElement/UIView.h" +#include"../../Header/Global/ServiceLocator.h" +#include"../../Header/Graphic/GraphicService.h" + +namespace UI +{ + namespace UIElement + { + using namespace Global; + using namespace Graphic; + + UIView::UIView() = default; + + UIView::~UIView() = default; + + void UIView::initialize() + { + game_window = ServiceLocator::getInstance()->getGraphicService()->getGameWindow(); + ui_state = UIState::VISIBLE; + } + + + void UIView::update() + { + + } + + void UIView::render() + { + + } + + void UIView::show() + { + ui_state = UIState::VISIBLE; + } + + void UIView::hide() + { + ui_state = UIState::HIDDEN; + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/UI/UIService.cpp b/Space-Invaders/Source/UI/UIService.cpp new file mode 100644 index 000000000..d6e011ad3 --- /dev/null +++ b/Space-Invaders/Source/UI/UIService.cpp @@ -0,0 +1,91 @@ +#include "../../Header/UI/UIService.h" +#include "../../Header/Main/GameService.h" +#include"../../Header/UI/UIElement/TextView.h" + +namespace UI +{ + using namespace Main; + using namespace MainMenu; + using namespace UIElement; + using namespace Interface; + using namespace GameplayUI; + using namespace SplashScreen; + + UIService::UIService() + { + main_menu_controller = nullptr; + gameplayUIController = nullptr; + splash_screen_ui_controller = nullptr; + createControllers(); + } + + void UIService::createControllers() + { + main_menu_controller = new MainMenuUIController(); + gameplayUIController = new GameplayUIController(); + splash_screen_ui_controller = new SplashScreenUIController(); + } + + UIService::~UIService() + { + destory(); + } + + void UIService::initialize() + { + TextView::initializeTextView(); + initializeControllers(); + } + + void UIService::initializeControllers() + { + main_menu_controller->initialize(); + gameplayUIController->initialize(); + splash_screen_ui_controller->initialize(); + } + + void UIService::update() + { + IUIController* ui_controller = getCurrentUIController(); + if (ui_controller)ui_controller->update(); + } + + void UIService::render() + { + IUIController* ui_controller = getCurrentUIController(); + if (ui_controller)ui_controller->render(); + } + + void UIService::showScreen() + { + IUIController* ui_controller = getCurrentUIController(); + if (ui_controller)ui_controller->show(); + } + + + + IUIController* UIService::getCurrentUIController() + { + switch (GameService::getGameState()) + { + case GameState::SPLASH_SCREEN: + return splash_screen_ui_controller; + + case GameState::MAIN_MENU: + return main_menu_controller; + + case GameState::GAMEPLAY: + return gameplayUIController; + + default: + return nullptr; + } + } + + void UIService::destory() + { + delete(main_menu_controller); + delete(gameplayUIController); + delete(splash_screen_ui_controller); + } +} diff --git a/Space-Invaders/Space-Invaders.vcxproj b/Space-Invaders/Space-Invaders.vcxproj index 6f7fa388d..ce7814ccd 100644 --- a/Space-Invaders/Space-Invaders.vcxproj +++ b/Space-Invaders/Space-Invaders.vcxproj @@ -1,4 +1,4 @@ - + @@ -133,6 +133,126 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Space-Invaders/Space-Invaders.vcxproj.filters b/Space-Invaders/Space-Invaders.vcxproj.filters index ce0c35ccf..d5692c10c 100644 --- a/Space-Invaders/Space-Invaders.vcxproj.filters +++ b/Space-Invaders/Space-Invaders.vcxproj.filters @@ -18,5 +18,331 @@ Source Files + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + \ No newline at end of file diff --git a/Space-Invaders/main.cpp b/Space-Invaders/main.cpp index 7d5f90dff..8ca493d7f 100644 --- a/Space-Invaders/main.cpp +++ b/Space-Invaders/main.cpp @@ -1,5 +1,20 @@ +#include +#include +#include "../../Header/Main/GameService.h" +using namespace std; +using namespace Main; int main() { - return 0; + + GameService* game_service = new GameService; + game_service->ignite(); + + while (game_service->isRunning()) + { + game_service->update(); + game_service->render(); + + } + } \ No newline at end of file diff --git a/Space-Invaders/sfml/include/SFML/Config.hpp b/Space-Invaders/sfml/include/SFML/Config.hpp index f4ea4ef3e..3093a7a51 100644 --- a/Space-Invaders/sfml/include/SFML/Config.hpp +++ b/Space-Invaders/sfml/include/SFML/Config.hpp @@ -31,7 +31,7 @@ //////////////////////////////////////////////////////////// #define SFML_VERSION_MAJOR 2 #define SFML_VERSION_MINOR 6 -#define SFML_VERSION_PATCH 0 +#define SFML_VERSION_PATCH 1 //////////////////////////////////////////////////////////// diff --git a/Space-Invaders/sfml/lib/Debug/sfml-audio-s-d.pdb b/Space-Invaders/sfml/lib/Debug/sfml-audio-s-d.pdb index 9371818c4..bbd97a4b6 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-audio-s-d.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-audio-s-d.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-audio-s.pdb b/Space-Invaders/sfml/lib/Debug/sfml-audio-s.pdb index 9371818c4..bbd97a4b6 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-audio-s.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-audio-s.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-audio.pdb b/Space-Invaders/sfml/lib/Debug/sfml-audio.pdb index eec00db20..e0cd93576 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-audio.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-audio.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-graphics-s-d.pdb b/Space-Invaders/sfml/lib/Debug/sfml-graphics-s-d.pdb index c0bed6ba8..d187d9728 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-graphics-s-d.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-graphics-s-d.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-graphics-s.pdb b/Space-Invaders/sfml/lib/Debug/sfml-graphics-s.pdb index c0bed6ba8..d187d9728 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-graphics-s.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-graphics-s.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-graphics.pdb b/Space-Invaders/sfml/lib/Debug/sfml-graphics.pdb index c516163a0..310a084ae 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-graphics.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-graphics.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-main-d.pdb b/Space-Invaders/sfml/lib/Debug/sfml-main-d.pdb index 3e17d4a22..432660dd8 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-main-d.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-main-d.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-main-s.pdb b/Space-Invaders/sfml/lib/Debug/sfml-main-s.pdb index 3e17d4a22..432660dd8 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-main-s.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-main-s.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-network-s-d.pdb b/Space-Invaders/sfml/lib/Debug/sfml-network-s-d.pdb index 7afce5265..446f1fb80 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-network-s-d.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-network-s-d.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-network-s.pdb b/Space-Invaders/sfml/lib/Debug/sfml-network-s.pdb index 7afce5265..446f1fb80 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-network-s.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-network-s.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-network.pdb b/Space-Invaders/sfml/lib/Debug/sfml-network.pdb index 93ec6553c..fa073311f 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-network.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-network.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-system-s-d.pdb b/Space-Invaders/sfml/lib/Debug/sfml-system-s-d.pdb index 2ba28522a..aa448263a 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-system-s-d.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-system-s-d.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-system-s.pdb b/Space-Invaders/sfml/lib/Debug/sfml-system-s.pdb index 2ba28522a..aa448263a 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-system-s.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-system-s.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-system.pdb b/Space-Invaders/sfml/lib/Debug/sfml-system.pdb index 59b5195a4..ea487f4f0 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-system.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-system.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-window-s-d.pdb b/Space-Invaders/sfml/lib/Debug/sfml-window-s-d.pdb index 4a11994b0..98a4c966e 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-window-s-d.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-window-s-d.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-window-s.pdb b/Space-Invaders/sfml/lib/Debug/sfml-window-s.pdb index 4a11994b0..98a4c966e 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-window-s.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-window-s.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-window.pdb b/Space-Invaders/sfml/lib/Debug/sfml-window.pdb index 332a83ca4..1e2442bd4 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-window.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-window.pdb differ diff --git a/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfig.cmake b/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfig.cmake index f8b915b60..f28497b6c 100644 --- a/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfig.cmake +++ b/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfig.cmake @@ -144,5 +144,5 @@ if (NOT SFML_FOUND) endif() if (SFML_FOUND AND NOT SFML_FIND_QUIETLY) - message(STATUS "Found SFML 2.6.0 in ${CMAKE_CURRENT_LIST_DIR}") + message(STATUS "Found SFML 2.6.1 in ${CMAKE_CURRENT_LIST_DIR}") endif() diff --git a/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfigVersion.cmake b/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfigVersion.cmake index b2208ca9f..25db87605 100644 --- a/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfigVersion.cmake +++ b/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfigVersion.cmake @@ -9,19 +9,19 @@ # The variable CVF_VERSION must be set before calling configure_file(). -set(PACKAGE_VERSION "2.6.0") +set(PACKAGE_VERSION "2.6.1") if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) set(PACKAGE_VERSION_COMPATIBLE FALSE) else() - if("2.6.0" MATCHES "^([0-9]+)\\.") + if("2.6.1" MATCHES "^([0-9]+)\\.") set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}") if(NOT CVF_VERSION_MAJOR VERSION_EQUAL 0) string(REGEX REPLACE "^0+" "" CVF_VERSION_MAJOR "${CVF_VERSION_MAJOR}") endif() else() - set(CVF_VERSION_MAJOR "2.6.0") + set(CVF_VERSION_MAJOR "2.6.1") endif() if(PACKAGE_FIND_VERSION_RANGE) diff --git a/Space-Invaders/sfml/lib/cmake/SFML/SFMLSharedTargets.cmake b/Space-Invaders/sfml/lib/cmake/SFML/SFMLSharedTargets.cmake index 1c1c3c062..852e1a8d4 100644 --- a/Space-Invaders/sfml/lib/cmake/SFML/SFMLSharedTargets.cmake +++ b/Space-Invaders/sfml/lib/cmake/SFML/SFMLSharedTargets.cmake @@ -7,7 +7,7 @@ if(CMAKE_VERSION VERSION_LESS "2.8.3") message(FATAL_ERROR "CMake >= 2.8.3 required") endif() cmake_policy(PUSH) -cmake_policy(VERSION 2.8.3...3.24) +cmake_policy(VERSION 2.8.3...3.25) #---------------------------------------------------------------- # Generated CMake target import file. #---------------------------------------------------------------- diff --git a/Space-Invaders/sfml/lib/cmake/SFML/SFMLStaticTargets.cmake b/Space-Invaders/sfml/lib/cmake/SFML/SFMLStaticTargets.cmake index 7257de655..419bb1b85 100644 --- a/Space-Invaders/sfml/lib/cmake/SFML/SFMLStaticTargets.cmake +++ b/Space-Invaders/sfml/lib/cmake/SFML/SFMLStaticTargets.cmake @@ -7,7 +7,7 @@ if(CMAKE_VERSION VERSION_LESS "2.8.3") message(FATAL_ERROR "CMake >= 2.8.3 required") endif() cmake_policy(PUSH) -cmake_policy(VERSION 2.8.3...3.24) +cmake_policy(VERSION 2.8.3...3.25) #---------------------------------------------------------------- # Generated CMake target import file. #----------------------------------------------------------------