gameserv/loadsave.cpp

   1  /* This file includes functions that deal with loading and
   2     saving to and from files. It also includes some miscellaneous related
   3     functions */
   4
   5  #include "extern.h"
   6  #include "level.h"
   7  #include "player.h"
   8  #include "aClient.h"
   9  #include "item.h"
  10  #include "pouch.h"
  11  #include "toplist.h"
  12  #include "flags.h"
  13
  14  #include <fstream>
  15
  16  using namespace std;
  17
  18  bool load_masters()
  19 {
  20   ifstream infile(masterdata);
  21   char *buf;
  22   int l = 0;
  23   buf = new char[1024];
  24
  25   if (infile.fail())
  26     {
  27           log("Error opening %s", masterdata);
  28           return false;
  29     }
  30
  31 #ifdef DEBUGMODE
  32   log("Loading masters from %s", masterdata);
  33 #endif
  34
  35   for (l = 0; l < LEVELS - 1; l++)
  36     {
  37           infile.getline(buf, 1024, '\n');
  38
  39           log("%s", buf);
  40           if (buf[0] == '#' || buf[0] == '\n' || buf[0] == '\r')
  41                 {
  42                   l--;
  43                   continue;
  44                 }
  45           else if (buf[0] == '^')
  46             break;
  47
  48           Monster *master = &levels[l].master;
  49
  50           char *name, *weapon, *strength, *gold, *exp, *maxhp, *death;
  51
  52
  53           name = strtok(buf, "~");
  54           weapon = strtok(NULL, "~");
  55           strength = strtok(NULL, "~");
  56           gold = strtok(NULL, "~");
  57           exp = strtok(NULL, "~");
  58           maxhp = strtok(NULL, "~");
  59           death = strtok(NULL, "~");
  60
  61           master->name = name;
  62           master->weapon = weapon;
  63           master->strength = stringtoint(strength);
  64           master->gold = stringtoint(gold);
  65           master->exp = stringtoint(exp);
  66           master->maxhp = stringtoint(maxhp);
  67           master->hp = master->maxhp;
  68           master->death = death;
  69     }
  70
  71   delete []buf;
  72
  73   if (l < LEVELS - 1)  // We didn't load a master for every level - check data/masters.dat
  74         return false;
  75   else
  76         return true;
  77 }
  78
  79 void delete_monsters()
  80 {
  81   for (int x = 0; x < LEVELS; x++)
  82         levels[x].monsters.clear();
  83 }
  84
  85 int save_gs_dbase()
  86 {
  87   list<Player*>::iterator iter;
  88   Player *it;
  89   ofstream outfile;
  90
  91   outfile.open(playerdata);
  92
  93   if (!outfile)
  94     {
  95           log("Error opening %s", playerdata);
  96           return 0;
  97     }
  98
  99   for (unsigned long x = 0; x < U_TABLE_SIZE; x++)
 100         {
 101           for(iter = players[x].begin(); iter != players[x].end(); iter++)
 102                 {
 103                   it = (*iter);
 104                   clearYourTurn(it);
 105                   item *w, *a;
 106                   w = it->getWeapon();
 107                   a = it->getArmor();
 108
 109                   outfile << it->getName().c_str() << ' ' << it->getLevel() << ' ' << it->getExp() << ' ' << it->getGold() << ' ' << it->getBank() << ' '<< it->getHP() << ' ' << it->getMaxHP() << ' ' << it->getStrength() << ' ' << it->getDefense() << ' ' << it->getForestFights() << ' ' << it->getPlayerFights() <<  ' ' << it->getFlags() << ' ' << it->getPassword().c_str() << ' ' << it->lastlogin << ' ' << (w ? w->getID() : 0) << ' ' << (a ? a->getID() : 0);
 110
 111                   // Traverse the list and write out each item ID and how many uses are left
 112                   if (!it->inventory->isEmpty())
 113                         {
 114                           list<itemContainer> *myitems;
 115                           list<itemContainer>::iterator item_iter;
 116                           myitems = it->inventory->getItems();
 117
 118                           for(item_iter = myitems->begin();item_iter != myitems->end();item_iter++)
 119                                 {
 120                                   outfile << ' ' << (*item_iter).getItem()->getID() << ' ' << (*item_iter).getUses();
 121                                 }
 122                         }
 123                   outfile << endl;
 124                 }
 125         }
 126   outfile.close();
 127   return 1;
 128 }
 129
 130 int load_dragon()
 131 {
 132     ifstream infile;
 133     char *buf;
 134
 135     infile.open(dragondata);
 136
 137     if (infile.fail())
 138     {
 139         infile.clear();
 140         log ("Error opening %s. Trying initialdragon.dat", dragondata);
 141         infile.open("data/initialdragon.dat");
 142         if (infile.fail())
 143         {
 144             log ("Error opening data/initialdragon.dat");
 145             return 0;
 146         }
 147     }
 148
 149     buf = new char[1024];
 150
 151     infile.getline(buf, 1024, '\n');
 152     infile.close(); // Done with the file... we have what we want
 153
 154     dragon.name = strtok(buf, "~");
 155     dragon.weapon = strtok(NULL, "~");
 156     dragon.gold = 0;
 157     dragon.exp = 0;
 158     dragon.strength = stringtoint(strtok(NULL, "~"));
 159     dragon.hp = stringtoint(strtok(NULL, "~"));
 160     dragon.defense = stringtoint(strtok(NULL, "~"));
 161     dragon.death = strtok(NULL, "");
 162
 163     log ("loaded dragon: %s", dragon.name.c_str());
 164
 165     delete []buf;
 166
 167 return save_dragon();  // Save the dragon file and return the status code :)
 168 }
 169
 170 int save_dragon()
 171 {
 172     ofstream outfile;
 173
 174     outfile.open(dragondata);
 175
 176     if (outfile.fail())
 177     {
 178         log ("Error opening %s. Exiting.", dragondata);
 179         return 0;
 180     }
 181
 182     outfile << dragon.name.c_str() << '~' << dragon.weapon.c_str() << '~'
 183                 << dragon.strength << '~' << dragon.hp << '~'
 184                 << dragon.defense << '~' << dragon.death.c_str() << "\n^"
 185                 << endl;
 186
 187 outfile.close();
 188
 189 return 1;
 190 }
 191
 192 int load_store()
 193 {
 194   ifstream infile;
 195   char *buf;
 196   item *tempItem;
 197   buf = new char[1024];
 198   long id;
 199
 200   infile.open(storeitemdata);
 201
 202   if (infile.fail())
 203     {
 204       log("Error opening %s", storeitemdata);
 205       return 0;
 206     }
 207
 208   while (infile.getline(buf, 1024, '\n'))
 209     {
 210       try
 211         {
 212           if (buf[0] != '#' && buf[0] != '\n' && buf[0] != '\0')
 213             {
 214               item *tempItem2;
 215               id = stringtoint(strtok(buf, ""));
 216               tempItem2 = findItemByID(id);
 217               if (tempItem2 == NULL)
 218                 {
 219                   log("Invalid ID in %s", storeitemdata);
 220                   return 0;
 221                 }
 222
 223               tempItem = tempItem2;
 224               store.push_back(tempItem);
 225             }
 226         }
 227       catch (char *str)
 228         {
 229           log("Exception loading store: %s", str);
 230           delete []buf;
 231           return 0;
 232         }
 233     }
 234   delete []buf;
 235   return 1;
 236 }
 237 int load_tavern()
 238 {
 239   ifstream infile;
 240   char *buf;
 241   tavernItem tempItem;
 242   buf = new char[1024];
 243   long id, level;
 244
 245   infile.open(tavernitemdata);
 246   if (infile.fail())
 247     {
 248       log("Error opening %s", tavernitemdata);
 249       return 0;
 250     }
 251
 252   while (infile.getline(buf, 1024, '\n'))
 253     {
 254       try
 255         {
 256           if (buf[0] != '#' && buf[0] != '\n' && buf[0] != '\0')
 257             {
 258               item *tempItem2;
 259               id = stringtoint(strtok(buf, "~"));
 260               level = stringtoint(strtok(NULL, ""));
 261               tempItem2 = findItemByID(id);
 262               if (tempItem2 == NULL)
 263                 {
 264                   log("Invalid ID in %s", tavernitemdata);
 265                   return 0;
 266                 }
 267               tempItem.setItem(tempItem2);
 268               tempItem.setLevel(level);
 269               tavern.push_back(tempItem);
 270             }
 271         }
 272       catch (char *str)
 273         {
 274           log("Exception loading tavern: %s", str);
 275           delete []buf;
 276           return 0;
 277         }
 278     }
 279   delete []buf;
 280   return 1;
 281 }
 282 int load_items()
 283 {
 284   ifstream infile;
 285   char *buf;
 286   item *tempItem;
 287
 288   buf = new char[1024];
 289
 290   infile.open(itemdata);
 291
 292   if (infile.fail())
 293     {
 294       log("Error opening %s", itemdata);
 295       return 0;
 296     }
 297
 298   while (infile.getline(buf, 1024, '\n'))
 299     {
 300       if (buf[0] == '^')
 301                 break;
 302       try
 303                 {
 304                   if (buf[0] != '#' && buf[0] != '\n' && buf[0] != '\0')
 305                         {
 306                           switch(buf[0])
 307                                 {
 308                                 case '1':
 309                                   tempItem = new weapon();
 310                                   break;
 311                                 case '2':
 312                                   tempItem = new armor();
 313                                   break;
 314                                 case '3':
 315                                   tempItem = new potion();
 316                                   break;
 317                                 default:
 318                                   log("Invalid Item Type %c in %s", buf[0], itemdata);
 319                                   delete []buf;
 320                                   return 0;
 321                                   break;
 322                                 }
 323                           if(tempItem->setData(buf))
 324                                 {
 325                                   Items.push_back(tempItem);
 326                                 }
 327                         }
 328                 }
 329       catch (char *str)
 330                 {
 331                   log("Exception loading items: %s", str);
 332                   delete []buf;
 333                   return 0;
 334                 }
 335     }
 336   delete []buf;
 337   return 1;
 338 }
 339
 340 int load_gs_dbase()
 341 {
 342   ifstream infile;
 343   Player *p;
 344   char *tempname, *buf, *password;
 345   int tempnum;
 346   buf = new char[100000];
 347
 348   infile.open(playerdata);
 349
 350   if (infile.fail())
 351     {
 352           log("Error opening %s", playerdata);
 353           return 0;
 354     }
 355
 356
 357   for (int x = 0; x < U_TABLE_SIZE; x++)
 358     {
 359           list<Player*>::iterator iter;
 360
 361           for (iter = players[x].begin(); iter != players[x].end(); iter++)
 362                 {
 363                   logout((*iter)->getClient());
 364                   delete (*iter);
 365                 }
 366           players[x].clear();
 367     }
 368
 369   while (infile.getline(buf, 100000, '\n'))
 370         {
 371           tempname = strtok(buf, " ");
 372           p = new Player(tempname);
 373
 374           p->setLevel(stringtoint(strtok(NULL, " ")));
 375           p->setExp(stringtoint(strtok(NULL, " ")));
 376           p->setGold(stringtoint(strtok(NULL, " ")));
 377           p->setBank(stringtoint(strtok(NULL, " ")));
 378           tempnum = stringtoint(strtok(NULL, " "));
 379           p->setMaxHP(stringtoint(strtok(NULL, " ")));
 380           p->setHP(tempnum);
 381           p->setStrength(stringtoint(strtok(NULL, " ")));
 382           p->setDefense(stringtoint(strtok(NULL, " ")));
 383           p->setForestFights(stringtoint(strtok(NULL, " ")));
 384           p->setPlayerFights(stringtoint(strtok(NULL, " ")));
 385           p->setFlags(stringtoint(strtok(NULL, " ")));
 386
 387
 388
 389           password = strtok(NULL, " ");
 390           p->setRawPassword(password);
 391           tempname = strtok(NULL, " ");
 392
 393           if (tempname)
 394                 p->lastlogin = stringtoint(tempname);
 395           else
 396                 p->lastlogin = time(NULL);
 397
 398           tempname = strtok(NULL, " ");
 399           tempnum = stringtoint(tempname);
 400           item *tempitem;
 401           if (tempnum != 0)
 402                 {
 403                   tempitem = findItemByID(tempnum);
 404                   p->setWeapon(*tempitem);
 405                 }
 406
 407           tempname = strtok(NULL, " ");
 408           tempnum = stringtoint(tempname);
 409
 410           if (tempnum != 0)
 411                 {
 412                   tempitem = findItemByID(tempnum);
 413                   p->setArmor(*tempitem);
 414                 }
 415
 416
 417           unsigned long hv = iHASH((unsigned char *) p->getName().c_str());
 418
 419           p->setClient(NULL);
 420
 421           for (tempname = strtok(NULL, " "); tempname != NULL; tempname = strtok(NULL, " "))
 422                 {
 423                   long int id, uses;
 424                   list<item*>::iterator item_iter;
 425                   id = stringtoint(tempname);
 426                   tempname = strtok(NULL, " ");
 427                   uses = stringtoint(tempname);
 428
 429                   item_iter = Items.begin();
 430                   while (item_iter != Items.end())
 431                         {
 432                           if ((*item_iter)->getID() == id)
 433                                 {
 434                                   // Don't sort every time you add an item or it eats CPU
 435                                   p->inventory->addItemNoChecks((*item_iter))->setUses(uses);
 436                                 }
 437                           item_iter++;
 438                         }
 439                 }
 440           p->inventory->sort();
 441      myToplist.insertPlayer(p);
 442           players[hv].push_back(p);
 443         }
 444
 445   delete [] buf;
 446   infile.close();
 447   return 1;
 448 }
 449
 450 bool load_levels()
 451 {
 452   char *filename;
 453   filename = new char[256];
 454
 455   for (int x = 1; x <= LEVELS; x++)
 456     {
 457           sprintf(filename, "data/levels/level%d.dat", x);
 458           if (levels[x - 1].loadLevel(filename) == false)
 459                 {
 460                   delete []filename;
 461                   return false;
 462                 }
 463     }
 464
 465   delete []filename;
 466   return true;
 467 }
 468
 469 bool load_monsters()
 470 {
 471   char *filename;
 472   ifstream infile;
 473   char *buf;
 474   buf = new char[2048];
 475
 476   for (int level = 1; level <= LEVELS; level++)
 477         {
 478           filename = new char[256];
 479           sprintf(filename, "data/monsters/level%d.dat", level);
 480           infile.open(filename);
 481
 482           if (!infile)
 483                 {
 484                   log("Error opening %s", filename);
 485                   delete []filename;
 486                   delete []buf;
 487                   return false;
 488                 }
 489
 490 #ifdef DEBUGMODE
 491           log("Loading monsters from %s", filename);
 492 #endif
 493
 494           while (infile.getline(buf, 2048))
 495                 {
 496                   if (buf[0] == '^')
 497                         break;
 498                   if (buf[0] == '\n' || buf[0] == '\0' || buf[0] == '#')
 499                         continue;
 500                   Monster *temp;
 501                   temp = new Monster;
 502
 503                   temp->name = strtok(buf, "~");
 504                   temp->weapon = strtok(NULL, "~");
 505                   temp->death = strtok(NULL, "~");
 506
 507                   levels[level - 1].monsters.push_back(temp);
 508
 509                 }
 510           delete [] filename;
 511           infile.close();
 512         }
 513   delete [] buf;
 514   return true;
 515 }
 516
 517
 518