309 lines
7.9 KiB
C++
309 lines
7.9 KiB
C++
#include "Settings.h"
|
|
|
|
#include "../Core/Menu.h"
|
|
#include "Keybinds.h"
|
|
|
|
#include <fstream>
|
|
#include <algorithm>
|
|
#include <SFML/Graphics.hpp>
|
|
|
|
static const sf::Vector2u BASE_WINDOW_SIZE = {80, 50};
|
|
static const int WINDOW_SIZE_MULTIPLIERS[] = {4, 6, 10, 14, 20, 30, 40};
|
|
static const int WINDOW_SIZE_LAST_MODE = (sizeof(WINDOW_SIZE_MULTIPLIERS) / sizeof(int)) - 1;
|
|
static const int START_TIMER_MAX = 4;
|
|
static const int DISTRIBUTION_MAX = 10;
|
|
|
|
|
|
Settings::Settings() {
|
|
for (int i = 1; i <= MAXIMUM_PIECES_SIZE; i++) {
|
|
this->menu.getPiecesList().loadPieces(i);
|
|
}
|
|
|
|
this->keybinds.reserve(NUMBER_OF_KEYBINDS);
|
|
for (int i = 0; i < NUMBER_OF_KEYBINDS; i++) {
|
|
this->keybinds.emplace_back(i);
|
|
}
|
|
|
|
this->loadSettingsFromFile();
|
|
}
|
|
|
|
void Settings::loadSettingsFromFile() {
|
|
std::ifstream settingsFile("data/config/settings.bin", std::ios::binary);
|
|
char byte;
|
|
|
|
// keybind layout
|
|
settingsFile.get(byte);
|
|
this->chosenKeybinds = byte;
|
|
|
|
// DAS tuning
|
|
settingsFile.get(byte);
|
|
this->menu.getPlayerControls().setDAS(byte);
|
|
|
|
// ARR tuning
|
|
settingsFile.get(byte);
|
|
this->menu.getPlayerControls().setARR(byte);
|
|
|
|
// SDR tuning
|
|
settingsFile.get(byte);
|
|
this->menu.getPlayerControls().setSDR(byte);
|
|
|
|
// window size mode
|
|
settingsFile.get(byte);
|
|
this->windowSizeMode = byte;
|
|
|
|
// start timer length
|
|
settingsFile.get(byte);
|
|
this->startTimerLength = byte;
|
|
|
|
// gamemode
|
|
settingsFile.get(byte);
|
|
this->gamemode = Gamemode(byte);
|
|
|
|
// board width
|
|
settingsFile.get(byte);
|
|
this->menu.setBoardWidth(byte);
|
|
|
|
// board height
|
|
settingsFile.get(byte);
|
|
this->menu.setBoardHeight(byte);
|
|
|
|
// piece distribution
|
|
settingsFile.get(byte);
|
|
this->menu.getPiecesList().setDistributionMode(DistributionMode(byte));
|
|
|
|
this->distributions.clear();
|
|
this->distributions.push_back(0);
|
|
for (int i = 1; i <= 15; i++) {
|
|
settingsFile.get(byte);
|
|
this->distributions.push_back(byte);
|
|
}
|
|
this->confirmDistribution();
|
|
|
|
// selected pieces
|
|
char pieceType;
|
|
char pieceValue;
|
|
this->selectedPieces.clear();
|
|
while (settingsFile.get(pieceType)) {
|
|
if (settingsFile.eof()) break;
|
|
|
|
settingsFile.get(pieceValue);
|
|
this->selectedPieces.push_back({PiecesType(pieceType), pieceValue});
|
|
}
|
|
this->confirmSelectedPieces();
|
|
}
|
|
|
|
void Settings::saveSettingsToFile() const {
|
|
this->keybinds.at(CUSTOMIZABLE_KEYBINDS).saveKeybindsToFile();
|
|
|
|
std::ofstream settingsFile("data/config/settings.bin", std::ios::trunc | std::ios::binary);
|
|
char byte;
|
|
|
|
// keybind layout
|
|
byte = this->chosenKeybinds;
|
|
settingsFile.write(&byte, 1);
|
|
|
|
// DAS tuning
|
|
byte = this->menu.readPlayerControls().getDAS();
|
|
settingsFile.write(&byte, 1);
|
|
|
|
// ARR tuning
|
|
byte = this->menu.readPlayerControls().getARR();
|
|
settingsFile.write(&byte, 1);
|
|
|
|
// SDR tuning
|
|
byte = this->menu.readPlayerControls().getSDR();
|
|
settingsFile.write(&byte, 1);
|
|
|
|
// window size mode
|
|
byte = this->windowSizeMode;
|
|
settingsFile.write(&byte, 1);
|
|
|
|
// start timer length
|
|
byte = this->startTimerLength;
|
|
settingsFile.write(&byte, 1);
|
|
|
|
// gamemode
|
|
byte = this->gamemode;
|
|
settingsFile.write(&byte, 1);
|
|
|
|
// board width
|
|
byte = this->menu.getBoardWidth();
|
|
settingsFile.write(&byte, 1);
|
|
|
|
// board height
|
|
byte = this->menu.getBoardHeight();
|
|
settingsFile.write(&byte, 1);
|
|
|
|
// piece distribution
|
|
byte = this->menu.readPiecesList().getDistributionMode();
|
|
settingsFile.write(&byte, 1);
|
|
|
|
for (int i = 1; i <= 15; i++) {
|
|
byte = this->distributions.at(i);
|
|
settingsFile.write(&byte, 1);
|
|
}
|
|
|
|
// selected pieces
|
|
for (const auto& [type, value] : this->selectedPieces) {
|
|
byte = type;
|
|
settingsFile.write(&byte, 1);
|
|
byte = value;
|
|
settingsFile.write(&byte, 1);
|
|
}
|
|
}
|
|
|
|
bool Settings::selectNextKeybinds() {
|
|
if (this->chosenKeybinds < (NUMBER_OF_KEYBINDS - 1)) {
|
|
this->chosenKeybinds++;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Settings::selectPreviousKeybinds() {
|
|
if (this->chosenKeybinds > 0) {
|
|
this->chosenKeybinds--;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Settings::canModifyCurrentKeybinds() const {
|
|
return (this->chosenKeybinds == CUSTOMIZABLE_KEYBINDS);
|
|
}
|
|
|
|
bool Settings::widenWindow() {
|
|
if (this->windowSizeMode < WINDOW_SIZE_LAST_MODE) {
|
|
this->windowSizeMode++;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Settings::shortenWindow() {
|
|
if (this->windowSizeMode > 0) {
|
|
this->windowSizeMode--;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void Settings::changeVideoMode(sf::RenderWindow& window) const {
|
|
sf::VideoMode videoMode(BASE_WINDOW_SIZE * (unsigned int) WINDOW_SIZE_MULTIPLIERS[this->windowSizeMode]);
|
|
window.create(videoMode, "jminos", sf::Style::Close | sf::Style::Titlebar);
|
|
|
|
sf::Vector2u desktopSize = sf::VideoMode::getDesktopMode().size;
|
|
sf::Vector2u windowSize = window.getSize();
|
|
window.setPosition(sf::Vector2i((desktopSize.x / 2) - (windowSize.x / 2), (desktopSize.y / 2) - (windowSize.y / 2)));
|
|
}
|
|
|
|
bool Settings::lengthenStartTimer() {
|
|
if (this->startTimerLength < START_TIMER_MAX) {
|
|
this->startTimerLength++;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Settings::shortenStartTimer() {
|
|
if (this->startTimerLength > 0) {
|
|
this->startTimerLength--;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void Settings::setGamemode(Gamemode gamemode) {
|
|
this->gamemode = gamemode;
|
|
}
|
|
|
|
void Settings::selectPieces(PiecesType type, int value) {
|
|
this->selectedPieces.emplace_back(type, value);
|
|
}
|
|
|
|
void Settings::unselectPieces(int index) {
|
|
if (index >= this->selectedPieces.size()) return;
|
|
|
|
this->selectedPieces.erase(this->selectedPieces.begin() + index);
|
|
}
|
|
|
|
void Settings::confirmSelectedPieces() {
|
|
this->menu.getPiecesList().unselectAll();
|
|
|
|
for (const auto& [type, value] : this->selectedPieces) {
|
|
int size = getSizeOfPieces(type);
|
|
|
|
if (size == 0) {
|
|
switch (type) {
|
|
case CONVEX_PIECES : {this->menu.getPiecesList().selectConvexPieces(value); break;}
|
|
case HOLELESS_PIECES : {this->menu.getPiecesList().selectHolelessPieces(value); break;}
|
|
case OTHER_PIECES : {this->menu.getPiecesList().selectOtherPieces(value); break;}
|
|
case ALL_PIECES : {this->menu.getPiecesList().selectAllPieces(value); break;}
|
|
}
|
|
}
|
|
else {
|
|
if (size > MAXIMUM_PIECES_SIZE) return;
|
|
|
|
this->menu.getPiecesList().selectPiece(size, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool Settings::increaseDistribution(int size) {
|
|
if (size < 1 || size > MAXIMUM_PIECES_SIZE) return false;
|
|
|
|
if (this->distributions.at(size) < DISTRIBUTION_MAX) {
|
|
this->distributions.at(size)++;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Settings::decreaseDistribution(int size) {
|
|
if (size < 1 || size > MAXIMUM_PIECES_SIZE) return false;
|
|
|
|
if (this->distributions.at(size) > 0) {
|
|
this->distributions.at(size)--;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void Settings::confirmDistribution() {
|
|
for (int i = 1; i <= 15; i++) {
|
|
this->menu.getPiecesList().changeCustomDistribution(i, (double) this->distributions.at(i) / (DISTRIBUTION_MAX + 0.001));
|
|
}
|
|
}
|
|
|
|
Menu& Settings::getMenu() {
|
|
return this->menu;
|
|
}
|
|
|
|
Keybinds& Settings::getKeybinds() {
|
|
return this->keybinds.at(this->chosenKeybinds);
|
|
}
|
|
|
|
int Settings::getKeybindsLayout() const {
|
|
return this->chosenKeybinds;
|
|
}
|
|
|
|
Gamemode Settings::getGamemode() const {
|
|
return this->gamemode;
|
|
}
|
|
|
|
int Settings::getWindowSizeMultiplier() const {
|
|
return WINDOW_SIZE_MULTIPLIERS[this->windowSizeMode];
|
|
}
|
|
|
|
int Settings::getStartTimerLength() const {
|
|
return this->startTimerLength;
|
|
}
|
|
|
|
const std::vector<std::pair<PiecesType, int>>& Settings::getSelectedPieces() const {
|
|
return this->selectedPieces;
|
|
}
|
|
|
|
const std::vector<int>& Settings::getDistributions() const {
|
|
return this->distributions;
|
|
}
|