# 2.11BSD#431 - /usr/src/games/hack/hack.lev.c

##### Functions

    bwrite            X
    getlev            X
    mklev             X
    mread             X
    savegoldchn       X
    savelev           X
    savemonchn        X
    saveobjchn        X
    savetrapchn       X

##### Variables

    level_exists      X

       1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
       2: /* hack.lev.c - version 1.0.3 */
       3:
       4: #include "hack.h"
       5: #include "def.mkroom.h"
       6: #include <stdio.h>
       7: extern struct monst *restmonchn();
       8: extern struct obj *restobjchn();
       9: extern struct obj *billobjs;
      10: extern char *itoa();
      11: extern char SAVEF[];
      12: extern int hackpid;
      13: extern xchar dlevel;
      14: extern char nul[];
      15:
      16: #ifndef NOWORM
      17: #include    "def.wseg.h"
      18: extern struct wseg *wsegs[32], *wheads[32];
      19: extern long wgrowtime[32];
      20: #endif NOWORM
      21:
      22: boolean level_exists[MAXLEVEL+1];
      23:
      24: savelev(fd,lev)
      25: int fd;
      26: xchar lev;
      27: {
      28: #ifndef NOWORM
      29:     register struct wseg *wtmp, *wtmp2;
      30:     register tmp;
      31: #endif NOWORM
      32:
      33:     if(fd < 0) panic("Save on bad file!");  /* impossible */
      34:     if(lev >= 0 && lev <= MAXLEVEL)
      35:         level_exists[lev] = TRUE;
      36:
      37:     bwrite(fd,(char *) &hackpid,sizeof(hackpid));
      38:     bwrite(fd,(char *) &lev,sizeof(lev));
      39:     bwrite(fd,(char *) levl,sizeof(levl));
      40:     bwrite(fd,(char *) &moves,sizeof(long));
      41:     bwrite(fd,(char *) &xupstair,sizeof(xupstair));
      42:     bwrite(fd,(char *) &yupstair,sizeof(yupstair));
      43:     bwrite(fd,(char *) &xdnstair,sizeof(xdnstair));
      44:     bwrite(fd,(char *) &ydnstair,sizeof(ydnstair));
      45:     savemonchn(fd, fmon);
      46:     savegoldchn(fd, fgold);
      47:     savetrapchn(fd, ftrap);
      48:     saveobjchn(fd, fobj);
      49:     saveobjchn(fd, billobjs);
      50:     billobjs = 0;
      51:     save_engravings(fd);
      52: #ifndef QUEST
      53:     bwrite(fd,(char *) rooms,sizeof(rooms));
      54:     bwrite(fd,(char *) doors,sizeof(doors));
      55: #endif QUEST
      56:     fgold = 0;
      57:     ftrap = 0;
      58:     fmon = 0;
      59:     fobj = 0;
      60: #ifndef NOWORM
      61:     bwrite(fd,(char *) wsegs,sizeof(wsegs));
      62:     for(tmp=1; tmp<32; tmp++){
      63:         for(wtmp = wsegs[tmp]; wtmp; wtmp = wtmp2){
      64:             wtmp2 = wtmp->nseg;
      65:             bwrite(fd,(char *) wtmp,sizeof(struct wseg));
      66:         }
      67:         wsegs[tmp] = 0;
      68:     }
      69:     bwrite(fd,(char *) wgrowtime,sizeof(wgrowtime));
      70: #endif NOWORM
      71: }
      72:
      73: bwrite(fd,loc,num)
      74: register fd;
      75: register char *loc;
      76: register unsigned num;
      77: {
      78: /* lint wants the 3rd arg of write to be an int; lint -p an unsigned */
      79:     if(write(fd, loc, (int) num) != num)
      80:         panic("cannot write %u bytes to file #%d", num, fd);
      81: }
      82:
      83: saveobjchn(fd,otmp)
      84: register fd;
      85: register struct obj *otmp;
      86: {
      87:     register struct obj *otmp2;
      88:     unsigned xl;
      89:     int minusone = -1;
      90:
      91:     while(otmp) {
      92:         otmp2 = otmp->nobj;
      93:         xl = otmp->onamelth;
      94:         bwrite(fd, (char *) &xl, sizeof(int));
      95:         bwrite(fd, (char *) otmp, xl + sizeof(struct obj));
      96:         free((char *) otmp);
      97:         otmp = otmp2;
      98:     }
      99:     bwrite(fd, (char *) &minusone, sizeof(int));
     100: }
     101:
     102: savemonchn(fd,mtmp)
     103: register fd;
     104: register struct monst *mtmp;
     105: {
     106:     register struct monst *mtmp2;
     107:     unsigned xl;
     108:     int minusone = -1;
     109:     struct permonst *monbegin = &mons[0];
     110:
     111:     bwrite(fd, (char *) &monbegin, sizeof(monbegin));
     112:
     113:     while(mtmp) {
     114:         mtmp2 = mtmp->nmon;
     115:         xl = mtmp->mxlth + mtmp->mnamelth;
     116:         bwrite(fd, (char *) &xl, sizeof(int));
     117:         bwrite(fd, (char *) mtmp, xl + sizeof(struct monst));
     118:         if(mtmp->minvent) saveobjchn(fd,mtmp->minvent);
     119:         free((char *) mtmp);
     120:         mtmp = mtmp2;
     121:     }
     122:     bwrite(fd, (char *) &minusone, sizeof(int));
     123: }
     124:
     125: savegoldchn(fd,gold)
     126: register fd;
     127: register struct gold *gold;
     128: {
     129:     register struct gold *gold2;
     130:     while(gold) {
     131:         gold2 = gold->ngold;
     132:         bwrite(fd, (char *) gold, sizeof(struct gold));
     133:         free((char *) gold);
     134:         gold = gold2;
     135:     }
     136:     bwrite(fd, nul, sizeof(struct gold));
     137: }
     138:
     139: savetrapchn(fd,trap)
     140: register fd;
     141: register struct trap *trap;
     142: {
     143:     register struct trap *trap2;
     144:     while(trap) {
     145:         trap2 = trap->ntrap;
     146:         bwrite(fd, (char *) trap, sizeof(struct trap));
     147:         free((char *) trap);
     148:         trap = trap2;
     149:     }
     150:     bwrite(fd, nul, sizeof(struct trap));
     151: }
     152:
     153: getlev(fd,pid,lev)
     154: int fd,pid;
     155: xchar lev;
     156: {
     157:     register struct gold *gold;
     158:     register struct trap *trap;
     159: #ifndef NOWORM
     160:     register struct wseg *wtmp;
     161: #endif NOWORM
     162:     register tmp;
     163:     long omoves;
     164:     int hpid;
     165:     xchar dlvl;
     166:
     167:     /* First some sanity checks */
     168:     mread(fd, (char *) &hpid, sizeof(hpid));
     169:     mread(fd, (char *) &dlvl, sizeof(dlvl));
     170:     if((pid && pid != hpid) || (lev && dlvl != lev)) {
     171:         pline("Strange, this map is not as I remember it.");
     172:         pline("Somebody is trying some trickery here ...");
     173:         pline("This game is void ...");
     174:         done("tricked");
     175:     }
     176:
     177:     fgold = 0;
     178:     ftrap = 0;
     179:     mread(fd, (char *) levl, sizeof(levl));
     180:     mread(fd, (char *)&omoves, sizeof(omoves));
     181:     mread(fd, (char *)&xupstair, sizeof(xupstair));
     182:     mread(fd, (char *)&yupstair, sizeof(yupstair));
     183:     mread(fd, (char *)&xdnstair, sizeof(xdnstair));
     184:     mread(fd, (char *)&ydnstair, sizeof(ydnstair));
     185:
     186:     fmon = restmonchn(fd);
     187:
     188:     /* regenerate animals while on another level */
     189:     { long tmoves = (moves > omoves) ? moves-omoves : 0;
     190:       register struct monst *mtmp, *mtmp2;
     191:       extern char genocided[];
     192:
     193:       for(mtmp = fmon; mtmp; mtmp = mtmp2) {
     194:         long newhp;     /* tmoves may be very large */
     195:
     196:         mtmp2 = mtmp->nmon;
     197:         if(index(genocided, mtmp->data->mlet)) {
     198:             mondead(mtmp);
     199:             continue;
     200:         }
     201:
     202:         if(mtmp->mtame && tmoves > 250) {
     203:             mtmp->mtame = 0;
     204:             mtmp->mpeaceful = 0;
     205:         }
     206:
     207:         newhp = mtmp->mhp +
     208:             (index(MREGEN, mtmp->data->mlet) ? tmoves : tmoves/20);
     209:         if(newhp > mtmp->mhpmax)
     210:             mtmp->mhp = mtmp->mhpmax;
     211:         else
     212:             mtmp->mhp = newhp;
     213:       }
     214:     }
     215:
     216:     setgd();
     217:     gold = newgold();
     218:     mread(fd, (char *)gold, sizeof(struct gold));
     219:     while(gold->gx) {
     220:         gold->ngold = fgold;
     221:         fgold = gold;
     222:         gold = newgold();
     223:         mread(fd, (char *)gold, sizeof(struct gold));
     224:     }
     225:     free((char *) gold);
     226:     trap = newtrap();
     227:     mread(fd, (char *)trap, sizeof(struct trap));
     228:     while(trap->tx) {
     229:         trap->ntrap = ftrap;
     230:         ftrap = trap;
     231:         trap = newtrap();
     232:         mread(fd, (char *)trap, sizeof(struct trap));
     233:     }
     234:     free((char *) trap);
     235:     fobj = restobjchn(fd);
     236:     billobjs = restobjchn(fd);
     237:     rest_engravings(fd);
     238: #ifndef QUEST
     239:     mread(fd, (char *)rooms, sizeof(rooms));
     240:     mread(fd, (char *)doors, sizeof(doors));
     241: #endif QUEST
     242: #ifndef NOWORM
     243:     mread(fd, (char *)wsegs, sizeof(wsegs));
     244:     for(tmp = 1; tmp < 32; tmp++) if(wsegs[tmp]){
     245:         wheads[tmp] = wsegs[tmp] = wtmp = newseg();
     246:         while(1) {
     247:             mread(fd, (char *)wtmp, sizeof(struct wseg));
     248:             if(!wtmp->nseg) break;
     249:             wheads[tmp]->nseg = wtmp = newseg();
     250:             wheads[tmp] = wtmp;
     251:         }
     252:     }
     253:     mread(fd, (char *)wgrowtime, sizeof(wgrowtime));
     254: #endif NOWORM
     255: }
     256:
     257: mread(fd, buf, len)
     258: register fd;
     259: register char *buf;
     260: register unsigned len;
     261: {
     262:     register int rlen;
     263:     extern boolean restoring;
     264:
     265:     rlen = read(fd, buf, (int) len);
     266:     if(rlen != len){
     267:         pline("Read %d instead of %u bytes.\n", rlen, len);
     268:         if(restoring) {
     269:             (void) unlink(SAVEF);
     270:             error("Error restoring old game.");
     271:         }
     272:         panic("Error reading level file.");
     273:     }
     274: }
     275:
     276: mklev()
     277: {
     278:     extern boolean in_mklev;
     279:
     280:     if(getbones()) return;
     281:
     282:     in_mklev = TRUE;
     283:     makelevel();
     284:     in_mklev = FALSE;
     285: }

#### Defined functions

bwrite defined in line 73; used 42 times

- in line 37-44(8), 53-54(2), 61-69(3), 94-99(3), 111-122(4), 132-136(2), 146-150(2)
- in /usr/src/games/hack/hack.engrave.c line 267-271(3)
- in /usr/src/games/hack/hack.o_init.c line 103-104(2), 111-112(2)
- in /usr/src/games/hack/hack.save.c line 51-61(10), 78

getlev defined in line 153; used 6 times

- in /usr/src/games/hack/hack.bones.c line 82
- in /usr/src/games/hack/hack.do.c line 176
- in /usr/src/games/hack/hack.save.c line 76, 100, 129, 137

mklev defined in line 276; used 2 times

- in /usr/src/games/hack/hack.do.c line 167
- in /usr/src/games/hack/hack.main.c line 263

mread defined in line 257; used 38 times

- in line 168-169(2), 179-184(6), 218-232(4), 239-247(4), 253
- in /usr/src/games/hack/hack.engrave.c line 280-283(2)
- in /usr/src/games/hack/hack.o_init.c line 120-125(4)
- in /usr/src/games/hack/hack.save.c line 107, 115-124(9), 184-189(2), 211, 219-224(2)

savegoldchn defined in line 125; used 1 times

- in line 46

savelev defined in line 24; used 5 times

- in /usr/src/games/hack/hack.bones.c line 71
- in /usr/src/games/hack/hack.do.c line 158
- in /usr/src/games/hack/hack.save.c line 46, 79, 133

savemonchn defined in line 102; used 2 times

- in line 45
- in /usr/src/games/hack/hack.save.c line 49

saveobjchn defined in line 83; used 5 times

- in line 48-49(2), 118
- in /usr/src/games/hack/hack.save.c line 47-48(2)

savetrapchn defined in line 139; used 1 times

- in line 47

#### Defined variables

level_exists defined in line 22; used 2 times

- in line 35
- in /usr/src/games/hack/hack.do.c line 166

Last modified: 1985-10-01 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1295 |