pc-hack

PC HACK 3.61 source code (archival)
git clone http://frotz.net/git/pc-hack.git
Log | Files | Refs

engrave.c (7057B)

      1 /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
      2 /* engrave.c - version 1.0.3 */
      3 
      4 #include	"hack.h"
      5 
      6 extern char *nomovemsg;
      7 extern char nul[];
      8 extern struct obj zeroobj;
      9 struct engr {
     10 	struct engr *nxt_engr;
     11 	char *engr_txt;
     12 	xchar engr_x, engr_y;
     13 	unsigned engr_lth;	/* for save & restore; not length of text */
     14 	long engr_time;	/* moment engraving was (will be) finished */
     15 	xchar engr_type;
     16 #define	DUST	1
     17 #define	ENGRAVE	2
     18 #define	BURN	3
     19 } *head_engr;
     20 
     21 struct engr *
     22 engr_at(x,y) register xchar x,y; {
     23 register struct engr *ep = head_engr;
     24 	while(ep) {
     25 		if(x == ep->engr_x && y == ep->engr_y)
     26 			return(ep);
     27 		ep = ep->nxt_engr;
     28 	}
     29 	return((struct engr *) 0);
     30 }
     31 
     32 sengr_at(s,x,y) register char *s; register xchar x,y; {
     33 register struct engr *ep = engr_at(x,y);
     34 register char *t;
     35 register int n;
     36 	if(ep && ep->engr_time <= moves) {
     37 		t = ep->engr_txt;
     38 /*
     39 		if(!strcmp(s,t)) return(1);
     40 */
     41 		n = strlen(s);
     42 		while(*t) {
     43 			if(!strncmp(s,t,n)) return(1);
     44 			t++;
     45 		}
     46 	}
     47 	return(0);
     48 }
     49 
     50 u_wipe_engr(cnt)
     51 register int cnt;
     52 {
     53 	if(!u.uswallow && !Levitation)
     54 		wipe_engr_at(u.ux, u.uy, cnt);
     55 }
     56 
     57 wipe_engr_at(x,y,cnt) register xchar x,y,cnt; {
     58 register struct engr *ep = engr_at(x,y);
     59 register int lth,pos;
     60 char ch;
     61 	if(ep){
     62 		if(ep->engr_type != DUST) {
     63 			cnt = rn2(1 + 50/(cnt+1)) ? 0 : 1;
     64 		}
     65 		lth = strlen(ep->engr_txt);
     66 		if(lth && cnt > 0 ) {
     67 			while(cnt--) {
     68 				pos = rn2(lth);
     69 				if((ch = ep->engr_txt[pos]) == ' ')
     70 					continue;
     71 				ep->engr_txt[pos] = (ch != '?') ? '?' : ' ';
     72 			}
     73 		}
     74 		while(lth && ep->engr_txt[lth-1] == ' ')
     75 			ep->engr_txt[--lth] = 0;
     76 		while(ep->engr_txt[0] == ' ')
     77 			ep->engr_txt++;
     78 		if(!ep->engr_txt[0]) del_engr(ep);
     79 	}
     80 }
     81 
     82 read_engr_at(x,y) register int x,y; {
     83 register struct engr *ep = engr_at(x,y);
     84 	if(ep && ep->engr_txt[0]) {
     85 	    switch(ep->engr_type) {
     86 	    case DUST:
     87 		pline("Something is written here in the dust.");
     88 		break;
     89 	    case ENGRAVE:
     90 		pline("Something is engraved here on the floor.");
     91 		break;
     92 	    case BURN:
     93 		pline("Some text has been burned here in the floor.");
     94 		break;
     95 	    default:
     96 		impossible("Something is written in a very strange way.");
     97 	    }
     98 	    pline("You read: \"%s\".", ep->engr_txt);
     99 	}
    100 }
    101 
    102 make_engr_at(x,y,s)
    103 register int x,y;
    104 register char *s;
    105 {
    106 	register struct engr *ep;
    107 
    108 	if(ep = engr_at(x,y))
    109 	    del_engr(ep);
    110 	ep = (struct engr *)
    111 	    alloc((unsigned)(sizeof(struct engr) + strlen(s) + 1));
    112 	ep->nxt_engr = head_engr;
    113 	head_engr = ep;
    114 	ep->engr_x = x;
    115 	ep->engr_y = y;
    116 	ep->engr_txt = (char *)(ep + 1);
    117 	(void) strcpy(ep->engr_txt, s);
    118 	ep->engr_time = 0;
    119 	ep->engr_type = DUST;
    120 	ep->engr_lth = strlen(s) + 1;
    121 }
    122 
    123 doengrave(){
    124 register int len;
    125 register char *sp;
    126 register struct engr *ep, *oep = engr_at(u.ux,u.uy);
    127 char buf[BUFSZ];
    128 xchar type;
    129 int spct;		/* number of leading spaces */
    130 register struct obj *otmp;
    131 	multi = 0;
    132 
    133 	if(u.uswallow) {
    134 		pline("You're joking. Hahaha!");	/* riv05!a3 */
    135 		return(0);
    136 	}
    137 
    138 	/* one may write with finger, weapon or wand */
    139 	otmp = getobj("#-)/", "write with");
    140 	if(!otmp) return(0);
    141 
    142 	if(otmp == &zeroobj)
    143 		otmp = 0;
    144  	if(otmp && otmp->otyp == WAN_FIRE && otmp->spe) {
    145 		type = BURN;
    146 		otmp->spe--;
    147 	} else {
    148 		/* first wield otmp */
    149 		if(otmp != uwep) {
    150 			if(uwep && uwep->cursed) {
    151 			    /* Andreas Bormann */
    152 			    pline("Since your weapon is welded to your hand,");
    153 			    pline("you use the %s.", aobjnam(uwep, (char *) 0));
    154 			    otmp = uwep;
    155 			} else {
    156 			    if(!otmp)
    157 				pline("You are now empty-handed.");
    158 			    else if(otmp->cursed)
    159 				pline("The %s %s to your hand!",
    160 				    aobjnam(otmp, "weld"),
    161 				    (otmp->quan == 1) ? "itself" : "themselves");
    162 			    else
    163 				pline("You now wield %s.", doname(otmp));
    164 			    setuwep(otmp);
    165 			}
    166 		}
    167 
    168 		if(!otmp)
    169 			type = DUST;
    170 		else
    171 		if(otmp->otyp == DAGGER || otmp->otyp == TWO_HANDED_SWORD ||
    172 		otmp->otyp == CRYSKNIFE ||
    173 		otmp->otyp == LONG_SWORD || otmp->otyp == AXE) {
    174 			type = ENGRAVE;
    175 			if((int)otmp->spe <= -3) {
    176 				type = DUST;
    177 				pline("Your %s too dull for engraving.",
    178 					aobjnam(otmp, "are"));
    179 				if(oep && oep->engr_type != DUST) return(1);
    180 			}
    181 		} else	type = DUST;
    182 	}
    183 	if(Levitation && type != BURN){		/* riv05!a3 */
    184 		pline("You can't reach the floor!");
    185 		return(1);
    186 	}
    187 	if(oep && oep->engr_type == DUST){
    188 		  pline("You wipe out the message that was written here.");
    189 		  del_engr(oep);
    190 		  oep = 0;
    191 	}
    192 	if(type == DUST && oep){
    193 	pline("You cannot wipe out the message that is %s in the rock.",
    194 		    (oep->engr_type == BURN) ? "burned" : "engraved");
    195 		  return(1);
    196 	}
    197 
    198 	pline("What do you want to %s on the floor here? ",
    199 	  (type == ENGRAVE) ? "engrave" : (type == BURN) ? "burn" : "write");
    200 	getlin(buf);
    201 	clrlin();
    202 	spct = 0;
    203 	sp = buf;
    204 	while(*sp == ' ') spct++, sp++;
    205 	len = strlen(sp);
    206 	if(!len || *buf == '\033') {
    207 		if(type == BURN) otmp->spe++;
    208 		return(0);
    209 	}
    210 	
    211 	switch(type) {
    212 	case DUST:
    213 	case BURN:
    214 		if(len > 15) {
    215 			multi = -(len/10);
    216 			nomovemsg = "You finished writing.";
    217 		}
    218 		break;
    219 	case ENGRAVE:		/* here otmp != 0 */
    220 		{	int len2 = (otmp->spe + 3) * 2 + 1;
    221 
    222 			pline("Your %s dull.", aobjnam(otmp, "get"));
    223 			if(len2 < len) {
    224 				len = len2;
    225 				sp[len] = 0;
    226 				otmp->spe = -3;
    227 				nomovemsg = "You cannot engrave more.";
    228 			} else {
    229 				otmp->spe -= len/2;
    230 				nomovemsg = "You finished engraving.";
    231 			}
    232 			multi = -len;
    233 		}
    234 		break;
    235 	}
    236 	if(oep) len += strlen(oep->engr_txt) + spct;
    237 	ep = (struct engr *) alloc((unsigned)(sizeof(struct engr) + len + 1));
    238 	ep->nxt_engr = head_engr;
    239 	head_engr = ep;
    240 	ep->engr_x = u.ux;
    241 	ep->engr_y = u.uy;
    242 	sp = (char *)(ep + 1);	/* (char *)ep + sizeof(struct engr) */
    243 	ep->engr_txt = sp;
    244 	if(oep) {
    245 		(void) strcpy(sp, oep->engr_txt);
    246 		(void) strcat(sp, buf);
    247 		del_engr(oep);
    248 	} else
    249 		(void) strcpy(sp, buf);
    250 	ep->engr_lth = len+1;
    251 	ep->engr_type = type;
    252 	ep->engr_time = moves-multi;
    253 
    254 	/* kludge to protect pline against excessively long texts */
    255 	if(len > BUFSZ-20) sp[BUFSZ-20] = 0;
    256 
    257 	return(1);
    258 }
    259 
    260 save_engravings(fd) int fd; {
    261 	register struct engr *ep = head_engr;
    262 
    263 	while(ep) {
    264 		if(!ep->engr_lth || !ep->engr_txt[0]){
    265 			ep = ep->nxt_engr;
    266 			continue;
    267 		}
    268 		bwrite(fd, (char *) & (ep->engr_lth), sizeof(ep->engr_lth));
    269 		bwrite(fd, (char *) ep, sizeof(struct engr) + ep->engr_lth);
    270 		ep = ep->nxt_engr;
    271 	}
    272 	bwrite(fd, (char *) nul, sizeof(unsigned));
    273 #ifdef DGK
    274 	if (!count_only)
    275 #endif
    276 		head_engr = 0;
    277 }
    278 
    279 rest_engravings(fd) int fd; {
    280 register struct engr *ep;
    281 unsigned lth;
    282 	head_engr = 0;
    283 	while(1) {
    284 		mread(fd, (char *) &lth, sizeof(unsigned));
    285 		if(lth == 0) return;
    286 		ep = (struct engr *) alloc(sizeof(struct engr) + lth);
    287 		mread(fd, (char *) ep, sizeof(struct engr) + lth);
    288 		ep->nxt_engr = head_engr;
    289 		ep->engr_txt = (char *) (ep + 1);	/* Andreas Bormann */
    290 		head_engr = ep;
    291 	}
    292 }
    293 
    294 del_engr(ep) register struct engr *ep; {
    295 register struct engr *ept;
    296 	if(ep == head_engr)
    297 		head_engr = ep->nxt_engr;
    298 	else {
    299 		for(ept = head_engr; ept; ept = ept->nxt_engr) {
    300 			if(ept->nxt_engr == ep) {
    301 				ept->nxt_engr = ep->nxt_engr;
    302 				goto fnd;
    303 			}
    304 		}
    305 		impossible("Error in del_engr?");
    306 		return;
    307 	fnd:	;
    308 	}
    309 	free((char *) ep);
    310 }