coffee_crisis_arcade_edition/source/load_param.cpp

#include "load_param.h"
#include <iostream>
#include <fstream>

// Asigna variables a partir de dos cadenas
bool setOptions(param_t *param, std::string var, std::string value);

// Calcula variables a partir de otras variables
void precalculateZones(param_t *param);

// Establece valores por defecto a las variables
void initParam(param_t *param)
{
	// GAME
	param->game.width = 320;
	param->game.height = 256;
	param->game.itemSize = 20;
	param->game.gameArea.rect = {0, 0, param->game.width, param->game.height};
	param->game.playArea.rect = {0, 0, param->game.width, 216};
	precalculateZones(param);

	// SCOREBOARD
	param->scoreboard = {0, 216, param->game.width, 40};

	// FADE
	param->fade.numSquaresWidth = param->game.width / 2;
	param->fade.numSquaresHeight = param->game.height / 2;
	param->fade.randomSquaresDelay = 1;
	param->fade.randomSquaresMult = 500;
	param->fade.postDuration = 80;
	param->fade.venetianSize = 16;

	// TITLE
	param->title.pressStartPosition = 160;
	param->title.titleDuration = 800;
	param->title.arcadeEditionPosition = 123;
	param->title.titleCCPosition = 11;

	// BACKGROUND
	param->background.attenuateColor = {255, 255, 255};
	param->background.attenuateAlpha = 32;

	// BALLOONS
	param->balloon1.vel = 2.60f;
	param->balloon1.grav = 0.09f;
	param->balloon2.vel = 3.50f;
	param->balloon2.grav = 0.10f;
	param->balloon3.vel = 4.50f;
	param->balloon3.grav = 0.10f;
	param->balloon4.vel = 4.95f;
	param->balloon4.grav = 0.10f;
}

// Establece valores para los parametros a partir de un fichero de texto
void loadParamsFromFile(param_t *param, std::string filePath)
{
	// Pone valores por defecto a las variables
	initParam(param);

	// Variables para manejar el fichero
	std::string line;
	std::ifstream file(filePath);
	std::string param1;
	std::string param2;

	// Si el fichero se puede abrir
	if (file.good())
	{
#ifdef VERBOSE
		const std::string filename = filePath.substr(filePath.find_last_of("\\/") + 1);
		std::cout << "Reading file: " << filename << std::endl;
#endif
		// Procesa cada linea del fichero
		while (std::getline(file, line))
		{
			// Reinicia variables
			param1 = "";
			param2 = "";

			// Elimina los comentarios
			line = line.substr(0, line.find("#"));

			// Ignora los espacios en blanco
			int pos = 0;
			while (pos < (int)line.size() && (int)line[pos] <= 32)
			{
				pos++;
			}

			// Si no ha llegado al final de la linea, es que hay algo escrito (no es una linea vacía)
			if (pos < (int)line.size())
			{
				// Elimina el espacio en blanco
				line = line.substr(pos, std::string::npos);

				// Se queda con todo lo que no sean espacios en blanco
				pos = 1;
				while (pos <= (int)line.size() && (int)line[pos] > 32)
				{
					pos++;
				}

				// Si llega al final de la linea, falta la segunda palabra
				if (pos < (int)line.size())
				{
					// Se queda con la primera palabra
					param1 = line.substr(0, pos);

					// Y recorta la linea
					line = line.substr(pos, std::string::npos);

					// Ignora los espacios en blanco
					pos = 0;
					while (pos <= (int)line.size() && (int)line[pos] <= 32)
					{
						pos++;
					}

					// Si llega al final de la linea, falta la segunda palabra
					if (pos < (int)line.size())
					{
						// Elimina el espacio en blanco
						line = line.substr(pos, std::string::npos);

						// Ignora los espacios en blanco
						pos = 1;
						while (pos <= (int)line.size() && (int)line[pos] > 32)
						{
							pos++;
						}
						// Se queda con la segunda palabra
						param2 = line.substr(0, pos);
					}
				}
			}

			setOptions(param, param1, param2);
		}

		// Cierra el fichero
		file.close();
	}
#ifdef VERBOSE
	else
		std::cout << "Failed to load file: " << filePath << std::endl;
#endif

	precalculateZones(param);
}

// Asigna variables a partir de dos cadenas
bool setOptions(param_t *param, std::string var, std::string value)
{
	// Indicador de éxito en la asignación
	bool success = true;

	// GAME
	if (var == "game.width")
	{
		param->game.width = std::stoi(value);
	}

	else if (var == "game.height")
	{
		param->game.height = std::stoi(value);
	}

	else if (var == "game.itemSize")
	{
		param->game.itemSize = std::stoi(value);
	}

	else if (var == "game.playArea.rect.x")
	{
		param->game.playArea.rect.x = std::stoi(value);
	}

	else if (var == "game.playArea.rect.y")
	{
		param->game.playArea.rect.y = std::stoi(value);
	}

	else if (var == "game.playArea.rect.w")
	{
		param->game.playArea.rect.w = std::stoi(value);
	}

	else if (var == "game.playArea.rect.h")
	{
		param->game.playArea.rect.h = std::stoi(value);
	}

	// FADE
	else if (var == "fade.numSquaresWidth")
	{
		param->fade.numSquaresWidth = std::stoi(value);
	}

	else if (var == "fade.numSquaresHeight")
	{
		param->fade.numSquaresHeight = std::stoi(value);
	}

	else if (var == "fade.randomSquaresDelay")
	{
		param->fade.randomSquaresDelay = std::stoi(value);
	}

	else if (var == "fade.randomSquaresMult")
	{
		param->fade.randomSquaresMult = std::stoi(value);
	}

	else if (var == "fade.postDuration")
	{
		param->fade.postDuration = std::stoi(value);
	}

	else if (var == "fade.venetianSize")
	{
		param->fade.venetianSize = std::stoi(value);
	}

	// SCOREBOARD
	else if (var == "scoreboard.x")
	{
		param->scoreboard.x = std::stoi(value);
	}

	else if (var == "scoreboard.y")
	{
		param->scoreboard.y = std::stoi(value);
	}

	else if (var == "scoreboard.w")
	{
		param->scoreboard.w = std::stoi(value);
	}

	else if (var == "scoreboard.h")
	{
		param->scoreboard.h = std::stoi(value);
	}

	// TITLE
	else if (var == "title.pressStartPosition")
	{
		param->title.pressStartPosition = std::stoi(value);
	}

	else if (var == "title.titleDuration")
	{
		param->title.titleDuration = std::stoi(value);
	}

	else if (var == "title.arcadeEditionPosition")
	{
		param->title.arcadeEditionPosition = std::stoi(value);
	}

	else if (var == "title.titleCCPosition")
	{
		param->title.titleCCPosition = std::stoi(value);
	}

	// BACKGROUND
	else if (var == "background.attenuateColor.r")
	{
		param->background.attenuateColor.r = std::stoi(value);
	}

	else if (var == "background.attenuateColor.g")
	{
		param->background.attenuateColor.g = std::stoi(value);
	}

	else if (var == "background.attenuateColor.b")
	{
		param->background.attenuateColor.b = std::stoi(value);
	}

	else if (var == "background.attenuateAlpha")
	{
		param->background.attenuateAlpha = std::stoi(value);
	}

	// BALLOON
	else if (var == "balloon1.vel")
	{
		param->balloon1.vel = std::stof(value);
	}

	else if (var == "balloon1.grav")
	{
		param->balloon1.grav = std::stof(value);
	}

	else if (var == "balloon2.vel")
	{
		param->balloon2.vel = std::stof(value);
	}

	else if (var == "balloon2.grav")
	{
		param->balloon2.grav = std::stof(value);
	}

	else if (var == "balloon3.vel")
	{
		param->balloon3.vel = std::stof(value);
	}

	else if (var == "balloon3.grav")
	{
		param->balloon3.grav = std::stof(value);
	}

	else if (var == "balloon4.vel")
	{
		param->balloon4.vel = std::stof(value);
	}

	else if (var == "balloon4.grav")
	{
		param->balloon4.grav = std::stof(value);
	}

	// RESTO
	else
	{
		success = false;
	}

	return success;
}

// Calcula variables a partir de otras variables
void precalculateZones(param_t *param)
{

	// playArea
	param->game.playArea.centerX = param->game.playArea.rect.w / 2;
	param->game.playArea.firstQuarterX = param->game.playArea.rect.w / 4;
	param->game.playArea.thirdQuarterX = param->game.playArea.rect.w / 4 * 3;
	param->game.playArea.centerY = param->game.playArea.rect.h / 2;
	param->game.playArea.firstQuarterY = param->game.playArea.rect.h / 4;
	param->game.playArea.thirdQuarterY = param->game.playArea.rect.h / 4 * 3;

	// gameArea
	param->game.gameArea.rect = {0, 0, param->game.width, param->game.height};
	param->game.gameArea.centerX = param->game.gameArea.rect.w / 2;
	param->game.gameArea.firstQuarterX = param->game.gameArea.rect.w / 4;
	param->game.gameArea.thirdQuarterX = param->game.gameArea.rect.w / 4 * 3;
	param->game.gameArea.centerY = param->game.gameArea.rect.h / 2;
	param->game.gameArea.firstQuarterY = param->game.gameArea.rect.h / 4;
	param->game.gameArea.thirdQuarterY = param->game.gameArea.rect.h / 4 * 3;
}