Wikia

Wikihack

Source:NetHack 3.1.0/mkobj.c

2,032pages on
this wiki
Talk0

Below is the full text to mkobj.c from the source code of NetHack 3.1.0. To link to a particular line, write [[NetHack 3.1.0/mkobj.c#line123]], for example.

Warning! This is the source code from an old release. For the latest release, see Source code

The NetHack General Public License applies to screenshots, source code and other content from NetHack.
1.    /*	SCCS Id: @(#)mkobj.c	3.1	93/01/17	*/
2.    /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
3.    /* NetHack may be freely redistributed.  See license for details. */
4.    
5.    #include "hack.h"
6.    #include "artifact.h"
7.    #include "prop.h"
8.    
9.    STATIC_DCL void FDECL(mkbox_cnts,(struct obj *));
10.   
11.   struct icp {
12.       int  iprob; /* probability of an item type */
13.       char ilet;	/* item class */
14.   };
15.   
16.   #ifdef OVL1
17.   
18.   const struct icp mkobjprobs[] = {
19.   {10, WEAPON_CLASS},
20.   {10, ARMOR_CLASS},
21.   {20, FOOD_CLASS},
22.   { 8, TOOL_CLASS},
23.   { 8, GEM_CLASS},
24.   {16, POTION_CLASS},
25.   {16, SCROLL_CLASS},
26.   { 4, SPBOOK_CLASS},
27.   { 4, WAND_CLASS},
28.   { 3, RING_CLASS},
29.   { 1, AMULET_CLASS}
30.   };
31.   
32.   const struct icp boxiprobs[] = {
33.   {18, GEM_CLASS},
34.   {15, FOOD_CLASS},
35.   {18, POTION_CLASS},
36.   {18, SCROLL_CLASS},
37.   {12, SPBOOK_CLASS},
38.   { 7, GOLD_CLASS},
39.   { 6, WAND_CLASS},
40.   { 5, RING_CLASS},
41.   { 1, AMULET_CLASS}
42.   };
43.   
44.   #ifdef REINCARNATION
45.   const struct icp rogueprobs[] = {
46.   {12, WEAPON_CLASS},
47.   {12, ARMOR_CLASS},
48.   {22, FOOD_CLASS},
49.   {22, POTION_CLASS},
50.   {22, SCROLL_CLASS},
51.   { 5, WAND_CLASS},
52.   { 5, RING_CLASS}
53.   };
54.   #endif
55.   
56.   const struct icp hellprobs[] = {
57.   {20, WEAPON_CLASS},
58.   {20, ARMOR_CLASS},
59.   {16, FOOD_CLASS},
60.   {12, TOOL_CLASS},
61.   {10, GEM_CLASS},
62.   { 1, POTION_CLASS},
63.   { 1, SCROLL_CLASS},
64.   { 8, WAND_CLASS},
65.   { 8, RING_CLASS},
66.   { 4, AMULET_CLASS}
67.   };
68.   
69.   static int NEARDATA mksx=0, NEARDATA mksy=0;
70.   
71.   struct obj *
72.   mkobj_at(let,x,y, artif)
73.   char let;
74.   int x,y;
75.   boolean artif;
76.   {
77.   	register struct obj *otmp;
78.   
79.   	mksx = x; mksy = y;
80.   	/* We need to know the X, Y coordinates while creating the object,
81.   	 * to insure shop boxes are empty.
82.   	 * Yes, this is a horrible kludge...
83.   	 */
84.   	otmp = mkobj(let,artif);
85.   	otmp->nobj = fobj;
86.   	fobj = otmp;
87.   	place_object(otmp, x, y);
88.   	mksx = mksy = 0;
89.   	return(otmp);
90.   }
91.   
92.   struct obj *
93.   mksobj_at(otyp,x,y,init)
94.   int otyp,x,y;
95.   boolean init;
96.   {
97.   	register struct obj *otmp;
98.   
99.   	mksx = x; mksy = y;
100.  	otmp = mksobj(otyp,init,TRUE);
101.  	otmp->nobj = fobj;
102.  	place_object(otmp, x, y);
103.  	mksx = mksy = 0;
104.  	return((fobj = otmp));
105.  }
106.  
107.  struct obj *
108.  mkobj(let, artif)
109.  char let;
110.  boolean artif;
111.  {
112.  	register int tprob, i, prob = rnd(1000);
113.  
114.  	if(let == RANDOM_CLASS) {
115.  		const struct icp *iprobs =
116.  #ifdef REINCARNATION
117.  				    (Is_rogue_level(&u.uz)) ?
118.  				    (const struct icp *)rogueprobs :
119.  #endif
120.  				    Inhell ? (const struct icp *)hellprobs :
121.  				    (const struct icp *)mkobjprobs;
122.  
123.  		for(tprob = rnd(100);
124.  		    (tprob -= iprobs->iprob) > 0;
125.  		    iprobs++);
126.  		let = iprobs->ilet;
127.  	}
128.  
129.  	i = bases[letindex(let)];
130.  	while((prob -= objects[i].oc_prob) > 0) i++;
131.  
132.  	if(objects[i].oc_class != let || !OBJ_NAME(objects[i]))
133.  		panic("probtype error, let=%c i=%d", let, i);
134.  
135.  	return(mksobj(i, TRUE, artif));
136.  }
137.  
138.  STATIC_OVL void
139.  mkbox_cnts(box)
140.  /* Note: does not check to see if it overloaded the box capacity; usually
141.   * possible only with corpses in ice boxes.
142.   */
143.  struct obj *box;
144.  {
145.  	register int n;
146.  	register struct obj *otmp, *gold = 0;
147.  
148.  	box->cobj = (struct obj *) 0;
149.  
150.  	switch(box->otyp) {
151.  		case ICE_BOX:		n = 20; break;
152.  		case CHEST:		n = 5; break;
153.  		case LARGE_BOX:		n = 3; break;
154.  		case SACK:
155.  		case OILSKIN_SACK:
156.  		case BAG_OF_HOLDING:	n = 1; break;
157.  		default:		n = 0; break;
158.  	}
159.  
160.  	for (n = rn2(n+1); n > 0; n--) {
161.  	    if (box->otyp == ICE_BOX) {
162.  		if (!(otmp = mksobj(CORPSE, TRUE, TRUE))) continue;
163.  		/* Note: setting age to 0 is correct.  Age has a different
164.  		 * from usual meaning for objects stored in ice boxes. -KAA
165.  		 */
166.  		otmp->age = 0L;
167.  	    } else {
168.  		register int tprob;
169.  		const struct icp *iprobs = boxiprobs;
170.  
171.  		for (tprob = rnd(100); (tprob -= iprobs->iprob) > 0; iprobs++)
172.  		    ;
173.  		if (!(otmp = mkobj(iprobs->ilet, TRUE))) continue;
174.  
175.  		/* handle a couple of special cases */
176.  		if (otmp->otyp == GOLD_PIECE) {
177.  		    /* 2.5 x level's usual amount; weight adjusted below */
178.  		    otmp->quan = (long)(rnd(level_difficulty()+2) * rnd(75));
179.  		    if (gold) {			/* gold already in this box */
180.  			gold->quan += otmp->quan;	/* merge */
181.  			dealloc_obj(otmp);	/* note: not yet in any chain */
182.  			continue;
183.  		    } else {
184.  			gold = otmp;		/* remember this object */
185.  		    }
186.  		} else while (otmp->otyp == ROCK) {
187.  		    otmp->otyp = rnd_class(DILITHIUM_CRYSTAL, LOADSTONE);
188.  		    if (otmp->quan > 2L) otmp->quan = 1L;
189.  		    otmp->owt = weight(otmp);
190.  		}
191.  		if (box->otyp == BAG_OF_HOLDING) {
192.  		    if (Is_mbag(otmp)) {
193.  			otmp->otyp = SACK;
194.  			otmp->spe = 0;
195.  			otmp->owt = weight(otmp);
196.  		    } else while (otmp->otyp == WAN_CANCELLATION)
197.  			    otmp->otyp = rnd_class(WAN_LIGHT, WAN_LIGHTNING);
198.  		}
199.  	    }
200.  	    otmp->nobj = box->cobj;
201.  	    box->cobj = otmp;
202.  	}
203.  	if (gold) gold->owt = weight(gold);	/* quantity was diddled */
204.  	return;
205.  }
206.  
207.  int
208.  rndmonnum()	/* select a random, common monster type */
209.  {
210.  	register struct permonst *ptr;
211.  	register int	i;
212.  
213.  	/* Plan A: get a level-appropriate common monster */
214.  	ptr = rndmonst();
215.  	if (ptr) return(monsndx(ptr));
216.  
217.  	/* Plan B: get any common monster */
218.  	do {
219.  	    ptr = &mons[(i = rn2(NUMMONS))];
220.  	} while((ptr->geno & G_NOGEN) || (!Inhell && (ptr->geno & G_HELL)));
221.  
222.  	return(i);
223.  }
224.  
225.  #endif /* OVL1 */
226.  #ifdef OVLB
227.  const char dknowns[] = { WAND_CLASS, RING_CLASS, POTION_CLASS, SCROLL_CLASS,
228.  			 GEM_CLASS, SPBOOK_CLASS, WEAPON_CLASS, 0};
229.  
230.  /*ARGSUSED*/
231.  struct obj *
232.  mksobj(otyp, init, artif)
233.  int otyp;
234.  boolean init;
235.  boolean artif;
236.  {
237.  	int tryct;
238.  	struct obj *otmp;
239.  	char let = objects[otyp].oc_class;
240.  
241.  	otmp = newobj(0);
242.  	*otmp = zeroobj;
243.  	otmp->age = monstermoves;
244.  	otmp->o_id = flags.ident++;
245.  	otmp->quan = 1L;
246.  	otmp->oclass = let;
247.  	otmp->otyp = otyp;
248.  	otmp->dknown = index(dknowns, let) ? 0 : 1;
249.  	if (!objects[otmp->otyp].oc_uses_known)
250.  		otmp->known = 1;
251.  	if (init) switch (let) {
252.  	case WEAPON_CLASS:
253.  		otmp->quan = (otmp->otyp <= SHURIKEN) ? (long) rn1(6,6) : 1L;
254.  		if(!rn2(11)) {
255.  			otmp->spe = rne(3);
256.  			otmp->blessed = rn2(2);
257.  		} else if(!rn2(10)) {
258.  			curse(otmp);
259.  			otmp->spe = -rne(3);
260.  		} else	blessorcurse(otmp, 10);
261.  
262.  		if (artif && !rn2(20))
263.  		    otmp = mk_artifact(otmp, (aligntyp)A_NONE);
264.  		break;
265.  	case FOOD_CLASS:
266.  	    otmp->oeaten = 0;
267.  	    switch(otmp->otyp) {
268.  		case CORPSE:
269.  		    /* overridden by mkcorpstat() */
270.  		    do otmp->corpsenm = rndmonnum();
271.  		    while (mons[otmp->corpsenm].geno & G_NOCORPSE);
272.  		    break;
273.  		case EGG:
274.  		    if(!rn2(3)) {		/* "live" eggs */
275.  			register struct permonst *ptr;
276.  			for(tryct = 0;
277.  			    (!(ptr = rndmonst()) ||
278.  			    (!lays_eggs(ptr) && ptr != &mons[PM_KILLER_BEE])) &&
279.  				tryct < 100;
280.  			    tryct++);
281.  			if(tryct < 100)	otmp->corpsenm = monsndx(ptr);
282.  			else		otmp->corpsenm = -1; /* empty */
283.  		    } else		otmp->corpsenm = -1; /* empty */
284.  		    break;
285.  		case TIN:
286.  		    if(!rn2(6)) {
287.  			otmp->spe = 1;		/* spinach */
288.  			otmp->corpsenm = -1;
289.  		    } else do {
290.  			otmp->corpsenm = rndmonnum();
291.  		    } while (mons[otmp->corpsenm].geno & G_NOCORPSE);
292.  		    blessorcurse(otmp, 10);
293.  		    break;
294.  #ifdef TUTTI_FRUTTI
295.  		case SLIME_MOLD:
296.  		    otmp->spe = current_fruit;
297.  		    break;
298.  #endif
299.  	    }
300.  	    if (otmp->otyp == CORPSE) break;
301.  	    /* fall into next case */
302.  
303.  	case GEM_CLASS:
304.  		if (otmp->otyp == LOADSTONE) curse(otmp);
305.  		else if (otmp->otyp == ROCK) otmp->quan = (long) rn1(6,6);
306.  		else if (otmp->otyp != LUCKSTONE && !rn2(6)) otmp->quan = 2L;
307.  		else otmp->quan = 1L;
308.  		break;
309.  	case TOOL_CLASS:
310.  	    switch(otmp->otyp) {
311.  		case TALLOW_CANDLE:
312.  		case WAX_CANDLE:	otmp->spe = 1;
313.  					otmp->age = 20L * /* 400 or 200 */
314.  					      (long)objects[otmp->otyp].oc_cost;
315.  					otmp->lamplit = 0;
316.  					otmp->quan = 1L +
317.  					      (long)(rn2(2) ? rn2(7) : 0);
318.  					blessorcurse(otmp, 5);
319.  					break;
320.  		case BRASS_LANTERN:
321.  		case OIL_LAMP:		otmp->spe = 1;
322.  					otmp->age = (long) rn1(500,1000);
323.  					otmp->lamplit = 0;
324.  					blessorcurse(otmp, 5);
325.  					break;
326.  		case MAGIC_LAMP:	otmp->spe = 1;
327.  					otmp->lamplit = 0;
328.  					blessorcurse(otmp, 2);
329.  					break;
330.  		case CHEST:
331.  		case LARGE_BOX:		otmp->olocked = !!(rn2(5));
332.  					otmp->otrapped = !(rn2(10));
333.  		case ICE_BOX:
334.  		case SACK:
335.  		case OILSKIN_SACK:
336.  		case BAG_OF_HOLDING:	mkbox_cnts(otmp);
337.  					break;
338.  		case MAGIC_MARKER:	otmp->spe = rn1(70,30);
339.  					break;
340.  		case CAN_OF_GREASE:	otmp->spe = rnd(25);
341.  					blessorcurse(otmp, 10);
342.  					break;
343.  		case CRYSTAL_BALL:	otmp->spe = rnd(5);
344.  					blessorcurse(otmp, 2);
345.  					break;
346.  		case HORN_OF_PLENTY:
347.  		case BAG_OF_TRICKS:	otmp->spe = rnd(20);
348.  					break;
349.  		case FIGURINE:	{	int tryct2 = 0;
350.  					do
351.  					    otmp->corpsenm = rndmonnum();
352.  					while(is_human(&mons[otmp->corpsenm])
353.  						&& tryct2++ < 30);
354.  					blessorcurse(otmp, 4);
355.  					break;
356.  				}
357.  		case BELL_OF_OPENING:   otmp->spe = 3;
358.  					break;
359.  		case MAGIC_FLUTE:
360.  		case MAGIC_HARP:
361.  		case FROST_HORN:
362.  		case FIRE_HORN:
363.  		case DRUM_OF_EARTHQUAKE:
364.  					otmp->spe = rn1(5,4);
365.  					break;
366.  	    }
367.  	    break;
368.  	case AMULET_CLASS:
369.  		if(rn2(10) && (otmp->otyp == AMULET_OF_STRANGULATION ||
370.  		   otmp->otyp == AMULET_OF_CHANGE ||
371.  		   otmp->otyp == AMULET_OF_RESTFUL_SLEEP)) {
372.  			curse(otmp);
373.  		} else	blessorcurse(otmp, 10);
374.  	case VENOM_CLASS:
375.  	case CHAIN_CLASS:
376.  	case BALL_CLASS:
377.  		break;
378.  	case POTION_CLASS:
379.  	case SCROLL_CLASS:
380.  #ifdef MAIL
381.  		if (otmp->otyp != SCR_MAIL)
382.  #endif
383.  			blessorcurse(otmp, 4);
384.  		break;
385.  	case SPBOOK_CLASS:
386.  		blessorcurse(otmp, 17);
387.  		break;
388.  	case ARMOR_CLASS:
389.  		if(rn2(10) && (otmp->otyp == FUMBLE_BOOTS ||
390.  		   otmp->otyp == LEVITATION_BOOTS ||
391.  		   otmp->otyp == HELM_OF_OPPOSITE_ALIGNMENT ||
392.  		   otmp->otyp == GAUNTLETS_OF_FUMBLING ||
393.  		   !rn2(11))) {
394.  			curse(otmp);
395.  			otmp->spe = -rne(3);
396.  		} else if(!rn2(10)) {
397.  			otmp->blessed = rn2(2);
398.  			otmp->spe = rne(3);
399.  		} else	blessorcurse(otmp, 10);
400.  		break;
401.  	case WAND_CLASS:
402.  		if(otmp->otyp == WAN_WISHING) otmp->spe = rnd(3); else
403.  		otmp->spe = rn1(5,
404.  			(objects[otmp->otyp].oc_dir == NODIR) ? 11 : 4);
405.  		blessorcurse(otmp, 17);
406.  		otmp->recharged = 0; /* used to control recharging */
407.  		break;
408.  	case RING_CLASS:
409.  		if(objects[otmp->otyp].oc_charged) {
410.  		    blessorcurse(otmp, 3);
411.  		    if(rn2(10)) {
412.  			if(rn2(10) && bcsign(otmp))
413.  			    otmp->spe = bcsign(otmp) * rne(3);
414.  			else otmp->spe = rn2(2) ? rne(3) : -rne(3);
415.  		    }
416.  		    /* make useless +0 rings much less common */
417.  		    if (otmp->spe == 0) otmp->spe = rn2(4) - rn2(3);
418.  		    /* negative rings are usually cursed */
419.  		    if (otmp->spe < 0 && rn2(5)) curse(otmp);
420.  		} else if(rn2(10) && (otmp->otyp == RIN_TELEPORTATION ||
421.  #ifdef POLYSELF
422.  			  otmp->otyp == RIN_POLYMORPH ||
423.  #endif
424.  			  otmp->otyp == RIN_AGGRAVATE_MONSTER ||
425.  			  otmp->otyp == RIN_HUNGER || !rn2(9))) {
426.  			curse(otmp);
427.  		}
428.  		break;
429.  	case ROCK_CLASS:
430.  		switch (otmp->otyp) {
431.  		    case STATUE:
432.  			if (rn2(level_difficulty()/2 + 10) > 10) {
433.  				struct obj *book;
434.  				book = mkobj(SPBOOK_CLASS,FALSE);
435.  				otmp->cobj = book;
436.  			}
437.  			/* overridden by mkcorpstat() */
438.  			otmp->corpsenm = rndmonnum();
439.  		}
440.  		break;
441.  	case GOLD_CLASS:
442.  		break;	/* do nothing */
443.  	default:
444.  		impossible("impossible mkobj %d, sym '%c'.", otmp->otyp, objects[otmp->otyp].oc_class);
445.  		return (struct obj *)0;
446.  	}
447.  	/* unique objects may have an associated artifact entry */
448.  	if (objects[otyp].oc_unique && !otmp->oartifact)
449.  	    otmp = mk_artifact(otmp, (aligntyp)A_NONE);
450.  	otmp->owt = weight(otmp);
451.  	return(otmp);
452.  }
453.  
454.  void
455.  bless(otmp)
456.  register struct obj *otmp;
457.  {
458.  	otmp->cursed = 0;
459.  	otmp->blessed = 1;
460.  	if (otmp->otyp == LUCKSTONE
461.  	    || (otmp->oartifact && spec_ability(otmp, SPFX_LUCK))) {
462.  	    int luckbon = stone_luck(TRUE);
463.  	    if(!luckbon && !carrying(LUCKSTONE)) u.moreluck = 0;
464.  	    else if (luckbon >= 0) u.moreluck = LUCKADD;
465.  	    else u.moreluck = -LUCKADD;
466.  	} else if (otmp->otyp == BAG_OF_HOLDING)
467.  	    otmp->owt = weight(otmp);
468.  	return;
469.  }
470.  
471.  void
472.  unbless(otmp)
473.  register struct obj *otmp;
474.  {
475.  	otmp->blessed = 0;
476.  	if (otmp->otyp == LUCKSTONE
477.  	    || (otmp->oartifact && spec_ability(otmp, SPFX_LUCK))) {
478.  	    int luckbon = stone_luck(TRUE);
479.  	    if (!luckbon && !carrying(LUCKSTONE)) u.moreluck = 0;
480.  	    else if (luckbon >= 0) u.moreluck = LUCKADD;
481.  	    else u.moreluck = -LUCKADD;
482.  	} else if (otmp->otyp == BAG_OF_HOLDING)
483.  	    otmp->owt = weight(otmp);
484.  }
485.  
486.  void
487.  curse(otmp)
488.  register struct obj *otmp;
489.  {
490.  	otmp->blessed = 0;
491.  	otmp->cursed = 1;
492.  	if (otmp->otyp == LUCKSTONE
493.  	    || (otmp->oartifact && spec_ability(otmp, SPFX_LUCK))) {
494.  	    int luckbon = stone_luck(TRUE);
495.  	    if (!luckbon && !carrying(LUCKSTONE)) u.moreluck = 0;
496.  	    else if (luckbon >= 0) u.moreluck = LUCKADD;
497.  	    else u.moreluck = -LUCKADD;
498.  	} else if (otmp->otyp == BAG_OF_HOLDING)
499.  	    otmp->owt = weight(otmp);
500.  	return;
501.  }
502.  
503.  void
504.  uncurse(otmp)
505.  register struct obj *otmp;
506.  {
507.  	otmp->cursed = 0;
508.  	if (otmp->otyp == LUCKSTONE
509.  	    || (otmp->oartifact && spec_ability(otmp, SPFX_LUCK))) {
510.  	    int luckbon = stone_luck(TRUE);
511.  	    if (!luckbon && !carrying(LUCKSTONE)) u.moreluck = 0;
512.  	    else if (luckbon >= 0) u.moreluck = LUCKADD;
513.  	    else u.moreluck = -LUCKADD;
514.  	} else if (otmp->otyp == BAG_OF_HOLDING)
515.  		otmp->owt = weight(otmp);
516.  }
517.  
518.  #endif /* OVLB */
519.  #ifdef OVL1
520.  void
521.  blessorcurse(otmp, chance)
522.  register struct obj *otmp;
523.  register int chance;
524.  {
525.  	if(otmp->blessed || otmp->cursed) return;
526.  
527.  	if(!rn2(chance))
528.  	    if(!rn2(2)) {
529.  		curse(otmp);
530.  	    } else {
531.  		bless(otmp);
532.  	    }
533.  	return;
534.  }
535.  
536.  #endif /* OVL1 */
537.  #ifdef OVLB
538.  
539.  int
540.  bcsign(otmp)
541.  register struct obj *otmp;
542.  {
543.  	return(!!otmp->blessed - !!otmp->cursed);
544.  }
545.  
546.  #endif /* OVLB */
547.  #ifdef OVL0
548.  
549.  /*
550.   *  Calculate the weight of the given object.  This will recursively follow
551.   *  and calculate the weight of any containers.
552.   *
553.   *  Note:  It is possible to end up with an incorrect weight if some part
554.   *	   of the code messes with a contained object and doesn't update the
555.   *	   container's weight.
556.   */
557.  int
558.  weight(obj)
559.  register struct obj *obj;
560.  {
561.  	int wt = objects[obj->otyp].oc_weight;
562.  
563.  	if (Is_container(obj) || obj->otyp == STATUE) {
564.  		struct obj *contents;
565.  		register int cwt = 0;
566.  
567.  		if (obj->otyp == STATUE && obj->corpsenm > -1)
568.  		    wt = (int)obj->quan *
569.  			 ((int)mons[obj->corpsenm].cwt * 3 / 2);
570.  
571.  		for(contents=obj->cobj; contents; contents=contents->nobj)
572.  			cwt += weight(contents);
573.  		/*
574.  		 *  The weight of bags of holding is calculated as the weight
575.  		 *  of the bag plus the weight of the bag's contents modified
576.  		 *  as follows:
577.  		 *
578.  		 *	Bag status	Weight of contents
579.  		 *	----------	------------------
580.  		 *	cursed			2x
581.  		 *	blessed			x/4 + 1
582.  		 *	otherwise		x/2 + 1
583.  		 *
584.  		 *  The macro DELTA_CWT in pickup.c also implements these
585.  		 *  weight equations.
586.  		 *
587.  		 *  Note:  The above checks are performed in the given order.
588.  		 *	   this means that if an object is both blessed and
589.  		 *	   cursed (not supposed to happen), it will be treated
590.  		 *	   as cursed.
591.  		 */
592.  		if (obj->otyp == BAG_OF_HOLDING)
593.  		    cwt = obj->cursed ? (cwt * 2) :
594.  					(1 + (cwt / (obj->blessed ? 4 : 2)));
595.  
596.  		return wt + cwt;
597.  	}
598.  	if (obj->otyp == CORPSE && obj->corpsenm > -1)
599.  		return (int)obj->quan * mons[obj->corpsenm].cwt;
600.  	else if (obj->otyp == GOLD_PIECE)
601.  		return (int)((obj->quan + 500L) / 1000L);
602.  	return(wt ? wt*(int)obj->quan : ((int)obj->quan + 1)>>1);
603.  }
604.  
605.  #endif /* OVL0 */
606.  #ifdef OVLB
607.  
608.  void
609.  mkgold(amount, x, y)
610.  long amount;
611.  int x, y;
612.  {
613.      register struct obj *gold = g_at(x,y);
614.  
615.      if (amount <= 0L) amount = (long)(1 + rnd(level_difficulty()+2) * rnd(30));
616.      if (gold) {
617.  	gold->quan += amount;
618.      } else {
619.  	gold = mksobj_at(GOLD_PIECE,x,y,TRUE);
620.  	gold->quan = amount;
621.      }
622.      gold->owt = weight(gold);
623.  }
624.  
625.  #endif /* OVLB */
626.  #ifdef OVL1
627.  struct obj *
628.  mkcorpstat(objtype, ptr, x, y, init)
629.  int objtype;	/* CORPSE or STATUE */
630.  register struct permonst *ptr;
631.  int x, y;
632.  boolean init;
633.  {
634.  	register struct obj *otmp;
635.  
636.  	if(objtype != CORPSE && objtype != STATUE)
637.  		impossible("making corpstat type %d", objtype);
638.  	otmp = mksobj_at(objtype, x, y, init);
639.  	if(otmp)  {
640.  		if(ptr)	otmp->corpsenm = monsndx(ptr);
641.  		else	otmp->corpsenm = rndmonnum();
642.  		otmp->owt = weight(otmp);
643.  	}
644.  	return(otmp);
645.  }
646.  
647.  #endif /* OVL1 */
648.  #ifdef OVLB
649.  struct obj *
650.  mk_tt_object(objtype, x, y)
651.  int objtype; /* CORPSE or STATUE */
652.  register int x, y;
653.  {
654.  	register struct obj *otmp;
655.  
656.  	/* player statues never contain books */
657.  	if ((otmp = mksobj_at(objtype,x,y,FALSE)) != 0)
658.  		otmp = tt_oname(otmp);
659.  	return(otmp);
660.  }
661.  
662.  /* make a new corpse or statue, uninitialized if a statue (i.e. no books) */
663.  struct obj *
664.  mk_named_object(objtype, ptr, x, y, nm, lth)
665.  int objtype; /* CORPSE or STATUE */
666.  register struct permonst *ptr;
667.  int x, y;
668.  char * nm;
669.  register int lth;
670.  {
671.  	struct obj *otmp;
672.  
673.  	otmp = mkcorpstat(objtype,ptr,x,y,(objtype != STATUE));
674.  	if (lth > 0) {
675.  		/* Note: oname() is safe since otmp is first in both chains */
676.  		otmp = oname(otmp, nm, FALSE);
677.  		fobj = otmp;
678.  		level.objects[x][y] = otmp;
679.  		if (is_pool(x,y)) water_damage(otmp,TRUE);
680.  	}
681.  	return(otmp);
682.  }
683.  
684.  boolean
685.  is_flammable(otmp)
686.  register struct obj *otmp;
687.  {
688.  	int otyp = otmp->otyp;
689.  
690.  	if (objects[otyp].oc_oprop == FIRE_RES) return FALSE;
691.  
692.  	return((objects[otyp].oc_material == WOOD ||
693.  			objects[otyp].oc_material == 0));
694.  
695.  }
696.  
697.  #endif /* OVLB */
698.  #ifdef OVL1
699.  
700.  /*
701.   * These routines maintain the single-linked lists headed in level.objects[][]
702.   * and threaded through the nexthere fields in the object-instance structure.
703.   */
704.  
705.  void
706.  place_object(otmp, x, y)
707.  /* put an object on top of the pile at the given location */
708.  register struct obj *otmp;
709.  int x, y;
710.  {
711.      register struct obj *otmp2 = level.objects[x][y];
712.  
713.      if (otmp->otyp == BOULDER) block_point(x,y);	/* vision */
714.  
715.      if (otmp2 && (otmp2->otyp == BOULDER)) {
716.  	otmp->nexthere = otmp2->nexthere;
717.  	otmp2->nexthere = otmp;
718.      } else {
719.  	otmp->nexthere = otmp2;
720.  	level.objects[x][y] = otmp;
721.      }
722.      if (is_pool(x,y)) water_damage(otmp,TRUE);
723.  
724.      /* set the new object's location */
725.      otmp->ox = x;
726.      otmp->oy = y;
727.  }
728.  
729.  #endif /* OVL1 */
730.  #ifdef OVLB
731.  void
732.  remove_object(otmp)
733.  register struct obj *otmp;
734.  {
735.      register struct obj *odel;
736.  
737.      if (otmp->otyp == BOULDER) unblock_point(otmp->ox,otmp->oy); /* vision */
738.  
739.      if (otmp == level.objects[otmp->ox][otmp->oy])
740.  	level.objects[otmp->ox][otmp->oy] = otmp->nexthere;
741.      else
742.  	for (odel = level.objects[otmp->ox][otmp->oy];
743.  						    odel; odel = odel->nexthere)
744.  	    if (odel->nexthere == otmp) {
745.  		odel->nexthere = otmp->nexthere;
746.  		break;
747.  	    }
748.  }
749.  
750.  void
751.  move_object(otmp, x, y)
752.  register struct obj *otmp;
753.  int x, y;
754.  {
755.      remove_object(otmp);
756.      place_object(otmp, x, y);
757.  }
758.  
759.  #endif /* OVLB */
760.  
761.  /*mkobj.c*/

Around Wikia's network

Random Wiki