[unix-history] / usr / src / games / hack / hack.do_wear.c

/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
/* hack.do_wear.c - version 1.0.3 */

#include "hack.h"
#include <stdio.h>
extern char *nomovemsg;
extern char quitchars[];
extern char *Doname();

off_msg(otmp) register struct obj *otmp; {
	pline("You were wearing %s.", doname(otmp));
}

doremarm() {
	register struct obj *otmp;
	if(!uarm && !uarmh && !uarms && !uarmg) {
		pline("Not wearing any armor.");
		return(0);
	}
	otmp = (!uarmh && !uarms && !uarmg) ? uarm :
		(!uarms && !uarm && !uarmg) ? uarmh :
		(!uarmh && !uarm && !uarmg) ? uarms :
		(!uarmh && !uarm && !uarms) ? uarmg :
		getobj("[", "take off");
	if(!otmp) return(0);
	if(!(otmp->owornmask & (W_ARMOR - W_ARM2))) {
		pline("You can't take that off.");
		return(0);
	}
	if( otmp == uarmg && uwep && uwep->cursed ) {	/* myers@uwmacc */
 pline("You seem not able to take off the gloves while holding your weapon.");
		return(0);
	}
	(void) armoroff(otmp);
	return(1);
}

doremring() {
	if(!uleft && !uright){
		pline("Not wearing any ring.");
		return(0);
	}
	if(!uleft)
		return(dorr(uright));
	if(!uright)
		return(dorr(uleft));
	if(uleft && uright) while(1) {
		char answer;

		pline("What ring, Right or Left? [ rl?]");
		if(index(quitchars, (answer = readchar())))
			return(0);
		switch(answer) {
		case 'l':
		case 'L':
			return(dorr(uleft));
		case 'r':
		case 'R':
			return(dorr(uright));
		case '?':
			(void) doprring();
			/* might look at morc here %% */
		}
	}
	/* NOTREACHED */
#ifdef lint
	return(0);
#endif lint
}

dorr(otmp) register struct obj *otmp; {
	if(cursed(otmp)) return(0);
	ringoff(otmp);
	off_msg(otmp);
	return(1);
}

cursed(otmp) register struct obj *otmp; {
	if(otmp->cursed){
		pline("You can't. It appears to be cursed.");
		return(1);
	}
	return(0);
}

armoroff(otmp) register struct obj *otmp; {
register int delay = -objects[otmp->otyp].oc_delay;
	if(cursed(otmp)) return(0);
	setworn((struct obj *) 0, otmp->owornmask & W_ARMOR);
	if(delay) {
		nomul(delay);
		switch(otmp->otyp) {
		case HELMET:
			nomovemsg = "You finished taking off your helmet.";
			break;
		case PAIR_OF_GLOVES:
			nomovemsg = "You finished taking off your gloves";
			break;
		default:
			nomovemsg = "You finished taking off your suit.";
		}
	} else {
		off_msg(otmp);
	}
	return(1);
}

doweararm() {
	register struct obj *otmp;
	register int delay;
	register int err = 0;
	long mask = 0;

	otmp = getobj("[", "wear");
	if(!otmp) return(0);
	if(otmp->owornmask & W_ARMOR) {
		pline("You are already wearing that!");
		return(0);
	}
	if(otmp->otyp == HELMET){
		if(uarmh) {
			pline("You are already wearing a helmet.");
			err++;
		} else
			mask = W_ARMH;
	} else if(otmp->otyp == SHIELD){
		if(uarms) pline("You are already wearing a shield."), err++;
		if(uwep && uwep->otyp == TWO_HANDED_SWORD)
	pline("You cannot wear a shield and wield a two-handed sword."), err++;
		if(!err) mask = W_ARMS;
	} else if(otmp->otyp == PAIR_OF_GLOVES) {
		if(uarmg) {
			pline("You are already wearing gloves.");
			err++;
		} else
		if(uwep && uwep->cursed) {
			pline("You cannot wear gloves over your weapon.");
			err++;
		} else
			mask = W_ARMG;
	} else {
		if(uarm) {
			if(otmp->otyp != ELVEN_CLOAK || uarm2) {
				pline("You are already wearing some armor.");
				err++;
			}
		}
		if(!err) mask = W_ARM;
	}
	if(otmp == uwep && uwep->cursed) {
		if(!err++)
			pline("%s is welded to your hand.", Doname(uwep));
	}
	if(err) return(0);
	setworn(otmp, mask);
	if(otmp == uwep)
		setuwep((struct obj *) 0);
	delay = -objects[otmp->otyp].oc_delay;
	if(delay){
		nomul(delay);
		nomovemsg = "You finished your dressing manoeuvre.";
	}
	otmp->known = 1;
	return(1);
}

dowearring() {
	register struct obj *otmp;
	long mask = 0;
	long oldprop;

	if(uleft && uright){
		pline("There are no more ring-fingers to fill.");
		return(0);
	}
	otmp = getobj("=", "wear");
	if(!otmp) return(0);
	if(otmp->owornmask & W_RING) {
		pline("You are already wearing that!");
		return(0);
	}
	if(otmp == uleft || otmp == uright) {
		pline("You are already wearing that.");
		return(0);
	}
	if(otmp == uwep && uwep->cursed) {
		pline("%s is welded to your hand.", Doname(uwep));
		return(0);
	}
	if(uleft) mask = RIGHT_RING;
	else if(uright) mask = LEFT_RING;
	else do {
		char answer;

 		pline("What ring-finger, Right or Left? ");
		if(index(quitchars, (answer = readchar())))
			return(0);
		switch(answer){
		case 'l':
		case 'L':
			mask = LEFT_RING;
			break;
		case 'r':
		case 'R':
			mask = RIGHT_RING;
			break;
		}
	} while(!mask);
	setworn(otmp, mask);
	if(otmp == uwep)
		setuwep((struct obj *) 0);
	oldprop = u.uprops[PROP(otmp->otyp)].p_flgs;
	u.uprops[PROP(otmp->otyp)].p_flgs |= mask;
	switch(otmp->otyp){
	case RIN_LEVITATION:
		if(!oldprop) float_up();
		break;
	case RIN_PROTECTION_FROM_SHAPE_CHANGERS:
		rescham();
		break;
	case RIN_GAIN_STRENGTH:
		u.ustr += otmp->spe;
		u.ustrmax += otmp->spe;
		if(u.ustr > 118) u.ustr = 118;
		if(u.ustrmax > 118) u.ustrmax = 118;
		flags.botl = 1;
		break;
	case RIN_INCREASE_DAMAGE:
		u.udaminc += otmp->spe;
		break;
	}
	prinv(otmp);
	return(1);
}

ringoff(obj)
register struct obj *obj;
{
register long mask;
	mask = obj->owornmask & W_RING;
	setworn((struct obj *) 0, obj->owornmask);
	if(!(u.uprops[PROP(obj->otyp)].p_flgs & mask))
		impossible("Strange... I didnt know you had that ring.");
	u.uprops[PROP(obj->otyp)].p_flgs &= ~mask;
	switch(obj->otyp) {
	case RIN_FIRE_RESISTANCE:
		/* Bad luck if the player is in hell... --jgm */
		if (!Fire_resistance && dlevel >= 30) {
			pline("The flames of Hell burn you to a crisp.");
			killer = "stupidity in hell";
			done("burned");
		}
		break;
	case RIN_LEVITATION:
		if(!Levitation) {	/* no longer floating */
			float_down();
		}
		break;
	case RIN_GAIN_STRENGTH:
		u.ustr -= obj->spe;
		u.ustrmax -= obj->spe;
		if(u.ustr > 118) u.ustr = 118;
		if(u.ustrmax > 118) u.ustrmax = 118;
		flags.botl = 1;
		break;
	case RIN_INCREASE_DAMAGE:
		u.udaminc -= obj->spe;
		break;
	}
}

find_ac(){
register int uac = 10;
	if(uarm) uac -= ARM_BONUS(uarm);
	if(uarm2) uac -= ARM_BONUS(uarm2);
	if(uarmh) uac -= ARM_BONUS(uarmh);
	if(uarms) uac -= ARM_BONUS(uarms);
	if(uarmg) uac -= ARM_BONUS(uarmg);
	if(uleft && uleft->otyp == RIN_PROTECTION) uac -= uleft->spe;
	if(uright && uright->otyp == RIN_PROTECTION) uac -= uright->spe;
	if(uac != u.uac){
		u.uac = uac;
		flags.botl = 1;
	}
}

glibr(){
register struct obj *otmp;
int xfl = 0;
	if(!uarmg) if(uleft || uright) {
		/* Note: at present also cursed rings fall off */
		pline("Your %s off your fingers.",
			(uleft && uright) ? "rings slip" : "ring slips");
		xfl++;
		if((otmp = uleft) != Null(obj)){
			ringoff(uleft);
			dropx(otmp);
		}
		if((otmp = uright) != Null(obj)){
			ringoff(uright);
			dropx(otmp);
		}
	}
	if((otmp = uwep) != Null(obj)){
		/* Note: at present also cursed weapons fall */
		setuwep((struct obj *) 0);
		dropx(otmp);
		pline("Your weapon %sslips from your hands.",
			xfl ? "also " : "");
	}
}

struct obj *
some_armor(){
register struct obj *otmph = uarm;
	if(uarmh && (!otmph || !rn2(4))) otmph = uarmh;
	if(uarmg && (!otmph || !rn2(4))) otmph = uarmg;
	if(uarms && (!otmph || !rn2(4))) otmph = uarms;
	return(otmph);
}

corrode_armor(){
register struct obj *otmph = some_armor();
	if(otmph){
		if(otmph->rustfree ||
		   otmph->otyp == ELVEN_CLOAK ||
		   otmph->otyp == LEATHER_ARMOR ||
		   otmph->otyp == STUDDED_LEATHER_ARMOR) {
			pline("Your %s not affected!",
				aobjnam(otmph, "are"));
			return;
		}
		pline("Your %s!", aobjnam(otmph, "corrode"));
		otmph->spe--;
	}
}
Commit	Line	Data
58a031ac KB	1	/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
	2	/* hack.do_wear.c - version 1.0.3 */
	3
	4	#include "hack.h"
	5	#include <stdio.h>
	6	extern char *nomovemsg;
	7	extern char quitchars[];
	8	extern char *Doname();
	9
	10	off_msg(otmp) register struct obj *otmp; {
	11	pline("You were wearing %s.", doname(otmp));
	12	}
	13
	14	doremarm() {
	15	register struct obj *otmp;
	16	if(!uarm && !uarmh && !uarms && !uarmg) {
	17	pline("Not wearing any armor.");
	18	return(0);
	19	}
	20	otmp = (!uarmh && !uarms && !uarmg) ? uarm :
	21	(!uarms && !uarm && !uarmg) ? uarmh :
	22	(!uarmh && !uarm && !uarmg) ? uarms :
	23	(!uarmh && !uarm && !uarms) ? uarmg :
	24	getobj("[", "take off");
	25	if(!otmp) return(0);
	26	if(!(otmp->owornmask & (W_ARMOR - W_ARM2))) {
	27	pline("You can't take that off.");
	28	return(0);
	29	}
	30	if( otmp == uarmg && uwep && uwep->cursed ) { /* myers@uwmacc */
	31	pline("You seem not able to take off the gloves while holding your weapon.");
	32	return(0);
	33	}
	34	(void) armoroff(otmp);
	35	return(1);
	36	}
	37
	38	doremring() {
	39	if(!uleft && !uright){
	40	pline("Not wearing any ring.");
	41	return(0);
	42	}
	43	if(!uleft)
	44	return(dorr(uright));
	45	if(!uright)
	46	return(dorr(uleft));
	47	if(uleft && uright) while(1) {
	48	char answer;
	49
	50	pline("What ring, Right or Left? [ rl?]");
	51	if(index(quitchars, (answer = readchar())))
	52	return(0);
	53	switch(answer) {
	54	case 'l':
	55	case 'L':
	56	return(dorr(uleft));
	57	case 'r':
	58	case 'R':
	59	return(dorr(uright));
	60	case '?':
	61	(void) doprring();
	62	/* might look at morc here %% */
	63	}
	64	}
65	/* NOTREACHED */
66	#ifdef lint
67	return(0);
68	#endif lint
69	}
70
71	dorr(otmp) register struct obj *otmp; {
72	if(cursed(otmp)) return(0);
73	ringoff(otmp);
74	off_msg(otmp);
75	return(1);
76	}
77
78	cursed(otmp) register struct obj *otmp; {
79	if(otmp->cursed){
80	pline("You can't. It appears to be cursed.");
81	return(1);
82	}
83	return(0);
84	}
85
86	armoroff(otmp) register struct obj *otmp; {
87	register int delay = -objects[otmp->otyp].oc_delay;
88	if(cursed(otmp)) return(0);
89	setworn((struct obj *) 0, otmp->owornmask & W_ARMOR);
90	if(delay) {
91	nomul(delay);
92	switch(otmp->otyp) {
93	case HELMET:
94	nomovemsg = "You finished taking off your helmet.";
95	break;
96	case PAIR_OF_GLOVES:
97	nomovemsg = "You finished taking off your gloves";
98	break;
99	default:
100	nomovemsg = "You finished taking off your suit.";
101	}
102	} else {
103	off_msg(otmp);
104	}
105	return(1);
106	}
107
108	doweararm() {
109	register struct obj *otmp;
110	register int delay;
111	register int err = 0;
112	long mask = 0;
113
114	otmp = getobj("[", "wear");
115	if(!otmp) return(0);
116	if(otmp->owornmask & W_ARMOR) {
117	pline("You are already wearing that!");
118	return(0);
119	}
120	if(otmp->otyp == HELMET){
121	if(uarmh) {
122	pline("You are already wearing a helmet.");
123	err++;
124	} else
125	mask = W_ARMH;
126	} else if(otmp->otyp == SHIELD){
127	if(uarms) pline("You are already wearing a shield."), err++;
128	if(uwep && uwep->otyp == TWO_HANDED_SWORD)
129	pline("You cannot wear a shield and wield a two-handed sword."), err++;
130	if(!err) mask = W_ARMS;
131	} else if(otmp->otyp == PAIR_OF_GLOVES) {
132	if(uarmg) {
133	pline("You are already wearing gloves.");
134	err++;
135	} else
136	if(uwep && uwep->cursed) {
137	pline("You cannot wear gloves over your weapon.");
138	err++;
139	} else
140	mask = W_ARMG;
141	} else {
142	if(uarm) {
143	if(otmp->otyp != ELVEN_CLOAK \|\| uarm2) {
144	pline("You are already wearing some armor.");
145	err++;
146	}
147	}
148	if(!err) mask = W_ARM;
149	}
150	if(otmp == uwep && uwep->cursed) {
151	if(!err++)
152	pline("%s is welded to your hand.", Doname(uwep));
153	}
154	if(err) return(0);
155	setworn(otmp, mask);
156	if(otmp == uwep)
157	setuwep((struct obj *) 0);
158	delay = -objects[otmp->otyp].oc_delay;
159	if(delay){
160	nomul(delay);
161	nomovemsg = "You finished your dressing manoeuvre.";
162	}
163	otmp->known = 1;
164	return(1);
165	}
166
167	dowearring() {
168	register struct obj *otmp;
169	long mask = 0;
170	long oldprop;
171
172	if(uleft && uright){
173	pline("There are no more ring-fingers to fill.");
174	return(0);
175	}
176	otmp = getobj("=", "wear");
177	if(!otmp) return(0);
178	if(otmp->owornmask & W_RING) {
179	pline("You are already wearing that!");
180	return(0);
181	}
182	if(otmp == uleft \|\| otmp == uright) {
183	pline("You are already wearing that.");
184	return(0);
185	}
186	if(otmp == uwep && uwep->cursed) {
187	pline("%s is welded to your hand.", Doname(uwep));
188	return(0);
189	}
190	if(uleft) mask = RIGHT_RING;
191	else if(uright) mask = LEFT_RING;
192	else do {
193	char answer;
194
195	pline("What ring-finger, Right or Left? ");
196	if(index(quitchars, (answer = readchar())))
197	return(0);
198	switch(answer){
199	case 'l':
200	case 'L':
201	mask = LEFT_RING;
202	break;
203	case 'r':
204	case 'R':
205	mask = RIGHT_RING;
206	break;
207	}
208	} while(!mask);
209	setworn(otmp, mask);
210	if(otmp == uwep)
211	setuwep((struct obj *) 0);
212	oldprop = u.uprops[PROP(otmp->otyp)].p_flgs;
213	u.uprops[PROP(otmp->otyp)].p_flgs \|= mask;
214	switch(otmp->otyp){
215	case RIN_LEVITATION:
216	if(!oldprop) float_up();
217	break;
218	case RIN_PROTECTION_FROM_SHAPE_CHANGERS:
219	rescham();
220	break;
221	case RIN_GAIN_STRENGTH:
222	u.ustr += otmp->spe;
223	u.ustrmax += otmp->spe;
224	if(u.ustr > 118) u.ustr = 118;
225	if(u.ustrmax > 118) u.ustrmax = 118;
226	flags.botl = 1;
227	break;
228	case RIN_INCREASE_DAMAGE:
229	u.udaminc += otmp->spe;
230	break;
231	}
232	prinv(otmp);
233	return(1);
234	}
235
236	ringoff(obj)
237	register struct obj *obj;
238	{
239	register long mask;
240	mask = obj->owornmask & W_RING;
241	setworn((struct obj *) 0, obj->owornmask);
242	if(!(u.uprops[PROP(obj->otyp)].p_flgs & mask))
243	impossible("Strange... I didnt know you had that ring.");
244	u.uprops[PROP(obj->otyp)].p_flgs &= ~mask;
245	switch(obj->otyp) {
246	case RIN_FIRE_RESISTANCE:
247	/* Bad luck if the player is in hell... --jgm */
248	if (!Fire_resistance && dlevel >= 30) {
249	pline("The flames of Hell burn you to a crisp.");
250	killer = "stupidity in hell";
251	done("burned");
252	}
253	break;
254	case RIN_LEVITATION:
255	if(!Levitation) { /* no longer floating */
256	float_down();
257	}
258	break;
259	case RIN_GAIN_STRENGTH:
260	u.ustr -= obj->spe;
261	u.ustrmax -= obj->spe;
262	if(u.ustr > 118) u.ustr = 118;
263	if(u.ustrmax > 118) u.ustrmax = 118;
264	flags.botl = 1;
265	break;
266	case RIN_INCREASE_DAMAGE:
267	u.udaminc -= obj->spe;
268	break;
269	}
270	}
271
272	find_ac(){
273	register int uac = 10;
274	if(uarm) uac -= ARM_BONUS(uarm);
275	if(uarm2) uac -= ARM_BONUS(uarm2);
276	if(uarmh) uac -= ARM_BONUS(uarmh);
277	if(uarms) uac -= ARM_BONUS(uarms);
278	if(uarmg) uac -= ARM_BONUS(uarmg);
279	if(uleft && uleft->otyp == RIN_PROTECTION) uac -= uleft->spe;
280	if(uright && uright->otyp == RIN_PROTECTION) uac -= uright->spe;
281	if(uac != u.uac){
282	u.uac = uac;
283	flags.botl = 1;
284	}
285	}
286
287	glibr(){
288	register struct obj *otmp;
289	int xfl = 0;
290	if(!uarmg) if(uleft \|\| uright) {
291	/* Note: at present also cursed rings fall off */
292	pline("Your %s off your fingers.",
293	(uleft && uright) ? "rings slip" : "ring slips");
294	xfl++;
295	if((otmp = uleft) != Null(obj)){
296	ringoff(uleft);
297	dropx(otmp);
298	}
299	if((otmp = uright) != Null(obj)){
300	ringoff(uright);
301	dropx(otmp);
302	}
303	}
304	if((otmp = uwep) != Null(obj)){
305	/* Note: at present also cursed weapons fall */
306	setuwep((struct obj *) 0);
307	dropx(otmp);
308	pline("Your weapon %sslips from your hands.",
309	xfl ? "also " : "");
310	}
311	}
312
313	struct obj *
314	some_armor(){
315	register struct obj *otmph = uarm;
316	if(uarmh && (!otmph \|\| !rn2(4))) otmph = uarmh;
317	if(uarmg && (!otmph \|\| !rn2(4))) otmph = uarmg;
318	if(uarms && (!otmph \|\| !rn2(4))) otmph = uarms;
319	return(otmph);
320	}
321
322	corrode_armor(){
323	register struct obj *otmph = some_armor();
324	if(otmph){
325	if(otmph->rustfree \|\|
326	otmph->otyp == ELVEN_CLOAK \|\|
327	otmph->otyp == LEATHER_ARMOR \|\|
328	otmph->otyp == STUDDED_LEATHER_ARMOR) {
329	pline("Your %s not affected!",
330	aobjnam(otmph, "are"));
331	return;
332	}
333	pline("Your %s!", aobjnam(otmph, "corrode"));
334	otmph->spe--;
335	}
336	}