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