Wikia

Wikihack

Source:Rm.h

2,032pages on
this wiki
Talk0

Below is the full text to include/rm.h from NetHack 3.4.3. To link to a particular line, write [[rm.h#line123]], for example.

1.    /*	SCCS Id: @(#)rm.h	3.4	1999/12/12	*/
2.    /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
3.    /* NetHack may be freely redistributed.  See license for details. */
4.    
The NetHack General Public License applies to screenshots, source code and other content from NetHack.
5.    #ifndef RM_H
6.    #define RM_H
7.    
8.    /*
9.     * The dungeon presentation graphics code and data structures were rewritten
10.    * and generalized for NetHack's release 2 by Eric S. Raymond (eric@snark)
11.    * building on Don G. Kneller's MS-DOS implementation.	See drawing.c for
12.    * the code that permits the user to set the contents of the symbol structure.
13.    *
14.    * The door representation was changed by Ari Huttunen(ahuttune@niksula.hut.fi)
15.    */
16.   
17.   /*
18.    * TLCORNER	TDWALL		TRCORNER
19.    * +-		-+-		-+
20.    * |		 |		 |
21.    *
22.    * TRWALL	CROSSWALL	TLWALL		HWALL
23.    * |		 |		 |
24.    * +-		-+-		-+		---
25.    * |		 |		 |
26.    *
27.    * BLCORNER	TUWALL		BRCORNER	VWALL
28.    * |		 |		 |		|
29.    * +-		-+-		-+		|
30.    */
31.   
32.   /* Level location types */
33.   #define STONE		0
34.   #define VWALL		1
35.   #define HWALL		2
36.   #define TLCORNER	3
37.   #define TRCORNER	4
38.   #define BLCORNER	5
39.   #define BRCORNER	6
40.   #define CROSSWALL	7	/* For pretty mazes and special levels */
41.   #define TUWALL		8
42.   #define TDWALL		9
43.   #define TLWALL		10
44.   #define TRWALL		11
45.   #define DBWALL		12
46.   #define TREE		13	/* KMH */
47.   #define SDOOR		14
48.   #define SCORR		15
49.   #define POOL		16
50.   #define MOAT		17	/* pool that doesn't boil, adjust messages */
51.   #define WATER		18
52.   #define DRAWBRIDGE_UP	19
53.   #define LAVAPOOL	20
54.   #define IRONBARS	21	/* KMH */
55.   #define DOOR		22
56.   #define CORR		23
57.   #define ROOM		24
58.   #define STAIRS		25
59.   #define LADDER		26
60.   #define FOUNTAIN	27
61.   #define THRONE		28
62.   #define SINK		29
63.   #define GRAVE		30
64.   #define ALTAR		31
65.   #define ICE		32
66.   #define DRAWBRIDGE_DOWN 33
67.   #define AIR		34
68.   #define CLOUD		35
69.   
70.   #define MAX_TYPE	36
71.   #define INVALID_TYPE	127
72.   
73.   /*
74.    * Avoid using the level types in inequalities:
75.    * these types are subject to change.
76.    * Instead, use one of the macros below.
77.    */
78.   #define IS_WALL(typ)	((typ) && (typ) <= DBWALL)
79.   #define IS_STWALL(typ)	((typ) <= DBWALL)	/* STONE <= (typ) <= DBWALL */
80.   #define IS_ROCK(typ)	((typ) < POOL)		/* absolutely nonaccessible */
81.   #define IS_DOOR(typ)	((typ) == DOOR)
82.   #define IS_TREE(typ)	((typ) == TREE || \
83.   			(level.flags.arboreal && (typ) == STONE))
84.   #define ACCESSIBLE(typ) ((typ) >= DOOR)		/* good position */
85.   #define IS_ROOM(typ)	((typ) >= ROOM)		/* ROOM, STAIRS, furniture.. */
86.   #define ZAP_POS(typ)	((typ) >= POOL)
87.   #define SPACE_POS(typ)	((typ) > DOOR)
88.   #define IS_POOL(typ)	((typ) >= POOL && (typ) <= DRAWBRIDGE_UP)
89.   #define IS_THRONE(typ)	((typ) == THRONE)
90.   #define IS_FOUNTAIN(typ) ((typ) == FOUNTAIN)
91.   #define IS_SINK(typ)	((typ) == SINK)
92.   #define IS_GRAVE(typ)	((typ) == GRAVE)
93.   #define IS_ALTAR(typ)	((typ) == ALTAR)
94.   #define IS_DRAWBRIDGE(typ) ((typ) == DRAWBRIDGE_UP || (typ) == DRAWBRIDGE_DOWN)
95.   #define IS_FURNITURE(typ) ((typ) >= STAIRS && (typ) <= ALTAR)
96.   #define IS_AIR(typ)	((typ) == AIR || (typ) == CLOUD)
97.   #define IS_SOFT(typ)	((typ) == AIR || (typ) == CLOUD || IS_POOL(typ))
98.   
99.   /*
100.   * The screen symbols may be the default or defined at game startup time.
101.   * See drawing.c for defaults.
102.   * Note: {ibm|dec}_graphics[] arrays (also in drawing.c) must be kept in synch.
103.   */
104.  
105.  /* begin dungeon characters */
106.  
107.  #define S_stone		0
108.  #define S_vwall		1
109.  #define S_hwall		2
110.  #define S_tlcorn	3
111.  #define S_trcorn	4
112.  #define S_blcorn	5
113.  #define S_brcorn	6
114.  #define S_crwall	7
115.  #define S_tuwall	8
116.  #define S_tdwall	9
117.  #define S_tlwall	10
118.  #define S_trwall	11
119.  #define S_ndoor		12
120.  #define S_vodoor	13
121.  #define S_hodoor	14
122.  #define S_vcdoor	15	/* closed door, vertical wall */
123.  #define S_hcdoor	16	/* closed door, horizontal wall */
124.  #define S_bars		17	/* KMH -- iron bars */
125.  #define S_tree		18	/* KMH */
126.  #define S_room		19
127.  #define S_corr		20
128.  #define S_litcorr	21
129.  #define S_upstair	22
130.  #define S_dnstair	23
131.  #define S_upladder	24
132.  #define S_dnladder	25
133.  #define S_altar		26
134.  #define S_grave		27
135.  #define S_throne	28
136.  #define S_sink		29
137.  #define S_fountain	30
138.  #define S_pool		31
139.  #define S_ice		32
140.  #define S_lava		33
141.  #define S_vodbridge	34
142.  #define S_hodbridge	35
143.  #define S_vcdbridge	36	/* closed drawbridge, vertical wall */
144.  #define S_hcdbridge	37	/* closed drawbridge, horizontal wall */
145.  #define S_air		38
146.  #define S_cloud		39
147.  #define S_water		40
148.  
149.  /* end dungeon characters, begin traps */
150.  
151.  #define S_arrow_trap		41
152.  #define S_dart_trap		42
153.  #define S_falling_rock_trap	43
154.  #define S_squeaky_board		44
155.  #define S_bear_trap		45
156.  #define S_land_mine		46
157.  #define S_rolling_boulder_trap	47
158.  #define S_sleeping_gas_trap	48
159.  #define S_rust_trap		49
160.  #define S_fire_trap		50
161.  #define S_pit			51
162.  #define S_spiked_pit		52
163.  #define S_hole			53
164.  #define S_trap_door		54
165.  #define S_teleportation_trap	55
166.  #define S_level_teleporter	56
167.  #define S_magic_portal		57
168.  #define S_web			58
169.  #define S_statue_trap		59
170.  #define S_magic_trap		60
171.  #define S_anti_magic_trap	61
172.  #define S_polymorph_trap	62
173.  
174.  /* end traps, begin special effects */
175.  
176.  #define S_vbeam		63	/* The 4 zap beam symbols.  Do NOT separate. */
177.  #define S_hbeam		64	/* To change order or add, see function     */
178.  #define S_lslant	65	/* zapdir_to_glyph() in display.c.	    */
179.  #define S_rslant	66
180.  #define S_digbeam	67	/* dig beam symbol */
181.  #define S_flashbeam	68	/* camera flash symbol */
182.  #define S_boomleft	69	/* thrown boomerang, open left, e.g ')'    */
183.  #define S_boomright	70	/* thrown boomerand, open right, e.g. '('  */
184.  #define S_ss1		71	/* 4 magic shield glyphs */
185.  #define S_ss2		72
186.  #define S_ss3		73
187.  #define S_ss4		74
188.  
189.  /* The 8 swallow symbols.  Do NOT separate.  To change order or add, see */
190.  /* the function swallow_to_glyph() in display.c.			 */
191.  #define S_sw_tl		75	/* swallow top left [1]			*/
192.  #define S_sw_tc		76	/* swallow top center [2]	Order:	*/
193.  #define S_sw_tr		77	/* swallow top right [3]		*/
194.  #define S_sw_ml		78	/* swallow middle left [4]	1 2 3	*/
195.  #define S_sw_mr		79	/* swallow middle right [6]	4 5 6	*/
196.  #define S_sw_bl		80	/* swallow bottom left [7]	7 8 9	*/
197.  #define S_sw_bc		81	/* swallow bottom center [8]		*/
198.  #define S_sw_br		82	/* swallow bottom right [9]		*/
199.  
200.  #define S_explode1	83	/* explosion top left			*/
201.  #define S_explode2	84	/* explosion top center			*/
202.  #define S_explode3	85	/* explosion top right		 Ex.	*/
203.  #define S_explode4	86	/* explosion middle left		*/
204.  #define S_explode5	87	/* explosion middle center	 /-\	*/
205.  #define S_explode6	88	/* explosion middle right	 |@|	*/
206.  #define S_explode7	89	/* explosion bottom left	 \-/	*/
207.  #define S_explode8	90	/* explosion bottom center		*/
208.  #define S_explode9	91	/* explosion bottom right		*/
209.  
210.  /* end effects */
211.  
212.  #define MAXPCHARS	92	/* maximum number of mapped characters */
213.  #define MAXDCHARS	41	/* maximum of mapped dungeon characters */
214.  #define MAXTCHARS	22	/* maximum of mapped trap characters */
215.  #define MAXECHARS	29	/* maximum of mapped effects characters */
216.  #define MAXEXPCHARS	9	/* number of explosion characters */
217.  
218.  struct symdef {
219.      uchar sym;
220.      const char	*explanation;
221.  #ifdef TEXTCOLOR
222.      uchar color;
223.  #endif
224.  };
225.  
226.  extern const struct symdef defsyms[MAXPCHARS];	/* defaults */
227.  extern uchar showsyms[MAXPCHARS];
228.  extern const struct symdef def_warnsyms[WARNCOUNT];
229.  
230.  /*
231.   * Graphics sets for display symbols
232.   */
233.  #define ASCII_GRAPHICS	0	/* regular characters: '-', '+', &c */
234.  #define IBM_GRAPHICS	1	/* PC graphic characters */
235.  #define DEC_GRAPHICS	2	/* VT100 line drawing characters */
236.  #define MAC_GRAPHICS	3	/* Macintosh drawing characters */
237.  
238.  /*
239.   * The 5 possible states of doors
240.   */
241.  
242.  #define D_NODOOR	0
243.  #define D_BROKEN	1
244.  #define D_ISOPEN	2
245.  #define D_CLOSED	4
246.  #define D_LOCKED	8
247.  #define D_TRAPPED	16
248.  
249.  /*
250.   * Some altars are considered as shrines, so we need a flag.
251.   */
252.  #define AM_SHRINE	8
253.  
254.  /*
255.   * Thrones should only be looted once.
256.   */
257.  #define T_LOOTED	1
258.  
259.  /*
260.   * Trees have more than one kick result.
261.   */
262.  #define TREE_LOOTED	1
263.  #define TREE_SWARM	2
264.  
265.  /*
266.   * Fountains have limits, and special warnings.
267.   */
268.  #define F_LOOTED	1
269.  #define F_WARNED	2
270.  #define FOUNTAIN_IS_WARNED(x,y)		(levl[x][y].looted & F_WARNED)
271.  #define FOUNTAIN_IS_LOOTED(x,y)		(levl[x][y].looted & F_LOOTED)
272.  #define SET_FOUNTAIN_WARNED(x,y)	levl[x][y].looted |= F_WARNED;
273.  #define SET_FOUNTAIN_LOOTED(x,y)	levl[x][y].looted |= F_LOOTED;
274.  #define CLEAR_FOUNTAIN_WARNED(x,y)	levl[x][y].looted &= ~F_WARNED;
275.  #define CLEAR_FOUNTAIN_LOOTED(x,y)	levl[x][y].looted &= ~F_LOOTED;
276.  
277.  /*
278.   * Doors are even worse :-) The special warning has a side effect
279.   * of instantly trapping the door, and if it was defined as trapped,
280.   * the guards consider that you have already been warned!
281.   */
282.  #define D_WARNED	16
283.  
284.  /*
285.   * Sinks have 3 different types of loot that shouldn't be abused
286.   */
287.  #define S_LPUDDING	1
288.  #define S_LDWASHER	2
289.  #define S_LRING		4
290.  
291.  /*
292.   * The four directions for a DrawBridge.
293.   */
294.  #define DB_NORTH	0
295.  #define DB_SOUTH	1
296.  #define DB_EAST		2
297.  #define DB_WEST		3
298.  #define DB_DIR		3	/* mask for direction */
299.  
300.  /*
301.   * What's under a drawbridge.
302.   */
303.  #define DB_MOAT		0
304.  #define DB_LAVA		4
305.  #define DB_ICE		8
306.  #define DB_FLOOR	16
307.  #define DB_UNDER	28	/* mask for underneath */
308.  
309.  /*
310.   * Wall information.
311.   */
312.  #define WM_MASK		0x07	/* wall mode (bottom three bits) */
313.  #define W_NONDIGGABLE	0x08
314.  #define W_NONPASSWALL	0x10
315.  
316.  /*
317.   * Ladders (in Vlad's tower) may be up or down.
318.   */
319.  #define LA_UP		1
320.  #define LA_DOWN		2
321.  
322.  /*
323.   * Room areas may be iced pools
324.   */
325.  #define ICED_POOL	8
326.  #define ICED_MOAT	16
327.  
328.  /*
329.   * The structure describing a coordinate position.
330.   * Before adding fields, remember that this will significantly affect
331.   * the size of temporary files and save files.
332.   */
333.  struct rm {
334.  	int glyph;		/* what the hero thinks is there */
335.  	schar typ;		/* what is really there */
336.  	uchar seenv;		/* seen vector */
337.  	Bitfield(flags,5);	/* extra information for typ */
338.  	Bitfield(horizontal,1); /* wall/door/etc is horiz. (more typ info) */
339.  	Bitfield(lit,1);	/* speed hack for lit rooms */
340.  	Bitfield(waslit,1);	/* remember if a location was lit */
341.  	Bitfield(roomno,6);	/* room # for special rooms */
342.  	Bitfield(edge,1);	/* marks boundaries for special rooms*/
343.  };
344.  
345.  /*
346.   * Add wall angle viewing by defining "modes" for each wall type.  Each
347.   * mode describes which parts of a wall are finished (seen as as wall)
348.   * and which are unfinished (seen as rock).
349.   *
350.   * We use the bottom 3 bits of the flags field for the mode.  This comes
351.   * in conflict with secret doors, but we avoid problems because until
352.   * a secret door becomes discovered, we know what sdoor's bottom three
353.   * bits are.
354.   *
355.   * The following should cover all of the cases.
356.   *
357.   *	type	mode				Examples: R=rock, F=finished
358.   *	-----	----				----------------------------
359.   *	WALL:	0 none				hwall, mode 1
360.   *		1 left/top (1/2 rock)			RRR
361.   *		2 right/bottom (1/2 rock)		---
362.   *							FFF
363.   *
364.   *	CORNER: 0 none				trcorn, mode 2
365.   *		1 outer (3/4 rock)			FFF
366.   *		2 inner (1/4 rock)			F+-
367.   *							F|R
368.   *
369.   *	TWALL:	0 none				tlwall, mode 3
370.   *		1 long edge (1/2 rock)			F|F
371.   *		2 bottom left (on a tdwall)		-+F
372.   *		3 bottom right (on a tdwall)		R|F
373.   *
374.   *	CRWALL: 0 none				crwall, mode 5
375.   *		1 top left (1/4 rock)			R|F
376.   *		2 top right (1/4 rock)			-+-
377.   *		3 bottom left (1/4 rock)		F|R
378.   *		4 bottom right (1/4 rock)
379.   *		5 top left & bottom right (1/2 rock)
380.   *		6 bottom left & top right (1/2 rock)
381.   */
382.  
383.  #define WM_W_LEFT 1			/* vertical or horizontal wall */
384.  #define WM_W_RIGHT 2
385.  #define WM_W_TOP WM_W_LEFT
386.  #define WM_W_BOTTOM WM_W_RIGHT
387.  
388.  #define WM_C_OUTER 1			/* corner wall */
389.  #define WM_C_INNER 2
390.  
391.  #define WM_T_LONG 1			/* T wall */
392.  #define WM_T_BL   2
393.  #define WM_T_BR   3
394.  
395.  #define WM_X_TL   1			/* cross wall */
396.  #define WM_X_TR   2
397.  #define WM_X_BL   3
398.  #define WM_X_BR   4
399.  #define WM_X_TLBR 5
400.  #define WM_X_BLTR 6
401.  
402.  /*
403.   * Seen vector values.	The seen vector is an array of 8 bits, one for each
404.   * octant around a given center x:
405.   *
406.   *			0 1 2
407.   *			7 x 3
408.   *			6 5 4
409.   *
410.   * In the case of walls, a single wall square can be viewed from 8 possible
411.   * directions.	If we know the type of wall and the directions from which
412.   * it has been seen, then we can determine what it looks like to the hero.
413.   */
414.  #define SV0 0x1
415.  #define SV1 0x2
416.  #define SV2 0x4
417.  #define SV3 0x8
418.  #define SV4 0x10
419.  #define SV5 0x20
420.  #define SV6 0x40
421.  #define SV7 0x80
422.  #define SVALL 0xFF
423.  
424.  
425.  
426.  #define doormask	flags
427.  #define altarmask	flags
428.  #define wall_info	flags
429.  #define ladder		flags
430.  #define drawbridgemask	flags
431.  #define looted		flags
432.  #define icedpool	flags
433.  
434.  #define blessedftn	horizontal  /* a fountain that grants attribs */
435.  #define disturbed	horizontal  /* a grave that has been disturbed */
436.  
437.  struct damage {
438.  	struct damage *next;
439.  	long when, cost;
440.  	coord place;
441.  	schar typ;
442.  };
443.  
444.  struct levelflags {
445.  	uchar	nfountains;		/* number of fountains on level */
446.  	uchar	nsinks;			/* number of sinks on the level */
447.  	/* Several flags that give hints about what's on the level */
448.  	Bitfield(has_shop, 1);
449.  	Bitfield(has_vault, 1);
450.  	Bitfield(has_zoo, 1);
451.  	Bitfield(has_court, 1);
452.  	Bitfield(has_morgue, 1);
453.  	Bitfield(has_beehive, 1);
454.  	Bitfield(has_barracks, 1);
455.  	Bitfield(has_temple, 1);
456.  
457.  	Bitfield(has_swamp, 1);
458.  	Bitfield(noteleport,1);
459.  	Bitfield(hardfloor,1);
460.  	Bitfield(nommap,1);
461.  	Bitfield(hero_memory,1);	/* hero has memory */
462.  	Bitfield(shortsighted,1);	/* monsters are shortsighted */
463.  	Bitfield(graveyard,1);		/* has_morgue, but remains set */
464.  	Bitfield(is_maze_lev,1);
465.  
466.  	Bitfield(is_cavernous_lev,1);
467.  	Bitfield(arboreal, 1);		/* Trees replace rock */
468.  };
469.  
470.  typedef struct
471.  {
472.      struct rm		locations[COLNO][ROWNO];
473.  #ifndef MICROPORT_BUG
474.      struct obj		*objects[COLNO][ROWNO];
475.      struct monst	*monsters[COLNO][ROWNO];
476.  #else
477.      struct obj		*objects[1][ROWNO];
478.      char		*yuk1[COLNO-1][ROWNO];
479.      struct monst	*monsters[1][ROWNO];
480.      char		*yuk2[COLNO-1][ROWNO];
481.  #endif
482.      struct obj		*objlist;
483.      struct obj		*buriedobjlist;
484.      struct monst	*monlist;
485.      struct damage	*damagelist;
486.      struct levelflags	flags;
487.  }
488.  dlevel_t;
489.  
490.  extern dlevel_t level;	/* structure describing the current level */
491.  
492.  /*
493.   * Macros for compatibility with old code. Someday these will go away.
494.   */
495.  #define levl		level.locations
496.  #define fobj		level.objlist
497.  #define fmon		level.monlist
498.  
499.  /*
500.   * Covert a trap number into the defsym graphics array.
501.   * Convert a defsym number into a trap number.
502.   * Assumes that arrow trap will always be the first trap.
503.   */
504.  #define trap_to_defsym(t) (S_arrow_trap+(t)-1)
505.  #define defsym_to_trap(d) ((d)-S_arrow_trap+1)
506.  
507.  #define OBJ_AT(x,y)	(level.objects[x][y] != (struct obj *)0)
508.  /*
509.   * Macros for encapsulation of level.monsters references.
510.   */
511.  #define MON_AT(x,y)	(level.monsters[x][y] != (struct monst *)0 && \
512.  			 !(level.monsters[x][y])->mburied)
513.  #define MON_BURIED_AT(x,y)	(level.monsters[x][y] != (struct monst *)0 && \
514.  				(level.monsters[x][y])->mburied)
515.  #ifndef STEED
516.  #define place_monster(m,x,y)	((m)->mx=(x),(m)->my=(y),\
517.  				 level.monsters[(m)->mx][(m)->my]=(m))
518.  #endif
519.  #define place_worm_seg(m,x,y)	level.monsters[x][y] = m
520.  #define remove_monster(x,y)	level.monsters[x][y] = (struct monst *)0
521.  #define m_at(x,y)		(MON_AT(x,y) ? level.monsters[x][y] : \
522.  						(struct monst *)0)
523.  #define m_buried_at(x,y)	(MON_BURIED_AT(x,y) ? level.monsters[x][y] : \
524.  						       (struct monst *)0)
525.  
526.  #endif /* RM_H */

Around Wikia's network

Random Wiki