# 2.11BSD#431 - /usr/src/games/rogue/save.c

##### Functions

    has_been_touched  X
    r_read            X
    r_write           X
    read_pack         X
    read_string       X
    restore           X
    rw_dungeon        X
    rw_id             X
    rw_rooms          X
    save_game         X
    save_into_file    X
    write_pack        X
    write_string      X

##### Variables

    save_file         X
    write_failed      X

       1: /*
       2:  * save.c
       3:  *
       4:  * This source herein may be modified and/or distributed by anybody who
       5:  * so desires, with the following restrictions:
       6:  *    1.)  No portion of this notice shall be removed.
       7:  *    2.)  Credit shall not be taken for the creation of this source.
       8:  *    3.)  This code is not to be traded, sold, or used for personal
       9:  *         gain or profit.
      10:  *
      11:  */
      12:
      13: #ifndef lint
      14: static char sccsid[] = "@(#)save.c	5.1 (Berkeley) 11/25/87";
      15: #endif /* not lint */
      16:
      17: #include <stdio.h>
      18: #include "rogue.h"
      19:
      20: short write_failed = 0;
      21: char *save_file = (char *) 0;
      22:
      23: extern boolean detect_monster;
      24: extern short cur_level, max_level;
      25: extern char hunger_str[];
      26: extern char login_name[];
      27: extern short party_room;
      28: extern short foods;
      29: extern boolean is_wood[];
      30: extern short cur_room;
      31: extern boolean being_held;
      32: extern short bear_trap;
      33: extern short halluc;
      34: extern short blind;
      35: extern short confused;
      36: extern short levitate;
      37: extern short haste_self;
      38: extern boolean see_invisible;
      39: extern boolean detect_monster;
      40: extern boolean wizard;
      41: extern boolean score_only;
      42: extern short m_moves;
      43:
      44: extern boolean msg_cleared;
      45:
      46: save_game()
      47: {
      48:     char fname[64];
      49:
      50:     if (!get_input_line("file name?", save_file, fname, "game not saved",
      51:             0, 1)) {
      52:         return;
      53:     }
      54:     check_message();
      55:     message(fname, 0);
      56:     save_into_file(fname);
      57: }
      58:
      59: save_into_file(sfile)
      60: char *sfile;
      61: {
      62:     FILE *fp;
      63:     int file_id;
      64:     char name_buffer[80];
      65:     char *hptr;
      66:     struct rogue_time rt_buf;
      67:
      68:     if (sfile[0] == '~') {
      69:         if (hptr = md_getenv("HOME")) {
      70:             (void) strcpy(name_buffer, hptr);
      71:             (void) strcat(name_buffer, sfile+1);
      72:             sfile = name_buffer;
      73:         }
      74:     }
      75:     if (    ((fp = fopen(sfile, "w")) == NULL) ||
      76:             ((file_id = md_get_file_id(sfile)) == -1)) {
      77:         message("problem accessing the save file", 0);
      78:         return;
      79:     }
      80:     md_ignore_signals();
      81:     write_failed = 0;
      82:     (void) xxx(1);
      83:     r_write(fp, (char *) &detect_monster, sizeof(detect_monster));
      84:     r_write(fp, (char *) &cur_level, sizeof(cur_level));
      85:     r_write(fp, (char *) &max_level, sizeof(max_level));
      86:     write_string(hunger_str, fp);
      87:     write_string(login_name, fp);
      88:     r_write(fp, (char *) &party_room, sizeof(party_room));
      89:     write_pack(&level_monsters, fp);
      90:     write_pack(&level_objects, fp);
      91:     r_write(fp, (char *) &file_id, sizeof(file_id));
      92:     rw_dungeon(fp, 1);
      93:     r_write(fp, (char *) &foods, sizeof(foods));
      94:     r_write(fp, (char *) &rogue, sizeof(fighter));
      95:     write_pack(&rogue.pack, fp);
      96:     rw_id(id_potions, fp, POTIONS, 1);
      97:     rw_id(id_scrolls, fp, SCROLS, 1);
      98:     rw_id(id_wands, fp, WANDS, 1);
      99:     rw_id(id_rings, fp, RINGS, 1);
     100:     r_write(fp, (char *) traps, (MAX_TRAPS * sizeof(trap)));
     101:     r_write(fp, (char *) is_wood, (WANDS * sizeof(boolean)));
     102:     r_write(fp, (char *) &cur_room, sizeof(cur_room));
     103:     rw_rooms(fp, 1);
     104:     r_write(fp, (char *) &being_held, sizeof(being_held));
     105:     r_write(fp, (char *) &bear_trap, sizeof(bear_trap));
     106:     r_write(fp, (char *) &halluc, sizeof(halluc));
     107:     r_write(fp, (char *) &blind, sizeof(blind));
     108:     r_write(fp, (char *) &confused, sizeof(confused));
     109:     r_write(fp, (char *) &levitate, sizeof(levitate));
     110:     r_write(fp, (char *) &haste_self, sizeof(haste_self));
     111:     r_write(fp, (char *) &see_invisible, sizeof(see_invisible));
     112:     r_write(fp, (char *) &detect_monster, sizeof(detect_monster));
     113:     r_write(fp, (char *) &wizard, sizeof(wizard));
     114:     r_write(fp, (char *) &score_only, sizeof(score_only));
     115:     r_write(fp, (char *) &m_moves, sizeof(m_moves));
     116:     md_gct(&rt_buf);
     117:     rt_buf.second += 10;        /* allow for some processing time */
     118:     r_write(fp, (char *) &rt_buf, sizeof(rt_buf));
     119:     fclose(fp);
     120:
     121:     if (write_failed) {
     122:         (void) md_df(sfile);    /* delete file */
     123:     } else {
     124:         clean_up("");
     125:     }
     126: }
     127:
     128: restore(fname)
     129: char *fname;
     130: {
     131:     FILE *fp;
     132:     struct rogue_time saved_time, mod_time;
     133:     char buf[4];
     134:     char tbuf[40];
     135:     int new_file_id, saved_file_id;
     136:
     137:     if (    ((new_file_id = md_get_file_id(fname)) == -1) ||
     138:             ((fp = fopen(fname, "r")) == NULL)) {
     139:         clean_up("cannot open file");
     140:     }
     141:     if (md_link_count(fname) > 1) {
     142:         clean_up("file has link");
     143:     }
     144:     (void) xxx(1);
     145:     r_read(fp, (char *) &detect_monster, sizeof(detect_monster));
     146:     r_read(fp, (char *) &cur_level, sizeof(cur_level));
     147:     r_read(fp, (char *) &max_level, sizeof(max_level));
     148:     read_string(hunger_str, fp);
     149:
     150:     (void) strcpy(tbuf, login_name);
     151:     read_string(login_name, fp);
     152:     if (strcmp(tbuf, login_name)) {
     153:         clean_up("you're not the original player");
     154:     }
     155:
     156:     r_read(fp, (char *) &party_room, sizeof(party_room));
     157:     read_pack(&level_monsters, fp, 0);
     158:     read_pack(&level_objects, fp, 0);
     159:     r_read(fp, (char *) &saved_file_id, sizeof(saved_file_id));
     160:     if (new_file_id != saved_file_id) {
     161:         clean_up("sorry, saved game is not in the same file");
     162:     }
     163:     rw_dungeon(fp, 0);
     164:     r_read(fp, (char *) &foods, sizeof(foods));
     165:     r_read(fp, (char *) &rogue, sizeof(fighter));
     166:     read_pack(&rogue.pack, fp, 1);
     167:     rw_id(id_potions, fp, POTIONS, 0);
     168:     rw_id(id_scrolls, fp, SCROLS, 0);
     169:     rw_id(id_wands, fp, WANDS, 0);
     170:     rw_id(id_rings, fp, RINGS, 0);
     171:     r_read(fp, (char *) traps, (MAX_TRAPS * sizeof(trap)));
     172:     r_read(fp, (char *) is_wood, (WANDS * sizeof(boolean)));
     173:     r_read(fp, (char *) &cur_room, sizeof(cur_room));
     174:     rw_rooms(fp, 0);
     175:     r_read(fp, (char *) &being_held, sizeof(being_held));
     176:     r_read(fp, (char *) &bear_trap, sizeof(bear_trap));
     177:     r_read(fp, (char *) &halluc, sizeof(halluc));
     178:     r_read(fp, (char *) &blind, sizeof(blind));
     179:     r_read(fp, (char *) &confused, sizeof(confused));
     180:     r_read(fp, (char *) &levitate, sizeof(levitate));
     181:     r_read(fp, (char *) &haste_self, sizeof(haste_self));
     182:     r_read(fp, (char *) &see_invisible, sizeof(see_invisible));
     183:     r_read(fp, (char *) &detect_monster, sizeof(detect_monster));
     184:     r_read(fp, (char *) &wizard, sizeof(wizard));
     185:     r_read(fp, (char *) &score_only, sizeof(score_only));
     186:     r_read(fp, (char *) &m_moves, sizeof(m_moves));
     187:     r_read(fp, (char *) &saved_time, sizeof(saved_time));
     188:
     189:     if (fread(buf, sizeof(char), 1, fp) > 0) {
     190:         clear();
     191:         clean_up("extra characters in file");
     192:     }
     193:
     194:     md_gfmt(fname, &mod_time);  /* get file modification time */
     195:
     196:     if (has_been_touched(&saved_time, &mod_time)) {
     197:         clear();
     198:         clean_up("sorry, file has been touched");
     199:     }
     200:     if ((!wizard) && !md_df(fname)) {
     201:         clean_up("cannot delete file");
     202:     }
     203:     msg_cleared = 0;
     204:     ring_stats(0);
     205:     fclose(fp);
     206: }
     207:
     208: write_pack(pack, fp)
     209: object *pack;
     210: FILE *fp;
     211: {
     212:     object t;
     213:
     214:     while (pack = pack->next_object) {
     215:         r_write(fp, (char *) pack, sizeof(object));
     216:     }
     217:     t.ichar = t.what_is = 0;
     218:     r_write(fp, (char *) &t, sizeof(object));
     219: }
     220:
     221: read_pack(pack, fp, is_rogue)
     222: object *pack;
     223: FILE *fp;
     224: boolean is_rogue;
     225: {
     226:     object read_obj, *new_obj;
     227:
     228:     for (;;) {
     229:         r_read(fp, (char *) &read_obj, sizeof(object));
     230:         if (read_obj.ichar == 0) {
     231:             pack->next_object = (object *) 0;
     232:             break;
     233:         }
     234:         new_obj = alloc_object();
     235:         *new_obj = read_obj;
     236:         if (is_rogue) {
     237:             if (new_obj->in_use_flags & BEING_WORN) {
     238:                     do_wear(new_obj);
     239:             } else if (new_obj->in_use_flags & BEING_WIELDED) {
     240:                     do_wield(new_obj);
     241:             } else if (new_obj->in_use_flags & (ON_EITHER_HAND)) {
     242:                 do_put_on(new_obj,
     243:                     ((new_obj->in_use_flags & ON_LEFT_HAND) ? 1 : 0));
     244:             }
     245:         }
     246:         pack->next_object = new_obj;
     247:         pack = new_obj;
     248:     }
     249: }
     250:
     251: rw_dungeon(fp, rw)
     252: FILE *fp;
     253: boolean rw;
     254: {
     255:     short i, j;
     256:     char buf[DCOLS];
     257:
     258:     for (i = 0; i < DROWS; i++) {
     259:         if (rw) {
     260:             r_write(fp, (char *) dungeon[i], (DCOLS * sizeof(dungeon[0][0])));
     261:             for (j = 0; j < DCOLS; j++) {
     262:                 buf[j] = mvinch(i, j);
     263:             }
     264:             r_write(fp, buf, DCOLS);
     265:         } else {
     266:             r_read(fp, (char *) dungeon[i], (DCOLS * sizeof(dungeon[0][0])));
     267:             r_read(fp, buf, DCOLS);
     268:             for (j = 0; j < DCOLS; j++) {
     269:                 mvaddch(i, j, buf[j]);
     270:             }
     271:         }
     272:     }
     273: }
     274:
     275: rw_id(id_table, fp, n, wr)
     276: struct id id_table[];
     277: FILE *fp;
     278: int n;
     279: boolean wr;
     280: {
     281:     short i;
     282:
     283:     for (i = 0; i < n; i++) {
     284:         if (wr) {
     285:             r_write(fp, (char *) &(id_table[i].value), sizeof(short));
     286:             r_write(fp, (char *) &(id_table[i].id_status),
     287:                 sizeof(unsigned short));
     288:             write_string(id_table[i].title, fp);
     289:         } else {
     290:             r_read(fp, (char *) &(id_table[i].value), sizeof(short));
     291:             r_read(fp, (char *) &(id_table[i].id_status),
     292:                 sizeof(unsigned short));
     293:             read_string(id_table[i].title, fp);
     294:         }
     295:     }
     296: }
     297:
     298: write_string(s, fp)
     299: char *s;
     300: FILE *fp;
     301: {
     302:     short n;
     303:
     304:     n = strlen(s) + 1;
     305:     xxxx(s, n);
     306:     r_write(fp, (char *) &n, sizeof(short));
     307:     r_write(fp, s, n);
     308: }
     309:
     310: read_string(s, fp)
     311: char *s;
     312: FILE *fp;
     313: {
     314:     short n;
     315:
     316:     r_read(fp, (char *) &n, sizeof(short));
     317:     r_read(fp, s, n);
     318:     xxxx(s, n);
     319: }
     320:
     321: rw_rooms(fp, rw)
     322: FILE *fp;
     323: boolean rw;
     324: {
     325:     short i;
     326:
     327:     for (i = 0; i < MAXROOMS; i++) {
     328:         rw ? r_write(fp, (char *) (rooms + i), sizeof(room)) :
     329:             r_read(fp, (char *) (rooms + i), sizeof(room));
     330:     }
     331: }
     332:
     333: r_read(fp, buf, n)
     334: FILE *fp;
     335: char *buf;
     336: int n;
     337: {
     338:     if (fread(buf, sizeof(char), n, fp) != n) {
     339:         clean_up("read() failed, don't know why");
     340:     }
     341: }
     342:
     343: r_write(fp, buf, n)
     344: FILE *fp;
     345: char *buf;
     346: int n;
     347: {
     348:     if (!write_failed) {
     349:         if (fwrite(buf, sizeof(char), n, fp) != n) {
     350:             message("write() failed, don't know why", 0);
     351:             sound_bell();
     352:             write_failed = 1;
     353:         }
     354:     }
     355: }
     356:
     357: boolean
     358: has_been_touched(saved_time, mod_time)
     359: struct rogue_time *saved_time, *mod_time;
     360: {
     361:     if (saved_time->year < mod_time->year) {
     362:         return(1);
     363:     } else if (saved_time->year > mod_time->year) {
     364:         return(0);
     365:     }
     366:     if (saved_time->month < mod_time->month) {
     367:         return(1);
     368:     } else if (saved_time->month > mod_time->month) {
     369:         return(0);
     370:     }
     371:     if (saved_time->day < mod_time->day) {
     372:         return(1);
     373:     } else if (saved_time->day > mod_time->day) {
     374:         return(0);
     375:     }
     376:     if (saved_time->hour < mod_time->hour) {
     377:         return(1);
     378:     } else if (saved_time->hour > mod_time->hour) {
     379:         return(0);
     380:     }
     381:     if (saved_time->minute < mod_time->minute) {
     382:         return(1);
     383:     } else if (saved_time->minute > mod_time->minute) {
     384:         return(0);
     385:     }
     386:     if (saved_time->second < mod_time->second) {
     387:         return(1);
     388:     }
     389:     return(0);
     390: }

#### Defined functions

has_been_touched defined in line 357; used 2 times

- in line 196
- in /usr/src/games/rogue/rogue.h line 414

r_read defined in line 333; used 31 times

- in line 145-147(3), 156-165(4), 171-187(16), 229, 266-267(2), 290-291(2), 316-317(2), 329

r_write defined in line 343; used 32 times

- in line 83-94(7), 100-118(16), 215-218(2), 260-264(2), 285-286(2), 306-307(2), 328

read_pack defined in line 221; used 3 times

- in line 157-158(2), 166

read_string defined in line 310; used 3 times

- in line 148-151(2), 293

restore defined in line 128; used 1 times

- in /usr/src/games/rogue/init.c line 76

rw_dungeon defined in line 251; used 2 times

- in line 92, 163

rw_id defined in line 275; used 8 times

- in line 96-99(4), 167-170(4)

rw_rooms defined in line 321; used 2 times

- in line 103, 174

save_game defined in line 46; used 1 times

- in /usr/src/games/rogue/play.c line 255

save_into_file defined in line 59; used 3 times

- in line 56
- in /usr/src/games/rogue/init.c line 194
- in /usr/src/games/rogue/object.c line 587

write_pack defined in line 208; used 3 times

- in line 89-95(3)

write_string defined in line 298; used 3 times

- in line 86-87(2), 288

#### Defined variables

save_file defined in line 21; used 4 times

- in line 50
- in /usr/src/games/rogue/init.c line 236, 262
- in /usr/src/games/rogue/room.c line 60

sccsid defined in line 14; never used
write_failed defined in line 20; used 4 times

- in line 81, 121, 348-352(2)

Last modified: 1987-11-26 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1918 |