gameserv-2.0/libgameservgldl/src/DataLayer/File/FileArmorDAO.cpp

   1 #include <GameServ/DataLayer/File/FileArmorDAO.h>
   2 using GameServ::DataLayer::File::FileArmorDAO;
   3 #include <GameServ/GameLayer/GameObjects/ArmorGO.h>
   4 using GameServ::GameLayer::GameObjects::ArmorGO;
   5
   6 #include <GameServ/DataLayer/DataLayerExceptions.h>
   7 using GameServ::DataLayer::Exceptions::ResourceException;
   8 using GameServ::DataLayer::Exceptions::DataLayerException;
   9
  10 #include <GameServ/DataLayer/File/FileId.h>
  11 using GameServ::DataLayer::File::FileId;
  12
  13 #include <GameServ/Types.h>
  14 using GameServ::Types::ItemTypes;
  15 using GameServ::Types::Modifiers;
  16
  17 #include <boost/shared_ptr.hpp>
  18 #include <boost/format.hpp>
  19 #include <boost/algorithm/string.hpp>
  20 #include <boost/lexical_cast.hpp>
  21 using boost::shared_ptr;
  22 using boost::format;
  23 using boost::str;
  24 using boost::algorithm::to_upper;
  25 using boost::lexical_cast;
  26 #include <boost/tokenizer.hpp>
  27 typedef boost::tokenizer<boost::char_separator<char> >
  28     tokenizer;
  29
  30 #include <string>
  31 using std::string;
  32
  33 #include <fstream>
  34 using std::ifstream;
  35 using std::getline;
  36 using std::ofstream;
  37 using std::endl;
  38
  39 #include <map>
  40 using std::map;
  41
  42 // TODO: Switch filename to be loaded from a config file
  43 FileArmorDAO::FileArmorDAO() : mFilename("data/items/masteritems.dat")
  44 {
  45         Initialize(GetArmorFilePath());
  46 }
  47
  48 FileArmorDAO::FileArmorDAO(const string &filename)
  49 {
  50         Initialize(filename);
  51 }
  52
  53 FileArmorDAO::~FileArmorDAO()
  54 {
  55 }
  56
  57 void FileArmorDAO::Initialize(const string &filename)
  58 {
  59         mFilename = filename;
  60         LoadArmorCache();
  61 }
  62
  63 string FileArmorDAO::GetArmorFilePath() const
  64 {
  65         return mFilename;
  66 }
  67
  68 shared_ptr<ArmorGO> FileArmorDAO::GetById(const string &Id) const
  69 {
  70         string line;
  71         ifstream infile;
  72         infile.open(GetArmorFilePath().c_str());
  73
  74         if (infile.fail())
  75         {
  76                 throw ResourceException(str(format("Unable to open file %1%") % GetArmorFilePath()), __FILE__, __LINE__);
  77         }
  78
  79
  80         while (getline(infile, line))
  81         {
  82                 shared_ptr<ArmorGO> spArmor = CreateArmorFromLine(line);
  83                 if (spArmor->Id() == Id)
  84                 {
  85                         return spArmor;
  86                 }
  87         }
  88         return shared_ptr<ArmorGO>();
  89 }
  90
  91 shared_ptr<ArmorGO> FileArmorDAO::CreateArmorFromLine(const string &line) const
  92 {
  93         assert(!line.empty());
  94         shared_ptr<ArmorGO> spArmor;
  95         map<Modifiers::Modifier, int> modifiers;
  96         spArmor = shared_ptr<ArmorGO>(new ArmorGO());
  97         boost::char_separator<char> sep("~", 0, boost::keep_empty_tokens);
  98         tokenizer tokens(line, sep);
  99         tokenizer::iterator tok_iter = tokens.begin();
 100         if ((*tok_iter) != "2")
 101                 return shared_ptr<ArmorGO>();
 102         tok_iter++;
 103         spArmor->Id(FileId::CreateItemId(ItemTypes::Armor, (*tok_iter)));
 104
 105         tok_iter++;
 106         spArmor->Name((*tok_iter));
 107         tok_iter++;
 108         spArmor->Price(lexical_cast<unsigned long int>((*tok_iter)));
 109         tok_iter++;
 110         spArmor->Uses(lexical_cast<int>((*tok_iter)));
 111         tok_iter++;
 112         modifiers[Modifiers::strength] = lexical_cast<int>((*tok_iter));
 113         tok_iter++;
 114         modifiers[Modifiers::defense] = lexical_cast<int>((*tok_iter));
 115         tok_iter++;
 116         modifiers[Modifiers::maxhp] = lexical_cast<int>((*tok_iter));
 117         tok_iter++;
 118         modifiers[Modifiers::hp] = lexical_cast<int>((*tok_iter));
 119         tok_iter++;
 120         modifiers[Modifiers::forestfights] = lexical_cast<int>((*tok_iter));
 121         tok_iter++;
 122         modifiers[Modifiers::playerfights] = lexical_cast<int>((*tok_iter));
 123         tok_iter++;
 124         modifiers[Modifiers::gold] = lexical_cast<int>((*tok_iter));
 125         tok_iter++;
 126         modifiers[Modifiers::bank] = lexical_cast<int>((*tok_iter));
 127         spArmor->Modifiers(modifiers);
 128
 129         return spArmor;
 130 }
 131 bool FileArmorDAO::IdExists(const string &Id) const
 132 {
 133         map<string, shared_ptr<ArmorGO> >::const_iterator iter;
 134         iter = spArmorCache.find(Id);
 135         return (iter != spArmorCache.end());
 136 }
 137
 138 void FileArmorDAO::LoadArmorCache(void)
 139 {
 140         ifstream infile;
 141         infile.open(mFilename.c_str());
 142
 143         if (infile.fail())
 144         {
 145                 throw DataLayerException(str(format("Unable to open %1% for reading") % mFilename), __FILE__, __LINE__);
 146         }
 147         string line;
 148         while (getline(infile, line))
 149         {
 150                 if (line.length() == 0)
 151                 {
 152                         continue;
 153                 }
 154                 if (line[0] == '#')
 155                 {
 156                         continue;
 157                 }
 158                 shared_ptr<ArmorGO> spArmor = CreateArmorFromLine(line);
 159                 if (spArmor != 0)
 160                 {
 161                         spArmorCache[spArmor->Id()] = spArmor;
 162                 }
 163         }
 164         infile.close();
 165 }