src/settings.cc

   1 /*
   2  * See settings.hh for information about this file.
   3  *
   4  * Copyright (C) 2008 David Kolossa
   5  *
   6  * This file is part of OpenStranded
   7  *
   8  * OpenStranded is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation, either version 3 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * OpenStranded is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with OpenStranded. If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <cassert>
  23 #include <iostream>
  24 #include "tinyxml/tinyxml.h"
  25 #include "settings.hh"
  26 #include "s2string.hh"
  27 #include "output.hh"
  28
  29 GlobalSettings::GlobalSettings(std::string configPath) :
  30         configPath(configPath)
  31 {
  32         this->initializeStandardValues();
  33         this->readConfigFile();
  34 }
  35
  36 GlobalSettings::~GlobalSettings()
  37 {}
  38
  39 void
  40 GlobalSettings::initializeStandardValues()
  41 {
  42         this->setResolutionX(1024);
  43         this->setResolutionY(768);
  44         this->setColorDepth(32);
  45         this->setFullScreen(false);
  46
  47         #ifdef HAVE_IRRLICHT
  48         this->setRenderer("Irrlicht");
  49         #elif defined(HAVE_HORDE3D)
  50         this->setRenderer("Horde3D");
  51         #else
  52         this->setRenderer("");
  53         #endif
  54
  55         this->setViewRange(2);
  56
  57         this->setTerrainDetail(1);
  58         this->setWaterDetail(3);
  59         this->setSkyDetail(1);
  60         this->setEffectDetail(1);
  61         this->setGrassDetail(2);
  62
  63         this->setMusicVolume(1.0);
  64         this->setSoundVolume(1.0);
  65
  66         this->setPp2d(true);
  67         this->setLightFx(true);
  68         this->setWindSwayFx(true);
  69         this->setFog(true);
  70         this->setMultiTex(true);
  71         this->setMotionBlur(true);
  72         this->setMotionBlurIntensity(1.0);
  73
  74         this->setPlayerName("Mr. Stranded");
  75         this->setPort(39369);
  76 }
  77
  78 bool
  79 GlobalSettings::updateConfigFile()
  80 {
  81         TiXmlDocument xml;
  82
  83         // Create XML declaration
  84         TiXmlDeclaration *declaration = new TiXmlDeclaration("1.0", "utf-8", "");
  85         xml.LinkEndChild(declaration);
  86
  87         // Create <config> environment
  88         TiXmlElement *root = new TiXmlElement("config");
  89         xml.LinkEndChild(root);
  90
  91         // Traverse setting map
  92         for (std::map<std::string, std::string>::iterator i = this->settings.begin(); i != this->settings.end(); i++)
  93         {
  94                 std::string substrings[2];
  95                 int flag;
  96                 std::string key = std::string(i->first);
  97                 std::string value = std::string(i->second);
  98
  99                 flag = s2str::explode(key, substrings, "_", 2);
 100                 if (inFlag(flag, EXPLODE_GREATER) || inFlag(flag, EXPLODE_LOWER) )
 101                 {
 102                         Out::debug << "Malformed setting name, skipped it." << Out::endl;
 103                         continue;
 104                 }
 105                 else if (inFlag(flag, EXPLODE_NO_TOKEN))
 106                 {
 107                         // TODO: Catch special case of categoryless setting
 108                         Out::debug << "Not Implemented: Categoryless setting, skipped it" << Out::endl;
 109                         continue;
 110                 }
 111                 else
 112                 {
 113                         // Check for existing category
 114                         TiXmlElement *categoryElement = NULL;
 115                         TiXmlNode *categoryNode = NULL;
 116                         while((categoryNode = root->IterateChildren(categoryNode)) != 0)
 117                         {
 118                                 categoryElement = categoryNode->Clone()->ToElement();
 119                                 if (std::string(categoryElement->Attribute("name")) == substrings[0])
 120                                         break;
 121                                 delete categoryElement;
 122                                 categoryElement = NULL;
 123                         }
 124                         delete categoryElement;
 125                         categoryElement = NULL;
 126
 127                         // No matching category found: Create it
 128                         if (categoryNode == NULL)
 129                         {
 130                                 categoryElement = new TiXmlElement("category");
 131                                 categoryElement->SetAttribute("name", substrings[0].c_str());
 132                                 root->LinkEndChild(categoryElement);
 133                         }
 134                         else
 135                         {
 136                                 categoryElement = categoryNode->ToElement();
 137                         }
 138
 139
 140                         // Create setting
 141                         TiXmlElement *element = new TiXmlElement("setting");
 142                         element->SetAttribute("name", substrings[1].c_str());
 143
 144                         // Set the type of the setting
 145                         // FIXME: This is both BUGGY and UGLY
 146                         if (s2str::isInteger(value))
 147                         {
 148                                 element->SetAttribute("type", "int");
 149                         }
 150                         else if (s2str::isDecimal(value))
 151                         {
 152                                 element->SetAttribute("type", "float");
 153                         }
 154                         else if (s2str::isBool(value))
 155                         {
 156                                 element->SetAttribute("type", "bool");
 157                         }
 158                         else
 159                         {
 160                                 element->SetAttribute("type", "string");
 161                         }
 162
 163                         categoryElement->LinkEndChild(element);
 164
 165                         // Store value in setting
 166                         TiXmlText *text = new TiXmlText(value.c_str());
 167                         element->LinkEndChild(text);
 168
 169                 }
 170         }
 171
 172         if (!xml.SaveFile(this->configPath.c_str()))
 173         {
 174                 Out::fatal << "Error when writing config file: " << xml.ErrorDesc() << Out::endl;
 175                 return false;
 176         }
 177
 178         return true;
 179 }
 180
 181 bool
 182 GlobalSettings::readConfigFile()
 183 {
 184         TiXmlDocument xml(this->configPath.c_str());
 185         // Check for regular file problems.
 186         if (!xml.LoadFile())
 187         {
 188                 Out::fatal << "Error when reading config file: " << xml.ErrorDesc() << Out::endl;
 189                 return false;
 190         }
 191
 192         TiXmlHandle handle(&xml);
 193         TiXmlElement *root;
 194
 195         root = handle.FirstChild("config").ToElement();
 196
 197         // Make sure that the top-level of our XML file is <config>
 198         if (!root)
 199         {
 200                 Out::fatal << "Invalid Markup: Top level element in config file is not <config> or missing" << Out::endl;
 201                 return false;
 202         }
 203
 204         for (TiXmlElement *e = root->FirstChild("category")->ToElement(); e; e = e->NextSiblingElement())
 205         {
 206                 for (TiXmlElement *f = e->FirstChild("setting")->ToElement(); f; f = f->NextSiblingElement())
 207                 {
 208                         std::string category = std::string(e->Attribute("name"));
 209                         std::string type = std::string(f->Attribute("type"));
 210                         std::string name = std::string(f->Attribute("name"));
 211                         std::string value = std::string(f->GetText());
 212                         if (type == "int")
 213                         {
 214                                 if (s2str::isInteger(value))
 215                                 {
 216                                         this->setSetting(category + "_" + name, value);
 217                                 }
 218                                 else
 219                                 {
 220                                         Out::error << "Invalid int value for setting with name \"" << name << "\" in config file!" << Out::endl;
 221                                 }
 222
 223                         }
 224                         else if (type == "float")
 225                         {
 226                                 if (s2str::isDecimal(value))
 227                                 {
 228                                         this->setSetting(category + "_" + name, value);
 229                                 }
 230                                 else
 231                                 {
 232                                         Out::error << "Invalid float value for setting with name \"" << name << "\" in config file!" << Out::endl;
 233                                 }
 234                         }
 235                         else if (type == "bool")
 236                         {
 237                                 if (s2str:: isBool(value))
 238                                 {
 239                                         this->setSetting(category + "_" + name, value);
 240                                 }
 241                                 else
 242                                 {
 243                                         Out::error << "Invalid bool value for setting with name \"" << name << "\" in config file!" << Out::endl;
 244                                 }
 245                         }
 246                         else if (type == "string")
 247                         {
 248                                 this->setSetting(category + "_" + name, value);
 249                         }
 250                         else
 251                         {
 252                                 Out::error << "Invalid type of setting with name \"" << name << "\" in config file!" << Out::endl;
 253                         }
 254                 }
 255         }
 256
 257         return true;
 258 }
 259
 260 std::string
 261 GlobalSettings::getSetting(const std::string &setting)
 262 {
 263         std::map<std::string, std::string>::iterator settingIterator;
 264         if (settings.empty())
 265                 return "";
 266
 267         settingIterator = settings.find(setting);
 268         if (settingIterator != settings.end())
 269                 return settingIterator->second;
 270         else
 271                 return "";
 272 }
 273
 274 std::string
 275 GlobalSettings::getTemporary(const std::string &setting)
 276 {
 277         std::map<std::string, std::string>::iterator settingIterator;
 278         if (tempSettings.empty())
 279                 return "";
 280
 281         settingIterator = tempSettings.find(setting);
 282         if (settingIterator != tempSettings.end())
 283                 return settingIterator->second;
 284         else
 285                 return "";
 286 }
 287
 288 void
 289 GlobalSettings::setSetting(const std::string &setting, const std::string &settingString)
 290 {
 291         settings[setting] = settingString;
 292 }
 293
 294 void
 295 GlobalSettings::setTemporary(const std::string &setting, const std::string &settingString)
 296 {
 297         tempSettings[setting] = settingString;
 298 }
 299
 300