diff --git a/Cell.hpp b/Cell.hpp new file mode 100644 index 0000000..a1bcf52 --- /dev/null +++ b/Cell.hpp @@ -0,0 +1,65 @@ +#include "SynEngine.hpp" + +class Cell : public Drawable +{ + private: + unsigned int spriteIndex; + sf::Vector2f position; + sf::Sprite sprite; + + bool CreateSprite(); + public: + Cell(); + Cell(unsigned int, unsigned int, unsigned int = 1); + void Set(unsigned int, unsigned int, unsigned int = 1); + void UpdateSprite(unsigned int); + void UpdateRotation(unsigned); + void Draw(sf::RenderWindow *); + ~Cell(); +}; + +Cell::Cell() +{ + spriteIndex = 0; + position = sf::Vector2f(0, 0); +} + +Cell::Cell(unsigned int x, unsigned int y, unsigned int index) +{ + Set(x, y, index); +} + +void Cell::Set(unsigned int x, unsigned int y, unsigned int index) +{ + spriteIndex = index; + position = sf::Vector2f(x, y); + CreateSprite(); +} + +bool Cell::CreateSprite() +{ + GameConfiguration *config = GameManager::GetConfig(); + if(!config) return false; + sprite = config -> GetSprite(spriteIndex, position); + return true; +} + +void Cell::UpdateSprite(unsigned int index) +{ + if(index == spriteIndex) return; + sprite.setTextureRect(GameManager::GetConfig() -> GetSpriteRect(index)); +} + +void Cell::UpdateRotation(unsigned direction) +{ + sprite.setRotation(direction * 90.0); +} + +void Cell::Draw(sf::RenderWindow *window) +{ + window -> draw(sprite); +} + +Cell::~Cell() +{ +} diff --git a/Drawable.hpp b/Drawable.hpp new file mode 100644 index 0000000..b5778bf --- /dev/null +++ b/Drawable.hpp @@ -0,0 +1,7 @@ +#include "SynEngine.hpp" + +class Drawable +{ + public: + virtual void Draw(sf::RenderWindow *) = 0; +}; diff --git a/GameConfiguration.hpp b/GameConfiguration.hpp index c844c3a..47081a3 100644 --- a/GameConfiguration.hpp +++ b/GameConfiguration.hpp @@ -4,7 +4,6 @@ class GameConfiguration { private: sf::Vector2i windowDimensions; - sf::Vector2f canvasSizeMultiplierRatio; sf::Color backgroundColor; sf::Texture spriteSheet; std::string spriteSheetPath; @@ -22,7 +21,7 @@ class GameConfiguration void LoadDefaultValues(); void LoadValuesFromFile(std::string); void WriteValuesToFile(std::string); - void CalculateSprites(); + void CalculateCommonValues(); std::istringstream GetNextNonCommentLine(std::istream &); bool LoadSpriteSheet(std::string); bool IsFileExists(std::string); @@ -35,6 +34,8 @@ class GameConfiguration sf::Vector2i GetScreenDimensions(); sf::Vector2i GetGridSize(); sf::Vector2i GetGridOffset(); + sf::Vector2i GetSpriteCellSize(); + sf::IntRect GetSpriteRect(unsigned int); sf::Sprite GetSprite(unsigned int, sf::Vector2f = sf::Vector2f(0, 0), float = 0.0); ~GameConfiguration(); }; @@ -42,7 +43,7 @@ class GameConfiguration GameConfiguration::GameConfiguration() { LoadDefaultValues(); - CalculateSprites(); + CalculateCommonValues(); } GameConfiguration::GameConfiguration(std::string configurationPath) @@ -58,10 +59,10 @@ GameConfiguration::GameConfiguration(std::string configurationPath) else LoadDefaultValues(); - CalculateSprites(); + CalculateCommonValues(); } -void GameConfiguration::CalculateSprites() +void GameConfiguration::CalculateCommonValues() { float offset; sf::Vector2i gridDimensions = sf::Vector2i @@ -69,29 +70,33 @@ void GameConfiguration::CalculateSprites() gridSize.x * spriteSheetCellSize.x, gridSize.y * spriteSheetCellSize.y ); - - canvasSizeMultiplierRatio = sf::Vector2f + sf::Vector2f canvasSizeMultiplierRatio = sf::Vector2f ( (float)windowDimensions.x / (float)gridDimensions.x, (float)windowDimensions.y / (float)gridDimensions.y ); - spriteSheetRect = sf::IntRect(sf::Vector2i(0, 0), spriteSheetCellSize); - if(canvasSizeMultiplierRatio.x < canvasSizeMultiplierRatio.y) { spriteSizeMultiplier = canvasSizeMultiplierRatio.x; offset = gridDimensions.y * spriteSizeMultiplier - windowDimensions.y; if(offset < 0) offset = -offset; - gridOffset = sf::Vector2i(0, offset / 2); + offset /= 2; + gridOffset = sf::Vector2i(0, offset); } else { spriteSizeMultiplier = canvasSizeMultiplierRatio.y; offset = gridDimensions.x * spriteSizeMultiplier - windowDimensions.x; if(offset < 0) offset = -offset; - gridOffset = sf::Vector2i(offset / 2, 0); + offset /= 2; + gridOffset = sf::Vector2i(offset, 0); } + // Center Origin Offset + gridOffset.x += spriteSheetCellSize.x / 2; + gridOffset.y += spriteSheetCellSize.y / 2; + + spriteSheetRect = sf::IntRect(sf::Vector2i(0, 0), spriteSheetCellSize); } void GameConfiguration::NormalizeVector2f(sf::Vector2f &vector) @@ -130,8 +135,8 @@ void GameConfiguration::LoadValuesFromFile(std::string path) GetNextNonCommentLine(stream) >> bgColor[0] >> coma >> bgColor[1] >> coma >> bgColor[2]; Clamp(audioVolume); - Clamp(gridSize.x, 10, 100); - Clamp(gridSize.y, 10, 100); + Clamp(gridSize.x, 5, 100); + Clamp(gridSize.y, 5, 100); backgroundColor.r = Clamp(bgColor[0], 0, 255); backgroundColor.g = Clamp(bgColor[1], 0, 255); backgroundColor.b = Clamp(bgColor[2], 0, 255); @@ -186,7 +191,6 @@ void GameConfiguration::LoadDefaultValues() { windowDimensions = sf::Vector2i(800, 600); // !! Placeholder values! Change after real sprites are added! !! - canvasSizeMultiplierRatio = sf::Vector2f(0.0, 1.0f); spriteSizeMultiplier = 1.0; backgroundColor = sf::Color::White; @@ -208,20 +212,26 @@ bool GameConfiguration::LoadSpriteSheet(std::string path) } sf::Sprite GameConfiguration::GetSprite(unsigned int index, sf::Vector2f position, float rotation) +{ + sf::Sprite sprite; + + sprite.setTexture(spriteSheet); + sprite.setTextureRect(GetSpriteRect(index)); + sprite.setPosition(position); + sprite.setRotation(rotation); + sprite.setOrigin(spriteSheetCellSize.x / 2, spriteSheetCellSize.y / 2); + sprite.setScale(spriteSizeMultiplier, spriteSizeMultiplier); + return sprite; +} + +sf::IntRect GameConfiguration::GetSpriteRect(unsigned int index) { int offset = spriteSheetRect.width * index; int xSize = spriteSheet.getSize().x; - sf::Sprite sprite; spriteSheetRect.left = offset % xSize; spriteSheetRect.top = offset / xSize * spriteSheetCellSize.y; - - sprite.setTexture(spriteSheet); - sprite.setTextureRect(spriteSheetRect); - sprite.setPosition(position); - sprite.setRotation(rotation); - sprite.setScale(spriteSizeMultiplier, spriteSizeMultiplier); - return sprite; + return spriteSheetRect; } sf::Vector2i GameConfiguration::GetGridSize() @@ -234,6 +244,11 @@ sf::Vector2i GameConfiguration::GetGridOffset() return gridOffset; } +sf::Vector2i GameConfiguration::GetSpriteCellSize() +{ + return spriteSheetCellSize; +} + sf::Vector2i GameConfiguration::GetScreenDimensions() { return windowDimensions; diff --git a/GameManager.hpp b/GameManager.hpp new file mode 100644 index 0000000..95e0840 --- /dev/null +++ b/GameManager.hpp @@ -0,0 +1,25 @@ +#include "SynEngine.hpp" +class GameConfiguration; + +class GameManager +{ + private: + static GameConfiguration *config; + + public: + static void SetConfig(GameConfiguration &); + static GameConfiguration *GetConfig(); +}; + +GameConfiguration *GameManager::config = NULL; + +void GameManager::SetConfig(GameConfiguration &config) +{ + GameManager::config = &config; +} + + +GameConfiguration *GameManager::GetConfig() +{ + return GameManager::config; +} diff --git a/Grid.hpp b/Grid.hpp index 01a1602..36ddcb1 100644 --- a/Grid.hpp +++ b/Grid.hpp @@ -1,36 +1,87 @@ #include "SynEngine.hpp" -class Grid +class Grid : public Drawable { private: sf::Vector2i offset; sf::Vector2i gridSize; - GameConfiguration *config; + Cell *cellArray; + unsigned int cellCount; + Cell *CreateCellArray(sf::Vector2i); public: Grid(); - bool SetGrid(GameConfiguration &); + bool SetGrid(); + void UpdateCell(unsigned int, unsigned int, unsigned int, int = -1); + void Draw(sf::RenderWindow *); ~Grid(); }; Grid::Grid() { - config = NULL; + cellArray = NULL; } -bool Grid::SetGrid(GameConfiguration &config) +Cell *Grid::CreateCellArray(sf::Vector2i) { - this -> config = &config; + cellCount = gridSize.x *gridSize.y; + Cell *array = new Cell[cellCount]; - if(!this -> config) return false; + if(!array) return NULL; - sf::Vector2i screenDimensions = config.GetScreenDimensions(); - gridSize = config.GetGridSize(); - offset = config.GetGridOffset(); + GameConfiguration *config = GameManager::GetConfig(); + + sf::Vector2i cellSize = config -> GetSpriteCellSize(); + float sizeMultiplier = config -> GetSpriteSizeMultiplier(); + int xPos; + int yPos; + int i; + + for (i = 0; i < cellCount; i++) + { + xPos = (i % gridSize.x) * cellSize.x * sizeMultiplier + offset.x; + yPos = (i / gridSize.x) * cellSize.y * sizeMultiplier + offset.y; + + (array + i) -> Set(xPos, yPos); + } + + return array; +} + +bool Grid::SetGrid() +{ + GameConfiguration *config = GameManager::GetConfig(); + + if(!config) return false; + + sf::Vector2i screenDimensions = config -> GetScreenDimensions(); + gridSize = config -> GetGridSize(); + offset = config -> GetGridOffset(); + + cellArray = CreateCellArray(gridSize); return true; } +void Grid::UpdateCell(unsigned int x, unsigned int y, unsigned int spriteIndex, int direction) +{ + int index = x + gridSize.x * y; + Cell *cell = cellArray + index; + + cell -> UpdateSprite(spriteIndex); + if(direction >= 0) + cell -> UpdateRotation(direction); +} + + +void Grid::Draw(sf::RenderWindow *window) +{ + int i; + for (i = 0; i < cellCount; i++) + (cellArray + i) -> Draw(window); +} + Grid::~Grid() { + delete[] cellArray; } diff --git a/SynEngine.hpp b/SynEngine.hpp index 81e8f57..9a8f7e6 100644 --- a/SynEngine.hpp +++ b/SynEngine.hpp @@ -5,7 +5,10 @@ #include #include #include + #include "GameManager.hpp" #include "GameConfiguration.hpp" + #include "Drawable.hpp" + #include "Cell.hpp" #include "Grid.hpp" #include "GameWindow.hpp" #endif diff --git a/main.cpp b/main.cpp index c2281ba..8908208 100644 --- a/main.cpp +++ b/main.cpp @@ -3,20 +3,18 @@ int main(int argc, char const *argv[]) { GameConfiguration config = GameConfiguration("Configurations"); + GameManager::SetConfig(config); Grid grid = Grid(); - grid.SetGrid(config); + grid.SetGrid(); sf::RenderWindow render(sf::VideoMode(800, 600), "Test"); if (render.isOpen()) // Quick Test { - float multiplier = config.GetSpriteSizeMultiplier(); - int count = config.GetGridSize().x * config.GetGridSize().y; - sf::Vector2i offset = config.GetGridOffset(); - render.clear(config.GetBackgroundColor()); - for (int i = 0; i < count; i++) - render.draw(config.GetSprite(i % 6, sf::Vector2f(i % config.GetGridSize().x * 50 * multiplier + offset.x, i / config.GetGridSize().x * 50 * multiplier + offset.y))); + grid.UpdateCell(0, 0, 2); + grid.UpdateCell(0, 1, 2, 1); + grid.Draw(&render); render.display(); sf::sleep(sf::milliseconds(5000)); }