Difference between revisions of "Source:NetHack 1.4f/mkshop.c"

From NetHackWiki
Jump to navigation Jump to search
m (Automated source code upload)
 
m (Semi-redirect to 1.3d versions)
Line 1: Line 1:
Below is the full text to '''mkshop.c''' from the [[NetHack 1.4f source code|source code]] of [[NetHack 1.4f]]. To link to a particular line, write [[NetHack 1.4f/mkshop.c#line123|<nowiki>[[NetHack 1.4f/mkshop.c#line123]]</nowiki>]], for example.
+
The source code file '''mkshop.c''' in [[NetHack 1.4f source code|NetHack 1.4f]] is unchanged from [[NetHack 1.3d/mkshop.c]].
 
+
[[Category:NetHack 1.4f source code]]
'''Warning!''' This is the source code from an old release. For the latest release, see [[Source code]]
 
 
 
{{CWI}}
 
<span id="line1">1.    /* SCCS Id: @(#)mkshop.c 1.3 87/07/14</span>
 
<span id="line2">2.    /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */</span>
 
<span id="line3">3.    /* mkshop.c - version 1.0.3 */</span>
 
<span id="line4">4.    </span>
 
<span id="line5">5.    #ifndef QUEST</span>
 
<span id="line6">6.    #include "hack.h"</span>
 
<span id="line7">7.    #include "mkroom.h"</span>
 
<span id="line8">8.    #include "eshk.h"</span>
 
<span id="line9">9.    #define ESHK ((struct eshk *)(&(shk->mextra[0])))</span>
 
<span id="line10">10.  extern struct monst *makemon();</span>
 
<span id="line11">11.  extern struct obj *mkobj_at();</span>
 
<span id="line12">12.  extern int nroom;</span>
 
<span id="line13">13.  extern char shtypes[]; /* = "=/+)%?!["; 9 types: 8 specialized, 1 mixed */</span>
 
<span id="line14">14.   #ifdef SPELLS</span>
 
<span id="line15">15.  schar shprobs[] = { 3,3,3,5,5,10,10,14,47 }; /* their probabilities */</span>
 
<span id="line16">16.  #else</span>
 
<span id="line17">17.  schar shprobs[] = { 3,3,5,5,10,10,14,50 }; /* their probabilities */</span>
 
<span id="line18">18.  #endif</span>
 
<span id="line19">19.  </span>
 
<span id="line20">20.  mkshop(){</span>
 
<span id="line21">21.  register struct mkroom *sroom;</span>
 
<span id="line22">22.  register int sh,sx,sy,i = -1;</span>
 
<span id="line23">23.  register char let;</span>
 
<span id="line24">24.  int roomno;</span>
 
<span id="line25">25.  register struct monst *shk;</span>
 
<span id="line26">26.  #ifdef WIZARD</span>
 
<span id="line27">27.  /* first determine shoptype */</span>
 
<span id="line28">28.  if(wizard){</span>
 
<span id="line29">29.  extern char *getenv();</span>
 
<span id="line30">30.  register char *ep = getenv("SHOPTYPE");</span>
 
<span id="line31">31.  if(ep){</span>
 
<span id="line32">32.  if(*ep == 'z' || *ep == 'Z'){</span>
 
<span id="line33">33.  mkzoo(ZOO);</span>
 
<span id="line34">34.  return;</span>
 
<span id="line35">35.  }</span>
 
<span id="line36">36.  if(*ep == 'm' || *ep == 'M'){</span>
 
<span id="line37">37.  mkzoo(MORGUE);</span>
 
<span id="line38">38.  return;</span>
 
<span id="line39">39.  }</span>
 
<span id="line40">40.  if(*ep == 'b' || *ep == 'B'){</span>
 
<span id="line41">41.  mkzoo(BEEHIVE);</span>
 
<span id="line42">42.  return;</span>
 
<span id="line43">43.  }</span>
 
<span id="line44">44.  #ifdef NEWCLASS</span>
 
<span id="line45">45.  if(*ep == 't' || *ep == 'T'){</span>
 
<span id="line46">46.  mkzoo(COURT);</span>
 
<span id="line47">47.  return;</span>
 
<span id="line48">48.  }</span>
 
<span id="line49">49.  #endif</span>
 
<span id="line50">50.  if(*ep == 's' || *ep == 'S'){</span>
 
<span id="line51">51.  mkswamp();</span>
 
<span id="line52">52.  return;</span>
 
<span id="line53">53.  }</span>
 
<span id="line54">54.  for(i=0; shtypes[i]; i++)</span>
 
<span id="line55">55.  if(*ep == shtypes[i]) break;</span>
 
<span id="line56">56.  goto gottype;</span>
 
<span id="line57">57.  }</span>
 
<span id="line58">58.  }</span>
 
<span id="line59">59.  gottype:</span>
 
<span id="line60">60.  #endif</span>
 
<span id="line61">61.  for(sroom = &rooms[0], roomno = 0; ; sroom++, roomno++){</span>
 
<span id="line62">62.  if(sroom->hx < 0) return;</span>
 
<span id="line63">63.  if(sroom - rooms >= nroom) {</span>
 
<span id="line64">64.  pline("rooms not closed by -1?");</span>
 
<span id="line65">65.  return;</span>
 
<span id="line66">66.  }</span>
 
<span id="line67">67.  if(sroom->rtype) continue;</span>
 
<span id="line68">68.  if(!sroom->rlit || has_dnstairs(sroom) || has_upstairs(sroom))</span>
 
<span id="line69">69.  continue;</span>
 
<span id="line70">70.  if(</span>
 
<span id="line71">71.  #ifdef WIZARD</span>
 
<span id="line72">72.    (wizard && getenv("SHOPTYPE") && sroom->doorct != 0) ||</span>
 
<span id="line73">73.  #endif</span>
 
<span id="line74">74.  sroom->doorct == 1) break;</span>
 
<span id="line75">75.  }</span>
 
<span id="line76">76.  </span>
 
<span id="line77">77.  if(i < 0) { /* shoptype not yet determined */</span>
 
<span id="line78">78.      register int j;</span>
 
<span id="line79">79.  </span>
 
<span id="line80">80.      for(j = rn2(100), i = 0; (j -= shprobs[i])>= 0; i++)</span>
 
<span id="line81">81.  if(!shtypes[i]) break; /* superfluous */</span>
 
<span id="line82">82.      if(isbig(sroom) && i + SHOPBASE == WANDSHOP)</span>
 
<span id="line83">83.  i = GENERAL-SHOPBASE;</span>
 
<span id="line84">84.  }</span>
 
<span id="line85">85.  sroom->rtype = i + SHOPBASE;</span>
 
<span id="line86">86.  let = shtypes[i];</span>
 
<span id="line87">87.  sh = sroom->fdoor;</span>
 
<span id="line88">88.  sx = doors[sh].x;</span>
 
<span id="line89">89.  sy = doors[sh].y;</span>
 
<span id="line90">90.  if(sx == sroom->lx-1) sx++; else</span>
 
<span id="line91">91.  if(sx == sroom->hx+1) sx--; else</span>
 
<span id="line92">92.  if(sy == sroom->ly-1) sy++; else</span>
 
<span id="line93">93.  if(sy == sroom->hy+1) sy--; else {</span>
 
<span id="line94">94.  #ifdef WIZARD</span>
 
<span id="line95">95.      /* This is said to happen sometimes, but I've never seen it. */</span>
 
<span id="line96">96.      if(wizard) {</span>
 
<span id="line97">97.  register int j = sroom->doorct;</span>
 
<span id="line98">98.  extern int doorindex;</span>
 
<span id="line99">99.  </span>
 
<span id="line100">100.  pline("Where is shopdoor?");</span>
 
<span id="line101">101.  pline("Room at (%d,%d),(%d,%d).", sroom->lx, sroom->ly,</span>
 
<span id="line102">102.  sroom->hx, sroom->hy);</span>
 
<span id="line103">103.  pline("doormax=%d doorct=%d fdoor=%d",</span>
 
<span id="line104">104.  doorindex, sroom->doorct, sh);</span>
 
<span id="line105">105.  while(j--) {</span>
 
<span id="line106">106.  pline("door [%d,%d]", doors[sh].x, doors[sh].y);</span>
 
<span id="line107">107.  sh++;</span>
 
<span id="line108">108.  }</span>
 
<span id="line109">109.  more();</span>
 
<span id="line110">110.      }</span>
 
<span id="line111">111.  #endif</span>
 
<span id="line112">112.      return;</span>
 
<span id="line113">113.  }</span>
 
<span id="line114">114.  if(!(shk = makemon(PM_SHK,sx,sy))) return;</span>
 
<span id="line115">115.  shk->isshk = shk->mpeaceful = 1;</span>
 
<span id="line116">116.  shk->msleep = 0;</span>
 
<span id="line117">117.  shk->mtrapseen = ~0; /* we know all the traps already */</span>
 
<span id="line118">118.  ESHK->shoproom = roomno;</span>
 
<span id="line119">119.  ESHK->shoplevel = dlevel;</span>
 
<span id="line120">120.  ESHK->shd = doors[sh];</span>
 
<span id="line121">121.  ESHK->shk.x = sx;</span>
 
<span id="line122">122.  ESHK->shk.y = sy;</span>
 
<span id="line123">123.  ESHK->robbed = 0;</span>
 
<span id="line124">124.  ESHK->visitct = 0;</span>
 
<span id="line125">125.  ESHK->following = 0;</span>
 
<span id="line126">126.  shk->mgold = 1000 + 30*rnd(100); /* initial capital */</span>
 
<span id="line127">127.  ESHK->billct = 0;</span>
 
<span id="line128">128.  findname(ESHK->shknam, let);</span>
 
<span id="line129">129.  for(sx = sroom->lx; sx <= sroom->hx; sx++)</span>
 
<span id="line130">130.  for(sy = sroom->ly; sy <= sroom->hy; sy++){</span>
 
<span id="line131">131.  register struct monst *mtmp;</span>
 
<span id="line132">132.  if((sx == sroom->lx && doors[sh].x == sx-1) ||</span>
 
<span id="line133">133.    (sx == sroom->hx && doors[sh].x == sx+1) ||</span>
 
<span id="line134">134.    (sy == sroom->ly && doors[sh].y == sy-1) ||</span>
 
<span id="line135">135.    (sy == sroom->hy && doors[sh].y == sy+1)) continue;</span>
 
<span id="line136">136.  if(rn2(100) < dlevel && !m_at(sx,sy) &&</span>
 
<span id="line137">137.    (mtmp = makemon(PM_MIMIC, sx, sy))){</span>
 
<span id="line138">138.  mtmp->mimic = 1;</span>
 
<span id="line139">139.  mtmp->mappearance =</span>
 
<span id="line140">140.      (let && rn2(10) < dlevel) ? let : ']';</span>
 
<span id="line141">141.  continue;</span>
 
<span id="line142">142.  }</span>
 
<span id="line143">143.  (void) mkobj_at(let, sx, sy);</span>
 
<span id="line144">144.  }</span>
 
<span id="line145">145.  }</span>
 
<span id="line146">146.  </span>
 
<span id="line147">147.  mkzoo(type)</span>
 
<span id="line148">148.  int type;</span>
 
<span id="line149">149.  {</span>
 
<span id="line150">150.  register struct mkroom *sroom;</span>
 
<span id="line151">151.  register struct monst *mon;</span>
 
<span id="line152">152.  register int sh,sx,sy,i;</span>
 
<span id="line153">153.  int goldlim = 500 * dlevel;</span>
 
<span id="line154">154.  int moct = 0;</span>
 
<span id="line155">155.  struct permonst *morguemon();</span>
 
<span id="line156">156.  #ifdef NEWCLASS</span>
 
<span id="line157">157.  struct permonst *courtmon();</span>
 
<span id="line158">158.  #endif</span>
 
<span id="line159">159.  </span>
 
<span id="line160">160.  i = nroom;</span>
 
<span id="line161">161.  for(sroom = &rooms[rn2(nroom)]; ; sroom++) {</span>
 
<span id="line162">162.  if(sroom == &rooms[nroom])</span>
 
<span id="line163">163.  sroom = &rooms[0];</span>
 
<span id="line164">164.  if(!i-- || sroom->hx < 0)</span>
 
<span id="line165">165.  return;</span>
 
<span id="line166">166.  if(sroom->rtype) continue;</span>
 
<span id="line167">167.  if(type == MORGUE && sroom->rlit) continue;</span>
 
<span id="line168">168.  if(has_upstairs(sroom) || (has_dnstairs(sroom) && rn2(3)))</span>
 
<span id="line169">169.  continue;</span>
 
<span id="line170">170.  if(sroom->doorct == 1 || !rn2(5))</span>
 
<span id="line171">171.  break;</span>
 
<span id="line172">172.  }</span>
 
<span id="line173">173.  sroom->rtype = type;</span>
 
<span id="line174">174.  sh = sroom->fdoor;</span>
 
<span id="line175">175.  for(sx = sroom->lx; sx <= sroom->hx; sx++)</span>
 
<span id="line176">176.      for(sy = sroom->ly; sy <= sroom->hy; sy++){</span>
 
<span id="line177">177.  if((sx == sroom->lx && doors[sh].x == sx-1) ||</span>
 
<span id="line178">178.    (sx == sroom->hx && doors[sh].x == sx+1) ||</span>
 
<span id="line179">179.    (sy == sroom->ly && doors[sh].y == sy-1) ||</span>
 
<span id="line180">180.    (sy == sroom->hy && doors[sh].y == sy+1)) continue;</span>
 
<span id="line181">181.  mon = makemon(</span>
 
<span id="line182">182.  #ifdef NEWCLASS</span>
 
<span id="line183">183.    (type == COURT) ? courtmon() :</span>
 
<span id="line184">184.  #endif</span>
 
<span id="line185">185.    (type == MORGUE) ? morguemon() :</span>
 
<span id="line186">186.    (type == BEEHIVE) ? PM_KILLER_BEE : (struct permonst *) 0,</span>
 
<span id="line187">187.    sx, sy);</span>
 
<span id="line188">188.  if(mon) mon->msleep = 1;</span>
 
<span id="line189">189.  switch(type) {</span>
 
<span id="line190">190.  case ZOO:</span>
 
<span id="line191">191.    i = sq(dist2(sx,sy,doors[sh].x,doors[sh].y));</span>
 
<span id="line192">192.    if(i >= goldlim) i = 5*dlevel;</span>
 
<span id="line193">193.    goldlim -= i;</span>
 
<span id="line194">194.    mkgold((long)(10 + rn2(i)), sx, sy);</span>
 
<span id="line195">195.    break;</span>
 
<span id="line196">196.  case MORGUE:</span>
 
<span id="line197">197.    /* Usually there is one dead body in the morgue */</span>
 
<span id="line198">198.    if(!moct && rn2(3)) {</span>
 
<span id="line199">199.  mksobj_at(CORPSE, sx, sy);</span>
 
<span id="line200">200.  moct++;</span>
 
<span id="line201">201.    }</span>
 
<span id="line202">202.    break;</span>
 
<span id="line203">203.  case BEEHIVE:</span>
 
<span id="line204">204.    if(!rn2(3)) mksobj_at(LUMP_OF_ROYAL_JELLY, sx, sy);</span>
 
<span id="line205">205.    break;</span>
 
<span id="line206">206.  }</span>
 
<span id="line207">207.  }</span>
 
<span id="line208">208.  #ifdef NEWCLASS</span>
 
<span id="line209">209.  if(type == COURT)  {</span>
 
<span id="line210">210.  </span>
 
<span id="line211">211.  sx = sroom->lx + (rn2(sroom->hx - sroom->lx));</span>
 
<span id="line212">212.  sy = sroom->ly + (rn2(sroom->hy - sroom->ly));</span>
 
<span id="line213">213.  levl[sx][sy].typ = THRONE;</span>
 
<span id="line214">214.  levl[sx][sy].scrsym = THRONE_SYM;</span>
 
<span id="line215">215.  mkgold((long) rn1(50 * dlevel,10), sx, sy);</span>
 
<span id="line216">216.  }</span>
 
<span id="line217">217.  #endif</span>
 
<span id="line218">218.  </span>
 
<span id="line219">219.  }</span>
 
<span id="line220">220.  </span>
 
<span id="line221">221.  struct permonst *</span>
 
<span id="line222">222.  morguemon()</span>
 
<span id="line223">223.  {</span>
 
<span id="line224">224.  extern struct permonst pm_ghost;</span>
 
<span id="line225">225.  register int i = rn2(100), hd = rn2(dlevel);</span>
 
<span id="line226">226.  </span>
 
<span id="line227">227.  if(hd > 10 && i < 10) return(PM_DEMON);</span>
 
<span id="line228">228.  if(hd > 8 && i > 85) return(PM_VAMPIRE);</span>
 
<span id="line229">229.  return((i < 40) ? PM_GHOST : (i < 60) ? PM_WRAITH : PM_ZOMBIE);</span>
 
<span id="line230">230.  }</span>
 
<span id="line231">231.  </span>
 
<span id="line232">232.  mkswamp() /* Michiel Huisjes & Fred de Wilde */</span>
 
<span id="line233">233.  {</span>
 
<span id="line234">234.  register struct mkroom *sroom;</span>
 
<span id="line235">235.  register int sx,sy,i,eelct = 0;</span>
 
<span id="line236">236.  extern struct permonst pm_eel;</span>
 
<span id="line237">237.  </span>
 
<span id="line238">238.  for(i=0; i<5; i++) { /* 5 tries */</span>
 
<span id="line239">239.  sroom = &rooms[rn2(nroom)];</span>
 
<span id="line240">240.  if(sroom->hx < 0 || sroom->rtype ||</span>
 
<span id="line241">241.    has_upstairs(sroom) || has_dnstairs(sroom))</span>
 
<span id="line242">242.  continue;</span>
 
<span id="line243">243.  </span>
 
<span id="line244">244.  /* satisfied; make a swamp */</span>
 
<span id="line245">245.  sroom->rtype = SWAMP;</span>
 
<span id="line246">246.  for(sx = sroom->lx; sx <= sroom->hx; sx++)</span>
 
<span id="line247">247.  for(sy = sroom->ly; sy <= sroom->hy; sy++)</span>
 
<span id="line248">248.  if((sx+sy)%2 && !o_at(sx,sy) && !t_at(sx,sy)</span>
 
<span id="line249">249.      && !m_at(sx,sy) && !nexttodoor(sx,sy)){</span>
 
<span id="line250">250.  levl[sx][sy].typ = POOL;</span>
 
<span id="line251">251.  levl[sx][sy].scrsym = POOL_SYM;</span>
 
<span id="line252">252.  if(!eelct || !rn2(4)) {</span>
 
<span id="line253">253.  (void) makemon(PM_EEL, sx, sy);</span>
 
<span id="line254">254.  eelct++;</span>
 
<span id="line255">255.  }</span>
 
<span id="line256">256.  }</span>
 
<span id="line257">257.  }</span>
 
<span id="line258">258.  }</span>
 
<span id="line259">259.  </span>
 
<span id="line260">260.  nexttodoor(sx,sy)</span>
 
<span id="line261">261.  register sx,sy;</span>
 
<span id="line262">262.  {</span>
 
<span id="line263">263.  register dx,dy;</span>
 
<span id="line264">264.  register struct rm *lev;</span>
 
<span id="line265">265.  for(dx = -1; dx <= 1; dx++) for(dy = -1; dy <= 1; dy++)</span>
 
<span id="line266">266.  if((lev = &levl[sx+dx][sy+dy])->typ == DOOR ||</span>
 
<span id="line267">267.      lev->typ == SDOOR || lev->typ == LDOOR)</span>
 
<span id="line268">268.  return(1);</span>
 
<span id="line269">269.  return(0);</span>
 
<span id="line270">270.  }</span>
 
<span id="line271">271.  </span>
 
<span id="line272">272.  has_dnstairs(sroom)</span>
 
<span id="line273">273.  register struct mkroom *sroom;</span>
 
<span id="line274">274.  {</span>
 
<span id="line275">275.  return(sroom->lx <= xdnstair && xdnstair <= sroom->hx &&</span>
 
<span id="line276">276.    sroom->ly <= ydnstair && ydnstair <= sroom->hy);</span>
 
<span id="line277">277.  }</span>
 
<span id="line278">278.  </span>
 
<span id="line279">279.  has_upstairs(sroom)</span>
 
<span id="line280">280.  register struct mkroom *sroom;</span>
 
<span id="line281">281.  {</span>
 
<span id="line282">282.  return(sroom->lx <= xupstair && xupstair <= sroom->hx &&</span>
 
<span id="line283">283.    sroom->ly <= yupstair && yupstair <= sroom->hy);</span>
 
<span id="line284">284.  }</span>
 
<span id="line285">285.  </span>
 
<span id="line286">286.  isbig(sroom)</span>
 
<span id="line287">287.  register struct mkroom *sroom;</span>
 
<span id="line288">288.  {</span>
 
<span id="line289">289.  register int area = (sroom->hx - sroom->lx) * (sroom->hy - sroom->ly);</span>
 
<span id="line290">290.  return( area > 20 );</span>
 
<span id="line291">291.  }</span>
 
<span id="line292">292.  </span>
 
<span id="line293">293.  dist2(x0,y0,x1,y1){</span>
 
<span id="line294">294.  return((x0-x1)*(x0-x1) + (y0-y1)*(y0-y1));</span>
 
<span id="line295">295.  }</span>
 
<span id="line296">296.  </span>
 
<span id="line297">297.  sq(a) int a; {</span>
 
<span id="line298">298.  return(a*a);</span>
 
<span id="line299">299.  }</span>
 
<span id="line300">300.  #endif /* QUEST /**/</span>
 
<span id="line301">301.  </span>
 
<span id="line302">302.  #ifdef NEWCLASS</span>
 
<span id="line303">303.  struct permonst *</span>
 
<span id="line304">304.  courtmon()</span>
 
<span id="line305">305.  {</span>
 
<span id="line306">306.  int    i = rn2(60) + rn2(3*dlevel);</span>
 
<span id="line307">307.  </span>
 
<span id="line308">308.  if (i > 100) return(PM_DRAGON);</span>
 
<span id="line309">309.  else if (i > 95) return(PM_XORN);</span>
 
<span id="line310">310.  else if (i > 85) return(PM_TROLL);</span>
 
<span id="line311">311.  else if (i > 75) return(PM_ETTIN);</span>
 
<span id="line312">312.  else if (i > 60) return(PM_CENTAUR);</span>
 
<span id="line313">313.  else if (i > 45) return(PM_ORC);</span>
 
<span id="line314">314.  else if (i > 30) return(PM_HOBGOBLIN);</span>
 
<span id="line315">315.  #ifdef KOPS</span>
 
<span id="line316">316.  else return(PM_GNOME);</span>
 
<span id="line317">317.  #else</span>
 
<span id="line318">318.  else if (i > 15) return(PM_GNOME);</span>
 
<span id="line319">319.  else return(PM_KOBOLD);</span>
 
<span id="line320">320.  #endif</span>
 
<span id="line321">321.  }</span>
 
<span id="line322">322.  #endif /* NEWCLASS /**/</span>
 
[[Category:NetHack 1.4f source code|mkshop.c]]
 

Revision as of 20:49, 3 September 2006

The source code file mkshop.c in NetHack 1.4f is unchanged from NetHack 1.3d/mkshop.c.