260 lines
7.5 KiB
C++
260 lines
7.5 KiB
C++
#include "SynEngine.hpp"
|
|
|
|
class GameConfiguration
|
|
{
|
|
private:
|
|
sf::Vector2i windowDimensions;
|
|
sf::Vector2f canvasSizeMultiplierRatio;
|
|
sf::Color backgroundColor;
|
|
sf::Texture spriteSheet;
|
|
std::string spriteSheetPath;
|
|
sf::Vector2i spriteSheetCellSize;
|
|
sf::IntRect spriteSheetRect;
|
|
sf::Vector2i gridSize;
|
|
sf::Vector2i gridOffset;
|
|
float spriteSizeMultiplier;
|
|
|
|
float audioVolume;
|
|
bool fullscreen;
|
|
|
|
template <class T> T Clamp(T &, T = 0.0, T = 1.0);
|
|
void NormalizeVector2f(sf::Vector2f &);
|
|
void LoadDefaultValues();
|
|
void LoadValuesFromFile(std::string);
|
|
void WriteValuesToFile(std::string);
|
|
void CalculateSprites();
|
|
std::istringstream GetNextNonCommentLine(std::istream &);
|
|
bool LoadSpriteSheet(std::string);
|
|
bool IsFileExists(std::string);
|
|
public:
|
|
GameConfiguration();
|
|
GameConfiguration(std::string = std::string());
|
|
float GetSpriteSizeMultiplier();
|
|
float GetAudioVolume();
|
|
sf::Color GetBackgroundColor();
|
|
sf::Vector2i GetScreenDimensions();
|
|
sf::Vector2i GetGridSize();
|
|
sf::Vector2i GetGridOffset();
|
|
sf::Sprite GetSprite(unsigned int, sf::Vector2f = sf::Vector2f(0, 0), float = 0.0);
|
|
~GameConfiguration();
|
|
};
|
|
|
|
GameConfiguration::GameConfiguration()
|
|
{
|
|
LoadDefaultValues();
|
|
CalculateSprites();
|
|
}
|
|
|
|
GameConfiguration::GameConfiguration(std::string configurationPath)
|
|
{
|
|
if(!configurationPath.empty())
|
|
if(IsFileExists(configurationPath))
|
|
LoadValuesFromFile(configurationPath);
|
|
else
|
|
{
|
|
LoadDefaultValues();
|
|
WriteValuesToFile(configurationPath);
|
|
}
|
|
else
|
|
LoadDefaultValues();
|
|
|
|
CalculateSprites();
|
|
}
|
|
|
|
void GameConfiguration::CalculateSprites()
|
|
{
|
|
float offset;
|
|
sf::Vector2i gridDimensions = sf::Vector2i
|
|
(
|
|
gridSize.x * spriteSheetCellSize.x,
|
|
gridSize.y * spriteSheetCellSize.y
|
|
);
|
|
|
|
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);
|
|
}
|
|
else
|
|
{
|
|
spriteSizeMultiplier = canvasSizeMultiplierRatio.y;
|
|
offset = gridDimensions.x * spriteSizeMultiplier - windowDimensions.x;
|
|
if(offset < 0) offset = -offset;
|
|
gridOffset = sf::Vector2i(offset / 2, 0);
|
|
}
|
|
}
|
|
|
|
void GameConfiguration::NormalizeVector2f(sf::Vector2f &vector)
|
|
{
|
|
float magnitude = sqrt(vector.x * vector.x + vector.y * vector.y);
|
|
vector.x /= magnitude;
|
|
vector.y /= magnitude;
|
|
}
|
|
|
|
template <class T> T GameConfiguration::Clamp(T &value, T min, T max)
|
|
{
|
|
if(value < min) value = min;
|
|
else if(value > max) value = max;
|
|
return value;
|
|
}
|
|
|
|
bool GameConfiguration::IsFileExists(std::string path)
|
|
{
|
|
std::fstream file(path);
|
|
return file.good();
|
|
}
|
|
|
|
void GameConfiguration::LoadValuesFromFile(std::string path)
|
|
{
|
|
std::ifstream confFile(path);
|
|
std::istream &stream = confFile;
|
|
char coma; // This looks so stupid there has to be a better way
|
|
int bgColor[3];
|
|
|
|
GetNextNonCommentLine(stream) >> gridSize.x >> coma >> gridSize.y;
|
|
GetNextNonCommentLine(stream) >> windowDimensions.x >> coma >> windowDimensions.y;
|
|
LoadSpriteSheet(GetNextNonCommentLine(stream).str());
|
|
GetNextNonCommentLine(stream) >> spriteSheetCellSize.x >> coma >> spriteSheetCellSize.y;
|
|
GetNextNonCommentLine(stream) >> audioVolume;
|
|
GetNextNonCommentLine(stream) >> fullscreen;
|
|
GetNextNonCommentLine(stream) >> bgColor[0] >> coma >> bgColor[1] >> coma >> bgColor[2];
|
|
|
|
Clamp(audioVolume);
|
|
Clamp(gridSize.x, 10, 100);
|
|
Clamp(gridSize.y, 10, 100);
|
|
backgroundColor.r = Clamp(bgColor[0], 0, 255);
|
|
backgroundColor.g = Clamp(bgColor[1], 0, 255);
|
|
backgroundColor.b = Clamp(bgColor[2], 0, 255);
|
|
|
|
if(fullscreen)
|
|
{
|
|
sf::VideoMode desktop = sf::VideoMode::getDesktopMode();
|
|
windowDimensions = sf::Vector2i(desktop.width, desktop.height);
|
|
}
|
|
|
|
confFile.close();
|
|
}
|
|
|
|
std::istringstream GameConfiguration::GetNextNonCommentLine(std::istream &stream)
|
|
{
|
|
std::string line;
|
|
while (std::getline(stream, line) && !stream.eof())
|
|
switch (line[0])
|
|
{
|
|
case '#': case '\n': case ' ': case NULL: break;
|
|
default:
|
|
return std::istringstream(line);
|
|
}
|
|
|
|
return std::istringstream();
|
|
}
|
|
|
|
void GameConfiguration::WriteValuesToFile(std::string path)
|
|
{
|
|
std::ofstream confFile(path);
|
|
|
|
confFile << "# Grid Size (x, y) (5 - 100)\n";
|
|
confFile << gridSize.x << ", " << gridSize.y << "\n\n";
|
|
confFile << "# Window Dimensions (x, y)\n";
|
|
confFile << "# If fullscreen set to 1 this will be skipped\n";
|
|
confFile << windowDimensions.x << ", " << windowDimensions.y << "\n\n";
|
|
confFile << "# Sprite Sheet Path\n";
|
|
confFile << spriteSheetPath << "\n\n";
|
|
confFile << "# Sprite Sheet Cell Size (x, y)\n";
|
|
confFile << spriteSheetCellSize.x << ", " << spriteSheetCellSize.y << "\n\n";
|
|
confFile << "# Audio Volume (0.0 - 1.0)\n";
|
|
confFile << audioVolume << "\n\n";
|
|
confFile << "# Fullscreen 1 = on, 0 = off\n";
|
|
confFile << fullscreen << "\n\n";
|
|
confFile << "# Background Color (r, g, b) (0 - 255)\n";
|
|
confFile << (int)backgroundColor.r << ", " << (int)backgroundColor.g << ", " << (int)backgroundColor.b << "\n";
|
|
|
|
confFile.close();
|
|
}
|
|
|
|
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;
|
|
|
|
gridSize = sf::Vector2i(10, 10);
|
|
|
|
LoadSpriteSheet("Data\\SpriteSheet.png");
|
|
// !! Placeholder values! Change after real sprites are added! !!
|
|
spriteSheetCellSize = sf::Vector2i(50, 50);
|
|
fullscreen = false;
|
|
|
|
audioVolume = 1.0;
|
|
}
|
|
|
|
bool GameConfiguration::LoadSpriteSheet(std::string path)
|
|
{
|
|
spriteSheetPath = path;
|
|
return spriteSheet.loadFromFile(path);
|
|
}
|
|
|
|
sf::Sprite GameConfiguration::GetSprite(unsigned int index, sf::Vector2f position, float rotation)
|
|
{
|
|
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;
|
|
}
|
|
|
|
sf::Vector2i GameConfiguration::GetGridSize()
|
|
{
|
|
return gridSize;
|
|
}
|
|
|
|
sf::Vector2i GameConfiguration::GetGridOffset()
|
|
{
|
|
return gridOffset;
|
|
}
|
|
|
|
sf::Vector2i GameConfiguration::GetScreenDimensions()
|
|
{
|
|
return windowDimensions;
|
|
}
|
|
|
|
sf::Color GameConfiguration::GetBackgroundColor()
|
|
{
|
|
return backgroundColor;
|
|
}
|
|
|
|
float GameConfiguration::GetSpriteSizeMultiplier()
|
|
{
|
|
return spriteSizeMultiplier;
|
|
}
|
|
|
|
float GameConfiguration::GetAudioVolume()
|
|
{
|
|
return audioVolume;
|
|
}
|
|
|
|
GameConfiguration::~GameConfiguration()
|
|
{
|
|
}
|