ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/server/login.C
(Generate patch)

Comparing deliantra/server/server/login.C (file contents):
Revision 1.18 by root, Thu Sep 14 22:34:04 2006 UTC vs.
Revision 1.36 by root, Sat Dec 30 10:16:11 2006 UTC

… …
20 20
21 The authors can be reached via e-mail at <crossfire@schmorp.de> 21 The authors can be reached via e-mail at <crossfire@schmorp.de>
22*/ 22*/
23 23
24#include <global.h> 24#include <global.h>
25#ifndef __CEXTRACT__
26# include <sproto.h> 25#include <sproto.h>
27#endif
28#include <spells.h> 26#include <spells.h>
29#include <loader.h> 27#include <loader.h>
30#include <define.h> 28#include <define.h>
31 29
32extern void sub_weight (object *, signed long); 30extern void sub_weight (object *, signed long);
33extern void add_weight (object *, signed long); 31extern void add_weight (object *, signed long);
34extern long pticks; 32extern long pticks;
35
36/* If flag is non zero, it means that we want to try and save everyone, but
37 * keep the game running. Thus, we don't want to free any information.
38 */
39void
40emergency_save (int flag)
41{
42 player *pl;
43
44#ifndef NO_EMERGENCY_SAVE
45 trying_emergency_save = 1;
46 if (editor)
47 return;
48 LOG (llevError, "Emergency save: ");
49 for (pl = first_player; pl != NULL; pl = pl->next)
50 {
51 if (!pl->ob)
52 {
53 LOG (llevError, "No name, ignoring this.\n");
54 continue;
55 }
56 LOG (llevError, "%s ", pl->ob->name);
57 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Emergency save...");
58
59/* If we are not exiting the game (ie, this is sort of a backup save), then
60 * don't change the location back to the village. Note that there are other
61 * options to have backup saves be done at the starting village
62 */
63 if (!flag)
64 {
65 strcpy (pl->maplevel, first_map_path);
66 if (pl->ob->map != NULL)
67 pl->ob->map = NULL;
68 pl->ob->x = -1;
69 pl->ob->y = -1;
70 }
71 if (!save_player (pl->ob, flag))
72 {
73 LOG (llevError, "(failed) ");
74 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Emergency save failed, checking score...");
75 }
76 check_score (pl->ob);
77 }
78 LOG (llevError, "\n");
79#else
80 LOG (llevInfo, "Emergency saves disabled, no save attempted\n");
81#endif
82 /* If the game is exiting, remove the player locks */
83 if (!flag)
84 {
85 for (pl = first_player; pl != NULL; pl = pl->next)
86 {
87 if (pl->ob)
88 {
89 }
90 }
91 }
92}
93 33
94/* Delete character with name. if new is set, also delete the new 34/* Delete character with name. if new is set, also delete the new
95 * style directory, otherwise, just delete the old style playfile 35 * style directory, otherwise, just delete the old style playfile
96 * (needed for transition) 36 * (needed for transition)
97 */ 37 */
… …
99delete_character (const char *name, int newchar) 39delete_character (const char *name, int newchar)
100{ 40{
101 char buf[MAX_BUF]; 41 char buf[MAX_BUF];
102 42
103 sprintf (buf, "%s/%s/%s.pl", settings.localdir, settings.playerdir, name); 43 sprintf (buf, "%s/%s/%s.pl", settings.localdir, settings.playerdir, name);
44
104 if (unlink (buf) == -1) 45 if (unlink (buf) == -1)
105 LOG (llevDebug, "Cannot delete character file %s: %s\n", buf, strerror (errno)); 46 LOG (llevDebug, "Cannot delete character file %s: %s\n", buf, strerror (errno));
47
106 if (newchar) 48 if (newchar)
107 { 49 {
108 sprintf (buf, "%s/%s/%s", settings.localdir, settings.playerdir, name); 50 sprintf (buf, "%s/%s/%s", settings.localdir, settings.playerdir, name);
109 /* this effectively does an rm -rf on the directory */ 51 /* this effectively does an rm -rf on the directory */
110 remove_directory (buf); 52 remove_directory (buf);
111 } 53 }
112}
113
114/* This verify that a character of name exits, and that it matches
115 * password. It return 0 if there is match, 1 if no such player,
116 * 2 if incorrect password.
117 */
118
119int
120verify_player (const char *name, char *password)
121{
122 char buf[MAX_BUF];
123 int comp;
124 FILE *fp;
125
126 if (strpbrk (name, "/.\\") != NULL)
127 {
128 LOG (llevError, "Username contains illegal characters: %s\n", name);
129 return 1;
130 }
131
132 snprintf (buf, sizeof (buf), "%s/%s/%s/%s.pl", settings.localdir, settings.playerdir, name, name);
133 if (strlen (buf) >= sizeof (buf) - 1)
134 {
135 LOG (llevError, "Username too long: %s\n", name);
136 return 1;
137 }
138
139 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
140 return 1;
141
142 /* Read in the file until we find the password line. Our logic could
143 * be a bit better on cleaning up the password from the file, but since
144 * it is written by the program, I think it is fair to assume that the
145 * syntax should be pretty standard.
146 */
147 while (fgets (buf, MAX_BUF - 1, fp) != NULL)
148 {
149 if (!strncmp (buf, "password ", 9))
150 {
151 buf[strlen (buf) - 1] = 0; /* remove newline */
152 if (check_password (password, buf + 9))
153 {
154 close_and_delete (fp, comp);
155 return 0;
156 }
157 else
158 {
159 close_and_delete (fp, comp);
160 return 2;
161 }
162 }
163 }
164 LOG (llevDebug, "Could not find a password line in player %s\n", name);
165 close_and_delete (fp, comp);
166 return 1;
167}
168
169/* Checks to see if anyone else by 'name' is currently playing.
170 * If we find that file or another character of some name is already in the
171 * game, we don't let this person join (we should really let the new player
172 * enter the password, and if correct, disconnect that socket and attach it to
173 * the players current session.
174 * If no one by that name is currently playing, we then make sure the name
175 * doesn't include any bogus characters.
176 * We return 0 if the name is in use/bad, 1 if it is OK to use this name.
177 */
178
179int
180check_name (player *me, const char *name)
181{
182 player *pl;
183
184 for (pl = first_player; pl != NULL; pl = pl->next)
185 if (pl != me && pl->ob->name != NULL && !strcmp (pl->ob->name, name))
186 {
187 new_draw_info (NDI_UNIQUE, 0, me->ob, "That name is already in use.");
188 return 0;
189 }
190
191 if (*name == '\0')
192 {
193 new_draw_info (NDI_UNIQUE, 0, me->ob, "Null names are not allowed.");
194 return 0;
195 }
196
197 if (!playername_ok (name))
198 {
199 new_draw_info (NDI_UNIQUE, 0, me->ob, "That name contains illegal characters.");
200 return 0;
201 }
202 if (strlen (name) >= MAX_NAME)
203 {
204 new_draw_info (NDI_UNIQUE, 0, me->ob, "That name is too long.");
205 return 0;
206 }
207
208 return 1;
209} 54}
210 55
211int 56int
212create_savedir_if_needed (char *savedir) 57create_savedir_if_needed (char *savedir)
213{ 58{
… …
227 LOG (llevError, "Unable to create player savedir %s: %s\n", savedir, strerror (errno)); 72 LOG (llevError, "Unable to create player savedir %s: %s\n", savedir, strerror (errno));
228 return 0; 73 return 0;
229 } 74 }
230 free (buf); 75 free (buf);
231 } 76 }
77
232 return 1; 78 return 1;
233} 79}
234 80
81/*
82 * If final is set, it a clean/final save, not a backup, ie dont remove objects from inventory
83 */
235void 84void
236destroy_object (object *op) 85player::save (bool final)
237{ 86{
238 object *tmp;
239
240 while ((tmp = op->inv))
241 destroy_object (tmp);
242
243 if (!QUERY_FLAG (op, FLAG_REMOVED))
244 remove_ob (op);
245 free_object (op);
246}
247
248/*
249 * If flag is set, it's only backup, ie dont remove objects from inventory
250 * If BACKUP_SAVE_AT_HOME is set, and the flag is set, then the player
251 * will be saved at the emergency save location.
252 * Returns non zero if successful.
253 */
254
255int
256save_player (object *op, int flag)
257{
258 object *tmp, *container = NULL; 87 object *tmp, *container = 0;
259 player *pl = op->contr;
260 int i, wiz = QUERY_FLAG (op, FLAG_WIZ);
261
262#ifdef BACKUP_SAVE_AT_HOME
263 sint16 backup_x, backup_y;
264#endif
265
266 if (!op->stats.exp)
267 return 0; /* no experience, no save */
268
269 flag &= 1;
270
271 if (!pl->name_changed || (!flag && !op->stats.exp))
272 {
273 if (!flag)
274 {
275 new_draw_info (NDI_UNIQUE, 0, op, "Your game is not valid,");
276 new_draw_info (NDI_UNIQUE, 0, op, "Game not saved.");
277 }
278 return 0;
279 }
280 88
281 /* Sanity check - some stuff changes this when player is exiting */ 89 /* Sanity check - some stuff changes this when player is exiting */
282 if (op->type != PLAYER) 90 if (ob->type != PLAYER || !enable_save || !ns)
283 return 0; 91 return;
284 92
285 /* Prevent accidental saves if connection is reset after player has
286 * mostly exited.
287 */
288 if (pl->state != ST_PLAYING && pl->state != ST_GET_PARTY_PASSWORD)
289 return 0;
290
291 INVOKE_PLAYER (SAVE, op->contr); 93 INVOKE_PLAYER (SAVE, ob->contr);
292
293 if (flag == 0)
294 terminate_all_pets (op);
295 94
296 object_freezer freezer; 95 object_freezer freezer;
297 96
97 int wiz = ob->flag [FLAG_WIZ];
98
298 /* Eneq(@csd.uu.se): If we have an open container hide it. */ 99 /* Eneq(@csd.uu.se): If we have an open container hide it. */
299 if (op->container)
300 {
301 container = op->container; 100 container = ob->container;
302 op->container = NULL; 101 ob->container = 0;
303 }
304 102
305 fprintf (freezer, "password %s\n", pl->password); 103 fprintf (freezer, "password %s\n", password);
306 104
307 if (settings.set_title == TRUE)
308 if (pl->own_title[0] != '\0') 105 if (own_title[0] != '\0')
309 fprintf (freezer, "title %s\n", pl->own_title); 106 fprintf (freezer, "title %s\n", own_title);
310 107
311 fprintf (freezer, "explore %d\n", pl->explore); 108 fprintf (freezer, "explore %d\n", explore);
312 fprintf (freezer, "gen_hp %d\n", pl->gen_hp); 109 fprintf (freezer, "gen_hp %d\n", gen_hp);
313 fprintf (freezer, "gen_sp %d\n", pl->gen_sp); 110 fprintf (freezer, "gen_sp %d\n", gen_sp);
314 fprintf (freezer, "gen_grace %d\n", pl->gen_grace); 111 fprintf (freezer, "gen_grace %d\n", gen_grace);
315 fprintf (freezer, "listening %d\n", pl->listening); 112 fprintf (freezer, "listening %d\n", listening);
316 fprintf (freezer, "shoottype %d\n", pl->shoottype); 113 fprintf (freezer, "shoottype %d\n", shoottype);
317 fprintf (freezer, "bowtype %d\n", pl->bowtype); 114 fprintf (freezer, "bowtype %d\n", bowtype);
318 fprintf (freezer, "petmode %d\n", pl->petmode); 115 fprintf (freezer, "petmode %d\n", petmode);
319 fprintf (freezer, "peaceful %d\n", pl->peaceful); 116 fprintf (freezer, "peaceful %d\n", peaceful);
320 fprintf (freezer, "no_shout %d\n", pl->no_shout);
321 fprintf (freezer, "digestion %d\n", pl->digestion); 117 fprintf (freezer, "digestion %d\n", digestion);
322 fprintf (freezer, "pickup %d\n", pl->mode); 118 fprintf (freezer, "pickup %d\n", mode);
323 fprintf (freezer, "outputs_sync %d\n", pl->outputs_sync); 119 fprintf (freezer, "outputs_sync %d\n", outputs_sync);
324 fprintf (freezer, "outputs_count %d\n", pl->outputs_count); 120 fprintf (freezer, "outputs_count %d\n", outputs_count);
325 /* Match the enumerations but in string form */ 121 /* Match the enumerations but in string form */
326 fprintf (freezer, "usekeys %s\n", pl->usekeys == key_inventory ? "key_inventory" : (pl->usekeys == keyrings ? "keyrings" : "containers")); 122 fprintf (freezer, "usekeys %s\n", usekeys == key_inventory ? "key_inventory" : (usekeys == keyrings ? "keyrings" : "containers"));
327 /* Match the enumerations but in string form */ 123 /* Match the enumerations but in string form */
328 fprintf (freezer, "unapply %s\n", pl->unapply == unapply_nochoice ? "unapply_nochoice" : 124 fprintf (freezer, "unapply %s\n", unapply == unapply_nochoice ? "unapply_nochoice" :
329 (pl->unapply == unapply_never ? "unapply_never" : "unapply_always")); 125 (unapply == unapply_never ? "unapply_never" : "unapply_always"));
330 126
331#ifdef BACKUP_SAVE_AT_HOME 127 if (ob->map)
332 if (op->map != NULL && flag == 0)
333#else
334 if (op->map != NULL)
335#endif
336 fprintf (freezer, "map %s\n", op->map->path); 128 fprintf (freezer, "map %s\n", &ob->map->path);
337 else
338 fprintf (freezer, "map %s\n", settings.emergency_mapname);
339 129
340 fprintf (freezer, "savebed_map %s\n", pl->savebed_map); 130 fprintf (freezer, "savebed_map %s\n", savebed_map);
341 fprintf (freezer, "bed_x %d\nbed_y %d\n", pl->bed_x, pl->bed_y); 131 fprintf (freezer, "bed_x %d\nbed_y %d\n", bed_x, bed_y);
342 fprintf (freezer, "weapon_sp %f\n", pl->weapon_sp); 132 fprintf (freezer, "weapon_sp %f\n", weapon_sp);
343 fprintf (freezer, "Str %d\n", pl->orig_stats.Str); 133 fprintf (freezer, "Str %d\n", orig_stats.Str);
344 fprintf (freezer, "Dex %d\n", pl->orig_stats.Dex); 134 fprintf (freezer, "Dex %d\n", orig_stats.Dex);
345 fprintf (freezer, "Con %d\n", pl->orig_stats.Con); 135 fprintf (freezer, "Con %d\n", orig_stats.Con);
346 fprintf (freezer, "Int %d\n", pl->orig_stats.Int); 136 fprintf (freezer, "Int %d\n", orig_stats.Int);
347 fprintf (freezer, "Pow %d\n", pl->orig_stats.Pow); 137 fprintf (freezer, "Pow %d\n", orig_stats.Pow);
348 fprintf (freezer, "Wis %d\n", pl->orig_stats.Wis); 138 fprintf (freezer, "Wis %d\n", orig_stats.Wis);
349 fprintf (freezer, "Cha %d\n", pl->orig_stats.Cha); 139 fprintf (freezer, "Cha %d\n", orig_stats.Cha);
350 140
351 fprintf (freezer, "lev_array %d\n", op->level > 10 ? 10 : op->level); 141 fprintf (freezer, "lev_array %d\n", ob->level > 10 ? 10 : ob->level);
142
352 for (i = 1; i <= pl->last_level && i <= 10; i++) 143 for (int i = 1; i <= last_level && i <= 10; i++)
353 { 144 {
354 fprintf (freezer, "%d\n", pl->levhp[i]); 145 fprintf (freezer, "%d\n", levhp[i]);
355 fprintf (freezer, "%d\n", pl->levsp[i]); 146 fprintf (freezer, "%d\n", levsp[i]);
356 fprintf (freezer, "%d\n", pl->levgrace[i]); 147 fprintf (freezer, "%d\n", levgrace[i]);
357 } 148 }
358 149
359 freezer.put (op->contr); 150 freezer.put (ob->contr);
360 151
361 fprintf (freezer, "endplst\n"); 152 fprintf (freezer, "endplst\n");
362 153
363 SET_FLAG (op, FLAG_NO_FIX_PLAYER); 154 SET_FLAG (ob, FLAG_NO_FIX_PLAYER);
364 CLEAR_FLAG (op, FLAG_WIZ); 155 CLEAR_FLAG (ob, FLAG_WIZ);
365#ifdef BACKUP_SAVE_AT_HOME
366 if (flag)
367 {
368 backup_x = op->x;
369 backup_y = op->y;
370 op->x = -1;
371 op->y = -1;
372 }
373 /* Save objects, but not unpaid objects. Don't remove objects from
374 * inventory.
375 */
376 save_object (freezer, op, 2);
377 if (flag)
378 {
379 op->x = backup_x;
380 op->y = backup_y;
381 }
382#else
383 save_object (freezer, op, 3); /* don't check and don't remove */ 156 save_object (freezer, ob, 1); /* don't check and don't remove */
384#endif
385 157
386 char filename[MAX_BUF]; 158 char filename[MAX_BUF];
387 159
388 sprintf (filename, "%s/%s/%s/%s.pl", settings.localdir, settings.playerdir, &op->name, &op->name); 160 sprintf (filename, "%s/%s/%s/%s.pl", settings.localdir, settings.playerdir, &ob->name, &ob->name);
389 make_path_to_file (filename); 161 make_path_to_file (filename);
390 freezer.save (filename); 162 freezer.save (filename);
391 163
392 CLEAR_FLAG (op, FLAG_NO_FIX_PLAYER); 164 CLEAR_FLAG (ob, FLAG_NO_FIX_PLAYER);
393
394 if (!flag)
395 while ((tmp = op->inv))
396 destroy_object (tmp);
397 165
398 /* Eneq(@csd.uu.se): Reveal the container if we have one. */ 166 /* Eneq(@csd.uu.se): Reveal the container if we have one. */
399 if (flag && container != NULL)
400 op->container = container; 167 ob->container = container;
401 168
402 if (wiz) 169 ob->flag [FLAG_WIZ] = wiz;
403 SET_FLAG (op, FLAG_WIZ);
404 170
405 if (!flag) 171 enable_save = !final;
406 esrv_send_inventory (op, op);
407
408 return 1;
409} 172}
410 173
411void 174player *
412check_login (object *op) 175player::load (const char *path)
413{ 176{
414 char filename[MAX_BUF];
415 char buf[MAX_BUF], bufall[MAX_BUF];
416 int i, value;
417 player *pl = op->contr;
418 int correct = 0;
419
420 strcpy (pl->maplevel, first_map_path);
421 sprintf (filename, "%s/%s/%s/%s.pl", settings.localdir, settings.playerdir, &op->name, &op->name);
422
423 object_thawer thawer (filename); 177 object_thawer thawer (path);
424 178
425 /* If no file, must be a new player, so lets get confirmation of 179 /* If no file, must be a new player, so lets get confirmation of
426 * the password. Return control to the higher level dispatch, 180 * the password. Return control to the higher level dispatch,
427 * since the rest of this just deals with loading of the file. 181 * since the rest of this just deals with loading of the file.
428 */ 182 */
429 if (!thawer) 183 if (!thawer)
430 {
431 confirm_password (op);
432 return; 184 return 0;
433 }
434 185
435 if (fgets (bufall, MAX_BUF, thawer) != NULL) 186 player *pl = new player;
436 {
437 if (sscanf (bufall, "password %s\n", buf))
438 {
439 /* New password scheme: */
440 correct = check_password (pl->write_buf + 1, buf);
441 }
442 }
443 187
444 if (!correct) 188 char buf[MAX_BUF], bufall[MAX_BUF];
445 {
446 new_draw_info (NDI_UNIQUE, 0, op, " ");
447 new_draw_info (NDI_UNIQUE, 0, op, "Wrong Password!");
448 new_draw_info (NDI_UNIQUE, 0, op, " ");
449 op->name = op->name_pl = "noname";
450 op->contr->socket.password_fails++;
451 if (op->contr->socket.password_fails >= MAX_PASSWORD_FAILURES)
452 {
453 new_draw_info (NDI_UNIQUE, 0, op, "You gave an incorrect password too many times, you will now be dropped from the server.");
454 LOG (llevInfo, "A player connecting from %s has been dropped for password failure\n", op->contr->socket.host);
455 op->contr->socket.status = Ns_Dead; /* the socket loop should handle the rest for us */
456 }
457 else
458 get_name (op);
459 return; /* Once again, rest of code just loads the char */
460 }
461 189
462#ifdef SAVE_INTERVAL 190 pl->set_object (object::create ());
463 pl->last_save_time = time (NULL); 191 pl->last_save_time = time (0);
464#endif /* SAVE_INTERVAL */ 192
465 pl->party = NULL;
466 if (settings.search_items == TRUE)
467 pl->search_str[0] = '\0';
468 pl->name_changed = 1;
469 pl->orig_stats.Str = 0;
470 pl->orig_stats.Dex = 0;
471 pl->orig_stats.Con = 0;
472 pl->orig_stats.Int = 0;
473 pl->orig_stats.Pow = 0;
474 pl->orig_stats.Wis = 0;
475 pl->orig_stats.Cha = 0;
476 strcpy (pl->savebed_map, first_map_path); 193 assign (pl->savebed_map, first_map_path);
477 pl->bed_x = 0, pl->bed_y = 0;
478 pl->spellparam[0] = '\0';
479 194
480 /* Loop through the file, loading the rest of the values */ 195 /* Loop through the file, loading the rest of the values */
481 while (fgets (bufall, MAX_BUF, thawer) != NULL) 196 while (fgets (bufall, MAX_BUF, thawer))
482 { 197 {
198 int value;
483 sscanf (bufall, "%s %d\n", buf, &value); 199 sscanf (bufall, "%s %d\n", buf, &value);
200
484 if (!strcmp (buf, "endplst")) 201 if (!strcmp (buf, "endplst"))
485 break; 202 break;
486 else if (!strcmp (buf, "oid")) 203 else if (!strcmp (buf, "oid"))
487 thawer.get (pl, value); 204 thawer.get (pl, value);
488 else if (!strcmp (buf, "title") && settings.set_title == TRUE) 205 else if (!strcmp (buf, "password"))
206 sscanf (bufall, "password %[^\n]", pl->password);
207 else if (!strcmp (buf, "title"))
489 sscanf (bufall, "title %[^\n]", pl->own_title); 208 sscanf (bufall, "title %[^\n]", pl->own_title);
490 else if (!strcmp (buf, "explore")) 209 else if (!strcmp (buf, "explore"))
491 pl->explore = value; 210 pl->explore = value;
492 else if (!strcmp (buf, "gen_hp")) 211 else if (!strcmp (buf, "gen_hp"))
493 pl->gen_hp = value; 212 pl->gen_hp = value;
… …
503 pl->gen_grace = value; 222 pl->gen_grace = value;
504 else if (!strcmp (buf, "listening")) 223 else if (!strcmp (buf, "listening"))
505 pl->listening = value; 224 pl->listening = value;
506 else if (!strcmp (buf, "peaceful")) 225 else if (!strcmp (buf, "peaceful"))
507 pl->peaceful = value; 226 pl->peaceful = value;
508 else if (!strcmp (buf, "no_shout"))
509 pl->no_shout = value;
510 else if (!strcmp (buf, "digestion")) 227 else if (!strcmp (buf, "digestion"))
511 pl->digestion = value; 228 pl->digestion = value;
512 else if (!strcmp (buf, "pickup")) 229 else if (!strcmp (buf, "pickup"))
513 pl->mode = value; 230 pl->mode = value;
514 else if (!strcmp (buf, "outputs_sync")) 231 else if (!strcmp (buf, "outputs_sync"))
… …
561 else 278 else
562 LOG (llevDebug, "load_player: got unknown unapply type: %s\n", bufall + 8); 279 LOG (llevDebug, "load_player: got unknown unapply type: %s\n", bufall + 8);
563 } 280 }
564 else if (!strcmp (buf, "lev_array")) 281 else if (!strcmp (buf, "lev_array"))
565 { 282 {
566 for (i = 1; i <= value; i++) 283 for (int i = 1; i <= value; i++)
567 { 284 {
568 char line[128]; 285 char line[128];
569 286
570 fgets (line, 128, thawer); 287 fgets (line, 128, thawer);
571 pl->levhp[i] = atoi (line); 288 pl->levhp[i] = atoi (line);
… …
577 /* spell_array code removed - don't know when that was last used. 294 /* spell_array code removed - don't know when that was last used.
578 * Even the load code below will someday be replaced by spells being 295 * Even the load code below will someday be replaced by spells being
579 * objects. 296 * objects.
580 */ 297 */
581 } 298 }
582 else if (!strcmp (buf, "known_spell")) 299 else
583 { 300 LOG (llevDebug, "unparseable line in player file %s: %s\n", path, bufall);
584#if 0 301 }
585 /* Logic is left here in case someone wants to try
586 * and write code to update to spell objects.
587 */
588 char *cp = strchr (bufall, '\n');
589
590 *cp = '\0';
591 cp = strchr (bufall, ' ');
592 cp++;
593 for (i = 0; i < NROFREALSPELLS; i++)
594 if (!strcmp (spells[i].name, cp))
595 {
596 pl->known_spells[pl->nrofknownspells++] = i;
597 break;
598 }
599 if (i == NROFREALSPELLS)
600 LOG (llevDebug, "Error: unknown spell (%s)\n", cp);
601#endif
602 }
603 } /* End of loop loading the character file */
604 leave_map (op);
605 op->speed = 0;
606 update_ob_speed (op);
607
608 clear_object (op);
609
610 op->contr = pl;
611 pl->ob = op;
612 302
613 /* this loads the standard objects values. */ 303 /* this loads the standard objects values. */
614 load_object (thawer, op, 0); 304 load_object (thawer, pl->ob, 0);
615 305
616 CLEAR_FLAG (op, FLAG_NO_FIX_PLAYER);
617
618 assign (pl->title, op->arch->clone.name);
619
620 /* If the map where the person was last saved does not exist,
621 * restart them on their home-savebed. This is good for when
622 * maps change between versions
623 * First, we check for partial path, then check to see if the full
624 * path (for unique player maps)
625 */
626 if (check_path (pl->maplevel, 1) == -1)
627 {
628 if (check_path (pl->maplevel, 0) == -1)
629 {
630 strcpy (pl->maplevel, pl->savebed_map);
631 op->x = pl->bed_x, op->y = pl->bed_y;
632 }
633 }
634
635 /* make sure he's a player--needed because of class change. */
636 op->type = PLAYER;
637
638 enter_exit (op, NULL);
639
640 pl->name_changed = 1;
641 pl->state = ST_PLAYING;
642#ifdef AUTOSAVE
643 pl->last_save_tick = pticks; 306 pl->last_save_tick = pticks;
644#endif
645 op->carrying = sum_weight (op);
646 /* Need to call fix_player now - program modified so that it is not
647 * called during the load process (FLAG_NO_FIX_PLAYER set when
648 * saved)
649 * Moved ahead of the esrv functions, so proper weights will be
650 * sent to the client.
651 */
652 link_player_skills (op);
653 307
654 if (!legal_range (op, op->contr->shoottype))
655 op->contr->shoottype = range_none;
656
657 fix_player (op);
658
659 /* if it's a dragon player, set the correct title here */
660 if (is_dragon_pl (op) && op->inv != NULL)
661 {
662 object *tmp, *abil = NULL, *skin = NULL;
663
664 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
665 {
666 if (tmp->type == FORCE)
667 {
668 if (strcmp (tmp->arch->name, "dragon_ability_force") == 0)
669 abil = tmp;
670 else if (strcmp (tmp->arch->name, "dragon_skin_force") == 0)
671 skin = tmp;
672 }
673 }
674 set_dragon_name (op, abil, skin);
675 }
676
677 new_draw_info (NDI_UNIQUE, 0, op, "Welcome Back!");
678 new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, NULL, "%s has entered the game.", &pl->ob->name);
679
680 INVOKE_PLAYER (LOAD, pl, ARG_STRING (filename)); 308 INVOKE_PLAYER (LOAD, pl, ARG_STRING (path));
681 INVOKE_PLAYER (LOGIN, pl);
682 309
683 op->contr->socket.update_look = 1;
684 /* If the player should be dead, call kill_player for them
685 * Only check for hp - if player lacks food, let the normal
686 * logic for that to take place. If player is permanently
687 * dead, and not using permadeath mode, the kill_player will
688 * set the play_again flag, so return.
689 */
690 if (op->stats.hp < 0)
691 {
692 new_draw_info (NDI_UNIQUE, 0, op, "Your character was dead last your played.");
693 kill_player (op);
694 if (pl->state != ST_PLAYING)
695 return;
696 }
697 LOG (llevInfo, "LOGIN: Player named %s from ip %s\n", &op->name, op->contr->socket.host);
698
699 /* Do this after checking for death - no reason sucking up bandwidth if
700 * the data isn't needed.
701 */
702 esrv_new_player (op->contr, op->weight + op->carrying);
703 esrv_send_inventory (op, op);
704 esrv_add_spells (op->contr, NULL);
705
706 CLEAR_FLAG (op, FLAG_FRIENDLY);
707
708 /* can_use_shield is a new flag. However, the can_use.. seems to largely come
709 * from the class, and not race. I don't see any way to get the class information
710 * to then update this. I don't think this will actually break anything - anyone
711 * that can use armour should be able to use a shield. What this may 'break'
712 * are features new characters get, eg, if someone starts up with a Q, they
713 * should be able to use a shield. However, old Q's won't get that advantage.
714 */
715 if (QUERY_FLAG (op, FLAG_USE_ARMOUR))
716 SET_FLAG (op, FLAG_USE_SHIELD);
717 return; 310 return pl;
718} 311}
312

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines