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

   1 #include <GameServ/DataLayer/File/FileItemDAO.h>
   2 using GameServ::DataLayer::File::FileItemDAO;
   3 #include <GameServ/GameLayer/GameObjects/ItemGO.h>
   4 using GameServ::GameLayer::GameObjects::ItemGO;
   5 #include <GameServ/GameLayer/GameObjects/ArmorGO.h>
   6 using GameServ::GameLayer::GameObjects::ArmorGO;
   7 #include <GameServ/GameLayer/GameObjects/WeaponGO.h>
   8 using GameServ::GameLayer::GameObjects::WeaponGO;
   9 #include <GameServ/GameLayer/GameObjects/PotionGO.h>
  10 using GameServ::GameLayer::GameObjects::PotionGO;
  11
  12 #include <GameServ/DataLayer/DataLayerExceptions.h>
  13 using GameServ::DataLayer::Exceptions::ResourceException;
  14 using GameServ::DataLayer::Exceptions::DataLayerException;
  15
  16 #include <GameServ/DataLayer/File/FileId.h>
  17 using GameServ::DataLayer::File::FileId;
  18
  19 #include <GameServ/Types.h>
  20 using GameServ::Types::ItemTypes;
  21 using GameServ::Types::Modifiers;
  22 using GameServ::Types::Exceptions::TypeException;
  23
  24 #include <boost/shared_ptr.hpp>
  25 #include <boost/format.hpp>
  26 #include <boost/algorithm/string.hpp>
  27 #include <boost/lexical_cast.hpp>
  28 using boost::shared_ptr;
  29 using boost::format;
  30 using boost::str;
  31 using boost::algorithm::to_upper;
  32 using boost::lexical_cast;
  33 #include <boost/tokenizer.hpp>
  34 typedef boost::tokenizer<boost::char_separator<char> >
  35     tokenizer;
  36
  37 #include <string>
  38 using std::string;
  39
  40 #include <fstream>
  41 using std::ifstream;
  42 using std::getline;
  43 using std::ofstream;
  44 using std::endl;
  45
  46 #include <map>
  47 using std::map;
  48
  49 // TODO: Switch filename to be loaded from a config file
  50 FileItemDAO::FileItemDAO() : mFilename("data/items/masteritems.dat")
  51 {
  52         Initialize(GetItemFilePath());
  53 }
  54
  55 FileItemDAO::FileItemDAO(const string &filename)
  56 {
  57         Initialize(filename);
  58 }
  59
  60 FileItemDAO::~FileItemDAO()
  61 {
  62 }
  63
  64 void FileItemDAO::Initialize(const string &filename)
  65 {
  66         mFilename = filename;
  67         LoadItemCache();
  68 }
  69
  70 string FileItemDAO::GetItemFilePath() const
  71 {
  72         return mFilename;
  73 }
  74
  75 shared_ptr<ItemGO> FileItemDAO::GetById(const string &Id) const
  76 {
  77         string line;
  78         ifstream infile;
  79         infile.open(GetItemFilePath().c_str());
  80
  81         if (infile.fail())
  82         {
  83                 throw ResourceException(str(format("Unable to open file %1%") % GetItemFilePath()), __FILE__, __LINE__);
  84         }
  85
  86
  87         while (getline(infile, line))
  88         {
  89                 if (line.empty())
  90                 {
  91                         continue;
  92                 }
  93                 if (line[0] == '#')
  94                 {
  95                         continue;
  96                 }
  97                 size_t tilde1 = line.find_first_of("~");
  98                 if (tilde1 == string::npos)
  99                 {
 100                         throw DataLayerException(str(format("Invalid Item in %1%: %2%") % mFilename % line), __FILE__,
 101                                 __LINE__);
 102                 }
 103                 size_t tilde2 = line.find_first_of("~", tilde1 + 1);
 104                 if (tilde2 == string::npos)
 105                 {
 106                         throw DataLayerException(str(format("Invalid Item in %1%: %2%") % mFilename % line), __FILE__,
 107                                 __LINE__);
 108                 }
 109                 string lineId = FileId::CreateItemId(line.substr(tilde1 + 1, tilde2 - tilde1 - 1));
 110
 111                 if (lineId == Id)
 112                 {
 113                         shared_ptr<ItemGO> spItem = CreateItemFromLine(line);
 114                         return spItem;
 115                 }
 116         }
 117         return shared_ptr<ItemGO>();
 118 }
 119
 120 shared_ptr<ItemGO> FileItemDAO::CreateItemFromLine(const string &line) const
 121 {
 122         assert(!line.empty());
 123         shared_ptr<ItemGO> spItem;
 124         map<Modifiers::Modifier, int> modifiers;
 125         boost::char_separator<char> sep("~", 0, boost::keep_empty_tokens);
 126         tokenizer tokens(line, sep);
 127         tokenizer::iterator tok_iter = tokens.begin();
 128
 129         ItemTypes::ItemType type;
 130
 131         try
 132         {
 133                 type = ItemTypes::Parse((*tok_iter));
 134         }
 135         catch (TypeException)
 136         {
 137                 return shared_ptr<ItemGO>();
 138         }
 139
 140         switch(type)
 141         {
 142         case ItemTypes::Weapon:
 143                 spItem = shared_ptr<WeaponGO>(new WeaponGO());
 144                 break;
 145         case ItemTypes::Armor:
 146                 spItem = shared_ptr<ArmorGO>(new ArmorGO());
 147                 break;
 148         case ItemTypes::Potion:
 149                 spItem = shared_ptr<PotionGO>(new PotionGO());
 150         default:
 151                 throw DataLayerException(str(format("Unknown Item type: %1%") % type), __FILE__, __LINE__);
 152         }
 153         tok_iter++;
 154         spItem->Id(FileId::CreateItemId((*tok_iter)));
 155
 156         tok_iter++;
 157         spItem->Name((*tok_iter));
 158         tok_iter++;
 159         spItem->Price(lexical_cast<unsigned long int>((*tok_iter)));
 160         tok_iter++;
 161         spItem->Uses(lexical_cast<int>((*tok_iter)));
 162         tok_iter++;
 163         modifiers[Modifiers::strength] = lexical_cast<int>((*tok_iter));
 164         tok_iter++;
 165         modifiers[Modifiers::defense] = lexical_cast<int>((*tok_iter));
 166         tok_iter++;
 167         modifiers[Modifiers::maxhp] = lexical_cast<int>((*tok_iter));
 168         tok_iter++;
 169         modifiers[Modifiers::hp] = lexical_cast<int>((*tok_iter));
 170         tok_iter++;
 171         modifiers[Modifiers::forestfights] = lexical_cast<int>((*tok_iter));
 172         tok_iter++;
 173         modifiers[Modifiers::playerfights] = lexical_cast<int>((*tok_iter));
 174         tok_iter++;
 175         modifiers[Modifiers::gold] = lexical_cast<int>((*tok_iter));
 176         tok_iter++;
 177         modifiers[Modifiers::bank] = lexical_cast<int>((*tok_iter));
 178         spItem->Modifiers(modifiers);
 179
 180         return spItem;
 181 }
 182 bool FileItemDAO::IdExists(const string &Id) const
 183 {
 184         map<string, shared_ptr<ItemGO> >::const_iterator iter;
 185         iter = spItemCache.find(Id);
 186         return (iter != spItemCache.end());
 187 }
 188
 189 void FileItemDAO::LoadItemCache(void)
 190 {
 191         ifstream infile;
 192         infile.open(mFilename.c_str());
 193
 194         if (infile.fail())
 195         {
 196                 throw DataLayerException(str(format("Unable to open %1% for reading") % mFilename), __FILE__, __LINE__);
 197         }
 198         string line;
 199         while (getline(infile, line))
 200         {
 201                 if (line.length() == 0)
 202                 {
 203                         continue;
 204                 }
 205                 if (line[0] == '#')
 206                 {
 207                         continue;
 208                 }
 209                 shared_ptr<ItemGO> spItem = CreateItemFromLine(line);
 210                 if (spItem != 0)
 211                 {
 212                         spItemCache[spItem->Id()] = spItem;
 213                 }
 214         }
 215         infile.close();
 216 }