Source:NetHack 3.4.3/src/shknam.c

From NetHackWiki
Jump to navigation Jump to search

Below is the full text to src/shknam.c from NetHack 3.4.3. To link to a particular line, write Source:NetHack 3.4.3/src/shknam.c#line123, for example.

Top of file

1.    /*	SCCS Id: @(#)shknam.c	3.4	2003/01/09	*/
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.

This content was modified from the original NetHack source code distribution (by splitting up NetHack content between wiki pages, and possibly further editing). See the page history for a list of who changed it, and on what dates. 

5.    /* shknam.c -- initialize a shop */
6.    
7.    #include "hack.h"
8.    #include "eshk.h"
9.    
10.   #ifndef OVLB
11.   extern const struct shclass shtypes[];
12.   
13.   #else
14.   
15.   STATIC_DCL void FDECL(mkshobj_at, (const struct shclass *,int,int));
16.   STATIC_DCL void FDECL(nameshk, (struct monst *,const char * const *));
17.   STATIC_DCL int  FDECL(shkinit, (const struct shclass *,struct mkroom *));
18.

Shopkeeper names

Most shopkeeper names are names of cities, towns and villages of various sizes, some of them quite obscure and remote. The exceptions are the tool shop and ring shop names.

The shopkeeper name lists are among the most archaic parts of NetHack; many lists are unchanged since Hack 1.0.

Potion store

19.   static const char * const shkliquors[] = {
20.       /* Ukraine */
21.       "Njezjin", "Tsjernigof", "Ossipewsk", "Gorlowka",
22.       /* Belarus */
23.       "Gomel",
24.       /* N. Russia */
25.       "Konosja", "Weliki Oestjoeg", "Syktywkar", "Sablja",
26.       "Narodnaja", "Kyzyl",
27.       /* Silezie */
28.       "Walbrzych", "Swidnica", "Klodzko", "Raciborz", "Gliwice",
29.       "Brzeg", "Krnov", "Hradec Kralove",
30.       /* Schweiz */
31.       "Leuk", "Brig", "Brienz", "Thun", "Sarnen", "Burglen", "Elm",
32.       "Flims", "Vals", "Schuls", "Zum Loch",
33.       0
34.   };
35.

The Ukrainian names, as well as Gomel, are in their Russian forms; the places themselves are now named in the local languages.

Tsjernigof and Weliki Oestjoeg are given Dutch rather than English transliteration. The English names are Chernigov and Veliky Ustyug.

Gomel was placed in the Ukraine section through NetHack 3.4.1. It's close to the border, and the error is understandable, given that Hack 1.0 predates the breakup of the Soviet Union by several years. This list is otherwise unchanged since Hack 1.0.

Spellbook store

36.   static const char * const shkbooks[] = {
37.       /* Eire */
38.       "Skibbereen", "Kanturk", "Rath Luirc", "Ennistymon", "Lahinch",
39.       "Kinnegad", "Lugnaquillia", "Enniscorthy", "Gweebarra",
40.       "Kittamagh", "Nenagh", "Sneem", "Ballingeary", "Kilgarvan",
41.       "Cahersiveen", "Glenbeigh", "Kilmihil", "Kiltamagh",
42.       "Droichead Atha", "Inniscrone", "Clonegal", "Lisnaskea",
43.       "Culdaff", "Dunfanaghy", "Inishbofin", "Kesh",
44.       0
45.   };
46.

Skibbereen is the setting of an old song about the Potato Famine. Here is one version of the lyrics.

"Kittamagh" and "Kiltamagh" may be misspellings of Kiltimagh.

Two small offshore islands are named Inishbofin, one in Galway and the other in Donegal; the link goes to the disambiguation page.

The town of Kesh is actually in Northern Ireland. There is also a river called Kesh, but it is unclear at this time whether any part of it is in the Republic of Ireland.

Several names disappeared from this list in NetHack 2.2a: Loughrea, Croagh, Maumakeogh and Ballyjamesduff.

Armor store

47.   static const char * const shkarmors[] = {
48.       /* Turquie */
49.       "Demirci", "Kalecik", "Boyabai", "Yildizeli", "Gaziantep",
50.       "Siirt", "Akhalataki", "Tirebolu", "Aksaray", "Ermenak",
51.       "Iskenderun", "Kadirli", "Siverek", "Pervari", "Malasgirt",
52.       "Bayburt", "Ayancik", "Zonguldak", "Balya", "Tefenni",
53.       "Artvin", "Kars", "Makharadze", "Malazgirt", "Midyat",
54.       "Birecik", "Kirikkale", "Alaca", "Polatli", "Nallihan",
55.       0
56.   };
57.

Makharadze and Akhalataki are actually in the Republic of Georgia.

Malasgirt may refer to the same place as Malazgirt.

This list is unchanged since Hack 1.0.

Wand store

58.   static const char * const shkwands[] = {
59.       /* Wales */
60.       "Yr Wyddgrug", "Trallwng", "Mallwyd", "Pontarfynach",
61.       "Rhaeader", "Llandrindod", "Llanfair-ym-muallt",
62.       "Y-Fenni", "Maesteg", "Rhydaman", "Beddgelert",
63.       "Curig", "Llanrwst", "Llanerchymedd", "Caergybi",
64.       /* Scotland */
65.       "Nairn", "Turriff", "Inverurie", "Braemar", "Lochnagar",
66.       "Kerloch", "Beinn a Ghlo", "Drumnadrochit", "Morven",
67.       "Uist", "Storr", "Sgurr na Ciche", "Cannich", "Gairloch",
68.       "Kyleakin", "Dunvegan",
69.       0
70.   };
71.

Llanfair-ym-muallt is known in English as Builth Wells and is not to be confused with "Llanfair PG", said to have the longest town name in the UK.

Morven is the name of two mountains, one in Aberdeenshire and the other in Caithness. The link goes to the disambiguation page.

This list is unchanged since Hack 1.0.

Ring store

72.   static const char * const shkrings[] = {
73.       /* Hollandse familienamen */
74.       "Feyfer", "Flugi", "Gheel", "Havic", "Haynin", "Hoboken",
75.       "Imbyze", "Juyn", "Kinsky", "Massis", "Matray", "Moy",
76.       "Olycan", "Sadelin", "Svaving", "Tapper", "Terwen", "Wirix",
77.       "Ypey",
78.       /* Skandinaviske navne */
79.       "Rastegaisa", "Varjag Njarga", "Kautekeino", "Abisko",
80.       "Enontekis", "Rovaniemi", "Avasaksa", "Haparanda",
81.       "Lulea", "Gellivare", "Oeloe", "Kajaani", "Fauske",
82.       0
83.   };
84.

The reason for "Hollandse familienamen" may be that Andries Brouwer is Dutch.

This list is unchanged since Hack 1.0.

Food store

85.   static const char * const shkfoods[] = {
86.       /* Indonesia */
87.       "Djasinga", "Tjibarusa", "Tjiwidej", "Pengalengan",
88.       "Bandjar", "Parbalingga", "Bojolali", "Sarangan",
89.       "Ngebel", "Djombang", "Ardjawinangun", "Berbek",
90.       "Papar", "Baliga", "Tjisolok", "Siboga", "Banjoewangi",
91.       "Trenggalek", "Karangkobar", "Njalindoeng", "Pasawahan",
92.       "Pameunpeuk", "Patjitan", "Kediri", "Pemboeang", "Tringanoe",
93.       "Makin", "Tipor", "Semai", "Berhala", "Tegal", "Samoe",
94.       0
95.   };
96.

Papar is actually in Malaysia, on the island of Borneo.

Makin is an island in Kiribati.

The Semai are an indigenous people of the Malay Peninsula.

This list is unchanged since Hack 1.0.

Weapon store

97.   static const char * const shkweapons[] = {
98.       /* Perigord */
99.       "Voulgezac", "Rouffiac", "Lerignac", "Touverac", "Guizengeard",
100.      "Melac", "Neuvicq", "Vanzac", "Picq", "Urignac", "Corignac",
101.      "Fleac", "Lonzac", "Vergt", "Queyssac", "Liorac", "Echourgnac",
102.      "Cazelon", "Eypau", "Carignan", "Monbazillac", "Jonzac",
103.      "Pons", "Jumilhac", "Fenouilledes", "Laguiolet", "Saujon",
104.      "Eymoutiers", "Eygurande", "Eauze", "Labouheyre",
105.      0
106.  };
107.

This list is unchanged since Hack 1.0.

Tool store

108.  static const char * const shktools[] = {
109.      /* Spmi */
110.      "Ymla", "Eed-morra", "Cubask", "Nieb", "Bnowr Falr", "Telloc Cyaj",
111.      "Sperc", "Noskcirdneh", "Yawolloh", "Hyeghu", "Niskal", "Trahnil",
112.      "Htargcm", "Enrobwem", "Kachzi Rellim", "Regien", "Donmyar",
113.      "Yelpur", "Nosnehpets", "Stewe", "Renrut", "_Zlaw", "Nosalnef",
114.      "Rewuorb", "Rellenk", "Yad", "Cire Htims", "Y-crad", "Nenilukah",
115.      "Corsh", "Aned",
116.  #ifdef OVERLAY
117.      "Erreip", "Nehpets", "Mron", "Snivek", "Lapu", "Kahztiy",
118.  #endif
119.  #ifdef WIN32
120.      "Lechaim", "Lexa", "Niod",
121.  #endif
122.  #ifdef MAC
123.      "Nhoj-lee", "Evad\'kh", "Ettaw-noj", "Tsew-mot", "Ydna-s",
124.      "Yao-hang", "Tonbar", "Kivenhoug",
125.  #endif
126.  #ifdef AMIGA
127.      "Falo", "Nosid-da\'r", "Ekim-p", "Rebrol-nek", "Noslo", "Yl-rednow",
128.      "Mured-oog", "Ivrajimsal",
129.  #endif
130.  #ifdef TOS
131.      "Nivram",
132.  #endif
133.  #ifdef VMS
134.      "Lez-tneg", "Ytnu-haled", "Niknar",
135.  #endif
136.      0
137.  };
138.

"Spmi" is "imps" spelled backward. The tool store keeper names are anagrams of names of various Hack and NetHack developers; usually the names are spelled backwards. This RGRN post gives a nearly complete list as of the then-current version of NetHack. These are matched with the names, and a few more recent additions provided, in the following table.

The "spmi" first appear in NetHack 3.0.0. Some additions to the list have been made since then.

The names in the OVERLAY section will not appear in any actual version of NetHack, as the 16-bit MS-DOS build is no longer supported (see MS-DOS).

Name Named after Version
Ymla Tom Almy 3.0.0
Eed-morra Ken Arromdee 3.0.0
Cubask Eric Backus 3.0.0
Nieb John S. Bien 3.0.0
Bnowr Falr Ralf Brown 3.0.0
Telloc Cyaj Jean-Christophe "JC" Collet 3.0.0
Sperc Steve Creps 3.0.0
Noskcirdneh Eric Hendrickson 3.0.0
Yawolloh Bruce Holloway 3.0.0
Hyeghu Richard P. Hughey 3.0.0
Niskal Greg Laskin 3.0.0
Trahnil Steve Linhart 3.0.0
Htargcm Roland McGrath 3.0.0
Enrobwem Bruce Mewborne 3.0.0
Kachzi Rellim Izchak Miller 3.0.0
Regien Gil Neiger 3.0.0
Donmyar Eric Raymond 3.0.0
Yelpur John Rupley 3.0.0
Nosnehpets Mike Stephenson 3.0.0
Stewe Kevin Sweet 3.0.0
Renrut Scott R Turner 3.0.0
Zlaw Janet Walz 3.0.0
Nosalnef Jay Fenlason 3.0.0
Rewuorb Andries Brouwer 3.0.0
Rellenk Don G Kneller 3.0.0
Yad Matt Day 3.0.8
Cire Htims Eric Smith 3.0.8
Y-crad Kevin Darcy 3.0.8
Nenilukah Timo Hakulinen 3.0.8
Corsh David Cohrs 3.1.3
Aned Dean Luick? 3.1.3
Erreip Pierre Martineau 3.0.8 - 3.3.1
Nehpets Stephen Spackman 3.0.8 - 3.3.1
Mron Norm Melluch 3.0.8 - 3.3.1
Snivek Kevin Smolkowski 3.0.8 - 3.3.1
Lapu Paul Winner 3.1.3 - 3.3.1
Kahztiy Yitzhak Sapir 3.2.0 - 3.3.1
Lechaim Michael Allison 3.1.3
Lexa Alex Kompel 3.4.0
Niod Dion Nicolaas 3.4.0
Nhoj-lee Johnny Lee 3.0.8
Evad'kh Dave KH? 3.0.8
Ettaw-noj Jon Wätte 3.0.8
Tsew-mot Tom West 3.0.8
Ydna-s Andy Swanson 3.0.8
Yao-hang Hao-yang Wang 3.1.3
Tonbar Barton House 3.1.3
Kivenhoug Kevin Hugo 3.3.0
Falo Olaf Seibert 3.0.8
Nosid-da'r Richard Addison 3.0.8
Ekim-p Mike Passaretti 3.0.8
Rebrol-nek Ken Lorber 3.0.8
Noslo Greg Olson 3.0.8
Yl-rednow Gregg Wonderly 3.0.8
Mured-oog Mark Gooderum 3.0.8
Ivrajimsal Janne Salmijarvi 3.3.1
Nivram Christian "Marvin" Bressler 3.3.1
Lez-tneg David Gentzel 3.0.8
Ytnu-haled Joshua Delahunty 3.0.8
Niknar Pat Rankin 3.0.8

Light store

139.  static const char * const shklight[] = {
140.      /* Romania */
141.      "Zarnesti", "Slanic", "Nehoiasu", "Ludus", "Sighisoara", "Nisipitu",
142.      "Razboieni", "Bicaz", "Dorohoi", "Vaslui", "Fetesti", "Tirgu Neamt",
143.      "Babadag", "Zimnicea", "Zlatna", "Jiu", "Eforie", "Mamaia",
144.      /* Bulgaria */
145.      "Silistra", "Tulovo", "Panagyuritshte", "Smolyan", "Kirklareli",
146.      "Pernik", "Lom", "Haskovo", "Dobrinishte", "Varvara", "Oryahovo",
147.      "Troyan", "Lovech", "Sliven",
148.      0
149.  };
150.

These names were introduced in NetHack 3.1.2, but have been in disuse since NetHack 3.2.0. An unmodified game has only one lighting store, and its keeper is Izchak.

SLASH'EM can generate a lighting store in the "mall" level of its main dungeon; its keeper will have a name from the above list.

Sighişoara is said to be the birthplace of Vlad Ţepeş -- Vlad the Impaler himself.

Kırklareli is actually in Turkey.

General store

151.  static const char * const shkgeneral[] = {
152.      /* Suriname */
153.      "Hebiwerie", "Possogroenoe", "Asidonhopo", "Manlobbi",
154.      "Adjama", "Pakka Pakka", "Kabalebo", "Wonotobo",
155.      "Akalapi", "Sipaliwini",
156.      /* Greenland */
157.      "Annootok", "Upernavik", "Angmagssalik",
158.      /* N. Canada */
159.      "Aklavik", "Inuvik", "Tuktoyaktuk",
160.      "Chicoutimi", "Ouiatchouane", "Chibougamau",
161.      "Matagami", "Kipawa", "Kinojevis",
162.      "Abitibi", "Maganasipi",
163.      /* Iceland */
164.      "Akureyri", "Kopasker", "Budereyri", "Akranes", "Bordeyri",
165.      "Holmavik",
166.      0
167.  };
168.

Most of the locations in Suriname seem to be in the Sipaliwini District, which is the southern part of Suriname. “Possogroenoe” is apparently a misspelling of “Poesoegroenoe”, where the “oe” vowels are the long [u] sound in Dutch. “Wonotobo” is the name of a famous waterfall in Suriname.

“Annootok” is a misspelling of Annoatok, an abandoned place in northeast Greenland. “Angmagssalik” is an older spelling of Ammassalik, a town in southeast Greenland which has since been renamed to Tasiilaq.

Ouiatchouane is a small river which empties into Lac Saint-Jean in Quebec.

“Kopasker” is actually Kópasker and Holmavik is actually Hólmavík, both small towns in Iceland.

This list is unchanged since Hack 1.0.

shtypes

169.  /*
170.   * To add new shop types, all that is necessary is to edit the shtypes[] array.
171.   * See mkroom.h for the structure definition.  Typically, you'll have to lower
172.   * some or all of the probability fields in old entries to free up some
173.   * percentage for the new type.
174.   *
175.   * The placement type field is not yet used but will be in the near future.
176.   *
177.   * The iprobs array in each entry defines the probabilities for various kinds
178.   * of objects to be present in the given shop type.  You can associate with
179.   * each percentage either a generic object type (represented by one of the
180.   * *_CLASS macros) or a specific object (represented by an onames.h define).
181.   * In the latter case, prepend it with a unary minus so the code can know
182.   * (by testing the sign) whether to use mkobj() or mksobj().
183.   */
184.  
185.  const struct shclass shtypes[] = {
186.  	{"general store", RANDOM_CLASS, 44,
187.  	    D_SHOP, {{100, RANDOM_CLASS}, {0, 0}, {0, 0}}, shkgeneral},
188.  	{"used armor dealership", ARMOR_CLASS, 14,
189.  	    D_SHOP, {{90, ARMOR_CLASS}, {10, WEAPON_CLASS}, {0, 0}},
190.  	     shkarmors},
191.  	{"second-hand bookstore", SCROLL_CLASS, 10, D_SHOP,
192.  	    {{90, SCROLL_CLASS}, {10, SPBOOK_CLASS}, {0, 0}}, shkbooks},
193.  	{"liquor emporium", POTION_CLASS, 10, D_SHOP,
194.  	    {{100, POTION_CLASS}, {0, 0}, {0, 0}}, shkliquors},
195.  	{"antique weapons outlet", WEAPON_CLASS, 5, D_SHOP,
196.  	    {{90, WEAPON_CLASS}, {10, ARMOR_CLASS}, {0, 0}}, shkweapons},
197.  	{"delicatessen", FOOD_CLASS, 5, D_SHOP,
198.  	    {{83, FOOD_CLASS}, {5, -POT_FRUIT_JUICE}, {4, -POT_BOOZE},
199.  	     {5, -POT_WATER}, {3, -ICE_BOX}}, shkfoods},
200.  	{"jewelers", RING_CLASS, 3, D_SHOP,
201.  	    {{85, RING_CLASS}, {10, GEM_CLASS}, {5, AMULET_CLASS}, {0, 0}},
202.  	    shkrings},
203.  	{"quality apparel and accessories", WAND_CLASS, 3, D_SHOP,
204.  	    {{90, WAND_CLASS}, {5, -LEATHER_GLOVES}, {5, -ELVEN_CLOAK}, {0, 0}},
205.  	     shkwands},
206.  	{"hardware store", TOOL_CLASS, 3, D_SHOP,
207.  	    {{100, TOOL_CLASS}, {0, 0}, {0, 0}}, shktools},
208.  	/* Actually shktools is ignored; the code specifically chooses a
209.  	 * random implementor name (along with candle shops having
210.  	 * random shopkeepers)
211.  	 */
212.  	{"rare books", SPBOOK_CLASS, 3, D_SHOP,
213.  	    {{90, SPBOOK_CLASS}, {10, SCROLL_CLASS}, {0, 0}}, shkbooks},
214.  	/* Shops below this point are "unique".  That is they must all have a
215.  	 * probability of zero.  They are only created via the special level
216.  	 * loader.
217.  	 */
218.  	{"lighting store", TOOL_CLASS, 0, D_SHOP,
219.  	    {{32, -WAX_CANDLE}, {50, -TALLOW_CANDLE},
220.  	     {5, -BRASS_LANTERN}, {10, -OIL_LAMP}, {3, -MAGIC_LAMP}}, shklight},
221.  	{(char *)0, 0, 0, 0, {{0, 0}, {0, 0}, {0, 0}}, 0}
222.  };
223.

init_shop_selection

224.  #if 0
225.  /* validate shop probabilities; otherwise incorrect local changes could
226.     end up provoking infinite loops or wild subscripts fetching garbage */
227.  void
228.  init_shop_selection()
229.  {
230.  	register int i, j, item_prob, shop_prob;
231.  
232.  	for (shop_prob = 0, i = 0; i < SIZE(shtypes); i++) {
233.  		shop_prob += shtypes[i].prob;
234.  		for (item_prob = 0, j = 0; j < SIZE(shtypes[0].iprobs); j++)
235.  			item_prob += shtypes[i].iprobs[j].iprob;
236.  		if (item_prob != 100)
237.  			panic("item probabilities total to %d for %s shops!",
238.  				item_prob, shtypes[i].name);
239.  	}
240.  	if (shop_prob != 100)
241.  		panic("shop probabilities total to %d!", shop_prob);
242.  }
243.  #endif /*0*/
244.

mkshobj_at

245.  STATIC_OVL void
246.  mkshobj_at(shp, sx, sy)
247.  /* make an object of the appropriate type for a shop square */
248.  const struct shclass *shp;
249.  int sx, sy;
250.  {
251.  	struct monst *mtmp;
252.  	int atype;
253.  	struct permonst *ptr;
254.  
255.  	if (rn2(100) < depth(&u.uz) &&
256.  		!MON_AT(sx, sy) && (ptr = mkclass(S_MIMIC,0)) &&
257.  		(mtmp = makemon(ptr,sx,sy,NO_MM_FLAGS)) != 0) {
258.  	    /* note: makemon will set the mimic symbol to a shop item */
259.  	    if (rn2(10) >= depth(&u.uz)) {
260.  		mtmp->m_ap_type = M_AP_OBJECT;
261.  		mtmp->mappearance = STRANGE_OBJECT;
262.  	    }
263.  	} else {
264.  	    atype = get_shop_item(shp - shtypes);
265.  	    if (atype < 0)
266.  		(void) mksobj_at(-atype, sx, sy, TRUE, TRUE);
267.  	    else
268.  		(void) mkobj_at(atype, sx, sy, TRUE);
269.  	}
270.  }
271.

nameshk

272.  /* extract a shopkeeper name for the given shop type */
273.  STATIC_OVL void
274.  nameshk(shk, nlp)
275.  struct monst *shk;
276.  const char * const *nlp;
277.  {
278.  	int i, trycnt, names_avail;
279.  	const char *shname = 0;
280.  	struct monst *mtmp;
281.  	int name_wanted;
282.  	s_level *sptr;
283.  
284.  	if (nlp == shklight && In_mines(&u.uz)
285.  		&& (sptr = Is_special(&u.uz)) != 0 && sptr->flags.town) {
286.  	    /* special-case minetown lighting shk */
287.  	    shname = "Izchak";
288.  	    shk->female = FALSE;
289.  	} else {
290.  	    /* We want variation from game to game, without needing the save
291.  	       and restore support which would be necessary for randomization;
292.  	       try not to make too many assumptions about time_t's internals;
293.  	       use ledger_no rather than depth to keep mine town distinct. */
294.  	    int nseed = (int)((long)u.ubirthday / 257L);
295.  
296.  	    name_wanted = ledger_no(&u.uz) + (nseed % 13) - (nseed % 5);
297.  	    if (name_wanted < 0) name_wanted += (13 + 5);
298.  	    shk->female = name_wanted & 1;
299.  
300.  	    for (names_avail = 0; nlp[names_avail]; names_avail++)
301.  		continue;
302.  
303.  	    for (trycnt = 0; trycnt < 50; trycnt++) {
304.  		if (nlp == shktools) {
305.  		    shname = shktools[rn2(names_avail)];
306.  		    shk->female = (*shname == '_');
307.  		    if (shk->female) shname++;
308.  		} else if (name_wanted < names_avail) {
309.  		    shname = nlp[name_wanted];
310.  		} else if ((i = rn2(names_avail)) != 0) {
311.  		    shname = nlp[i - 1];
312.  		} else if (nlp != shkgeneral) {
313.  		    nlp = shkgeneral;	/* try general names */
314.  		    for (names_avail = 0; nlp[names_avail]; names_avail++)
315.  			continue;
316.  		    continue;		/* next `trycnt' iteration */
317.  		} else {
318.  		    shname = shk->female ? "Lucrezia" : "Dirk";
319.  		}
320.  
321.  		/* is name already in use on this level? */
322.  		for (mtmp = fmon; mtmp; mtmp = mtmp->nmon) {
323.  		    if (DEADMONSTER(mtmp) || (mtmp == shk) || !mtmp->isshk) continue;
324.  		    if (strcmp(ESHK(mtmp)->shknam, shname)) continue;
325.  		    break;
326.  		}
327.  		if (!mtmp) break;	/* new name */
328.  	    }
329.  	}
330.  	(void) strncpy(ESHK(shk)->shknam, shname, PL_NSIZ);
331.  	ESHK(shk)->shknam[PL_NSIZ-1] = 0;
332.  }
333.

shkinit

334.  STATIC_OVL int
335.  shkinit(shp, sroom)	/* create a new shopkeeper in the given room */
336.  const struct shclass	*shp;
337.  struct mkroom	*sroom;
338.  {
339.  	register int sh, sx, sy;
340.  	struct monst *shk;
341.  
342.  	/* place the shopkeeper in the given room */
343.  	sh = sroom->fdoor;
344.  	sx = doors[sh].x;
345.  	sy = doors[sh].y;
346.  
347.  	/* check that the shopkeeper placement is sane */
348.  	if(sroom->irregular) {
349.  	    int rmno = (sroom - rooms) + ROOMOFFSET;
350.  	    if (isok(sx-1,sy) && !levl[sx-1][sy].edge &&
351.  		(int) levl[sx-1][sy].roomno == rmno) sx--;
352.  	    else if (isok(sx+1,sy) && !levl[sx+1][sy].edge &&
353.  		(int) levl[sx+1][sy].roomno == rmno) sx++;
354.  	    else if (isok(sx,sy-1) && !levl[sx][sy-1].edge &&
355.  		(int) levl[sx][sy-1].roomno == rmno) sy--;
356.  	    else if (isok(sx,sy+1) && !levl[sx][sy+1].edge &&
357.  		(int) levl[sx][sy+1].roomno == rmno) sx++;
358.  	    else goto shk_failed;
359.  	}
360.  	else if(sx == sroom->lx-1) sx++;
361.  	else if(sx == sroom->hx+1) sx--;
362.  	else if(sy == sroom->ly-1) sy++;
363.  	else if(sy == sroom->hy+1) sy--; else {
364.  	shk_failed:
365.  #ifdef DEBUG
366.  # ifdef WIZARD
367.  	    /* Said to happen sometimes, but I have never seen it. */
368.  	    /* Supposedly fixed by fdoor change in mklev.c */
369.  	    if(wizard) {
370.  		register int j = sroom->doorct;
371.  
372.  		pline("Where is shopdoor?");
373.  		pline("Room at (%d,%d),(%d,%d).",
374.  		      sroom->lx, sroom->ly, sroom->hx, sroom->hy);
375.  		pline("doormax=%d doorct=%d fdoor=%d",
376.  		      doorindex, sroom->doorct, sh);
377.  		while(j--) {
378.  		    pline("door [%d,%d]", doors[sh].x, doors[sh].y);
379.  		    sh++;
380.  		}
381.  		display_nhwindow(WIN_MESSAGE, FALSE);
382.  	    }
383.  # endif
384.  #endif
385.  	    return(-1);
386.  	}
387.  
388.  	if(MON_AT(sx, sy)) (void) rloc(m_at(sx, sy), FALSE); /* insurance */
389.  
390.  	/* now initialize the shopkeeper monster structure */
391.  	if(!(shk = makemon(&mons[PM_SHOPKEEPER], sx, sy, NO_MM_FLAGS)))
392.  		return(-1);
393.  	shk->isshk = shk->mpeaceful = 1;
394.  	set_malign(shk);
395.  	shk->msleeping = 0;
396.  	shk->mtrapseen = ~0;	/* we know all the traps already */
397.  	ESHK(shk)->shoproom = (sroom - rooms) + ROOMOFFSET;
398.  	sroom->resident = shk;
399.  	ESHK(shk)->shoptype = sroom->rtype;
400.  	assign_level(&(ESHK(shk)->shoplevel), &u.uz);
401.  	ESHK(shk)->shd = doors[sh];
402.  	ESHK(shk)->shk.x = sx;
403.  	ESHK(shk)->shk.y = sy;
404.  	ESHK(shk)->robbed = 0L;
405.  	ESHK(shk)->credit = 0L;
406.  	ESHK(shk)->debit = 0L;
407.  	ESHK(shk)->loan = 0L;
408.  	ESHK(shk)->visitct = 0;
409.  	ESHK(shk)->following = 0;
410.  	ESHK(shk)->billct = 0;
411.  #ifndef GOLDOBJ
412.  	shk->mgold = 1000L + 30L*(long)rnd(100);	/* initial capital */
413.  #else
414.          mkmonmoney(shk, 1000L + 30L*(long)rnd(100));	/* initial capital */
415.  #endif
416.  	if (shp->shknms == shkrings)
417.  	    (void) mongets(shk, TOUCHSTONE);
418.  	nameshk(shk, shp->shknms);
419.  
420.  	return(sh);
421.  }
422.

stock_room

423.  /* stock a newly-created room with objects */
424.  void
425.  stock_room(shp_indx, sroom)
426.  int shp_indx;
427.  register struct mkroom *sroom;
428.  {
429.      /*
430.       * Someday soon we'll dispatch on the shdist field of shclass to do
431.       * different placements in this routine. Currently it only supports
432.       * shop-style placement (all squares except a row nearest the first
433.       * door get objects).
434.       */
435.      register int sx, sy, sh;
436.      char buf[BUFSZ];
437.      int rmno = (sroom - rooms) + ROOMOFFSET;
438.      const struct shclass *shp = &shtypes[shp_indx];
439.  
440.      /* first, try to place a shopkeeper in the room */
441.      if ((sh = shkinit(shp, sroom)) < 0)
442.  	return;
443.  
444.      /* make sure no doorways without doors, and no */
445.      /* trapped doors, in shops.			   */
446.      sx = doors[sroom->fdoor].x;
447.      sy = doors[sroom->fdoor].y;
448.  
449.      if(levl[sx][sy].doormask == D_NODOOR) {
450.  	    levl[sx][sy].doormask = D_ISOPEN;
451.  	    newsym(sx,sy);
452.      }
453.      if(levl[sx][sy].typ == SDOOR) {
454.  	    cvt_sdoor_to_door(&levl[sx][sy]);	/* .typ = DOOR */
455.  	    newsym(sx,sy);
456.      }
457.      if(levl[sx][sy].doormask & D_TRAPPED)
458.  	    levl[sx][sy].doormask = D_LOCKED;
459.  
460.      if(levl[sx][sy].doormask == D_LOCKED) {
461.  	    register int m = sx, n = sy;
462.  
463.  	    if(inside_shop(sx+1,sy)) m--;
464.  	    else if(inside_shop(sx-1,sy)) m++;
465.  	    if(inside_shop(sx,sy+1)) n--;
466.  	    else if(inside_shop(sx,sy-1)) n++;
467.  	    Sprintf(buf, "Closed for inventory");
468.  	    make_engr_at(m, n, buf, 0L, DUST);
469.      }
470.  
471.      for(sx = sroom->lx; sx <= sroom->hx; sx++)
472.  	for(sy = sroom->ly; sy <= sroom->hy; sy++) {
473.  	    if(sroom->irregular) {
474.  		if (levl[sx][sy].edge || (int) levl[sx][sy].roomno != rmno ||
475.  		   distmin(sx, sy, doors[sh].x, doors[sh].y) <= 1)
476.  		    continue;
477.  	    } else if((sx == sroom->lx && doors[sh].x == sx-1) ||
478.  		      (sx == sroom->hx && doors[sh].x == sx+1) ||
479.  		      (sy == sroom->ly && doors[sh].y == sy-1) ||
480.  		      (sy == sroom->hy && doors[sh].y == sy+1)) continue;
481.  	    mkshobj_at(shp, sx, sy);
482.  	}
483.  
484.      /*
485.       * Special monster placements (if any) should go here: that way,
486.       * monsters will sit on top of objects and not the other way around.
487.       */
488.  
489.      level.flags.has_shop = TRUE;
490.  }
491.  
492.  #endif /* OVLB */

saleable

493.  #ifdef OVL0
494.  
495.  /* does shkp's shop stock this item type? */
496.  boolean
497.  saleable(shkp, obj)
498.  struct monst *shkp;
499.  struct obj *obj;
500.  {
501.      int i, shp_indx = ESHK(shkp)->shoptype - SHOPBASE;
502.      const struct shclass *shp = &shtypes[shp_indx];
503.  
504.      if (shp->symb == RANDOM_CLASS) return TRUE;
505.      else for (i = 0; i < SIZE(shtypes[0].iprobs) && shp->iprobs[i].iprob; i++)
506.  		if (shp->iprobs[i].itype < 0 ?
507.  			shp->iprobs[i].itype == - obj->otyp :
508.  			shp->iprobs[i].itype == obj->oclass) return TRUE;
509.      /* not found */
510.      return FALSE;
511.  }
512.

get_shop_item

513.  /* positive value: class; negative value: specific object type */
514.  int
515.  get_shop_item(type)
516.  int type;
517.  {
518.  	const struct shclass *shp = shtypes+type;
519.  	register int i,j;
520.  
521.  	/* select an appropriate object type at random */
522.  	for(j = rnd(100), i = 0; (j -= shp->iprobs[i].iprob) > 0; i++)
523.  		continue;
524.  
525.  	return shp->iprobs[i].itype;
526.  }
527.  
528.  #endif /* OVL0 */
529.  
530.  /*shknam.c*/
Retrieved from "https://nethackwiki.com/index.php?title=Source:NetHack_3.4.3/src/shknam.c&oldid=172042"