Below is the full text to exper.c from the source code of SLASH'EM 0.0.7E7F2. To link to a particular line, write [[SLASH'EM 0.0.7E7F2/exper.c#line123]], for example.
The latest source code for vanilla NetHack is at Source code.
| The NetHack General Public License applies to screenshots, source code and other content from NetHack. |
1. /* SCCS Id: @(#)exper.c 3.4 2002/11/20 */ 2. /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */ 3. /* NetHack may be freely redistributed. See license for details. */ 4. 5. #include "hack.h" 6. 7. /*STATIC_DCL*/ long FDECL(newuexp, (int)); 8. STATIC_DCL int FDECL(enermod, (int)); 9. 10. /*STATIC_OVL*/ long 11. newuexp(lev) 12. int lev; 13. { 14. /* KMH, balance patch -- changed again! */ 15. if (lev < 9) return (20L * (1L << lev)); 16. if (lev < 13) return (10000L * (1L << (lev - 9))); 17. if (lev == 13) return (150000L); 18. return (50000L * ((long)(lev - 9))); 19. /* Old XP routine */ 20. /* if (lev < 10) return (10L * (1L << lev)); */ 21. /* if (lev < 20) return (10000L * (1L << (lev - 10))); */ 22. /* return (10000000L * ((long)(lev - 19))); */ 23. /* if (lev == 1) return (75L); 24. if (lev == 2) return (150L); 25. if (lev == 3) return (300L); 26. if (lev == 4) return (600L); 27. if (lev == 5) return (1200L); */ 28. #if 0 29. if (lev == 1) return (50L); /* need 50 */ 30. if (lev == 2) return (100L); /* need 50 */ 31. if (lev == 3) return (200L); /* need 100 */ 32. if (lev == 4) return (500L); /* need 300 */ 33. if (lev == 5) return (1000L); /* need 500 */ 34. if (lev == 6) return (1750L); /* need 750 */ 35. if (lev == 7) return (2750L); /* need 1000 */ 36. if (lev == 8) return (4250L); /* need 1500 */ 37. if (lev == 9) return (6250L); /* need 2000 */ 38. if (lev == 10) return (8750L); /* need 2500 */ 39. if (lev == 11) return (11750L); /* need 3000 */ 40. if (lev == 12) return (15500L); /* need 3750 */ 41. if (lev == 13) return (20000L); /* need 4500 */ 42. if (lev == 14) return (25000L); /* need 5000 */ 43. if (lev == 15) return (31000L); /* need 6000 */ 44. if (lev == 16) return (38500L); /* need 7500 */ 45. if (lev == 17) return (48000L); /* need 9500 */ 46. if (lev == 18) return (60000L); /* need 12000 */ 47. if (lev == 19) return (76000L); /* need 16000 */ 48. if (lev == 20) return (97000L); /* need 21000 */ 49. if (lev == 21) return (125000L); /* need 28000 +7 */ 50. if (lev == 22) return (163000L); /* need 38000 +10 */ 51. if (lev == 23) return (213000L); /* need 50000 +12 */ 52. if (lev == 24) return (279000L); /* need 66000 +16 */ 53. if (lev == 25) return (365000L); /* need 86000 + 20 */ 54. if (lev == 26) return (476000L); /* need 111000 + 25 */ 55. if (lev == 27) return (617000L); /* need 141000+ 30 */ 56. if (lev == 28) return (798000L); /* need 181000 + 40 */ 57. if (lev == 29) return (1034000L); /* need 236000 + 55 */ 58. return (1750000L); 59. #endif 60. } 61. 62. STATIC_OVL int 63. enermod(en) 64. int en; 65. { 66. switch (Role_switch) { 67. /* WAC 'F' and 'I' get bonus similar to 'W' */ 68. case PM_FLAME_MAGE: 69. case PM_ICE_MAGE: 70. case PM_PRIEST: 71. case PM_WIZARD: 72. return(2 * en); 73. case PM_HEALER: 74. case PM_KNIGHT: 75. return((3 * en) / 2); 76. case PM_BARBARIAN: 77. case PM_VALKYRIE: 78. return((3 * en) / 4); 79. default: 80. return (en); 81. } 82. } 83. 84. int 85. experience(mtmp, nk) /* return # of exp points for mtmp after nk killed */ 86. register struct monst *mtmp; 87. register int nk; 88. #if defined(MAC_MPW) 89. # pragma unused(nk) 90. #endif 91. { 92. register struct permonst *ptr = mtmp->data; 93. int i, tmp, tmp2; 94. 95. tmp = 1 + mtmp->m_lev * mtmp->m_lev; 96. 97. /* For higher ac values, give extra experience */ 98. if ((i = find_mac(mtmp)) < 3) tmp += (7 - i) * ((i < 0) ? 2 : 1); 99. 100. /* For very fast monsters, give extra experience */ 101. if (ptr->mmove > NORMAL_SPEED) 102. tmp += (ptr->mmove > (3*NORMAL_SPEED/2)) ? 5 : 3; 103. 104. /* For each "special" attack type give extra experience */ 105. for(i = 0; i < NATTK; i++) { 106. tmp2 = ptr->mattk[i].aatyp; 107. if(tmp2 > AT_BUTT) { 108. 109. if(tmp2 == AT_WEAP) tmp += 5; 110. else if(tmp2 == AT_MAGC) tmp += 10; 111. else tmp += 3; 112. } 113. } 114. 115. /* For each "special" damage type give extra experience */ 116. for(i = 0; i < NATTK; i++) { 117. tmp2 = ptr->mattk[i].adtyp; 118. if(tmp2 > AD_PHYS && tmp2 < AD_BLND) tmp += 2*mtmp->m_lev; 119. else if((tmp2 == AD_DRLI) || (tmp2 == AD_STON) || 120. (tmp2 == AD_SLIM)) tmp += 50; 121. else if(tmp != AD_PHYS) tmp += mtmp->m_lev; 122. /* extra heavy damage bonus */ 123. if((int)(ptr->mattk[i].damd * ptr->mattk[i].damn) > 23) 124. tmp += mtmp->m_lev; 125. if (tmp2 == AD_WRAP && ptr->mlet == S_EEL && !Amphibious) 126. tmp += 1000; 127. } 128. 129. /* For certain "extra nasty" monsters, give even more */ 130. if (extra_nasty(ptr)) tmp += (7 * mtmp->m_lev); 131. 132. /* For higher level monsters, an additional bonus is given */ 133. if(mtmp->m_lev > 8) tmp += 50; 134. 135. #ifdef MAIL 136. /* Mail daemons put up no fight. */ 137. if(mtmp->data == &mons[PM_MAIL_DAEMON]) tmp = 1; 138. #endif 139. 140. return(tmp); 141. } 142. 143. void 144. more_experienced(exp, rexp) 145. register int exp, rexp; 146. { 147. u.uexp += exp; 148. u.urexp += 4*exp + rexp; 149. if(exp 150. #ifdef SCORE_ON_BOTL 151. || flags.showscore 152. #endif 153. ) flags.botl = 1; 154. if (u.urexp >= (Role_if(PM_WIZARD) ? 1000 : 2000)) 155. flags.beginner = 0; 156. } 157. 158. void 159. losexp(drainer,force) /* e.g., hit by drain life attack */ 160. const char *drainer; /* cause of death, if drain should be fatal */ 161. boolean force; /* Force the loss of an experience level */ 162. { 163. register int num; 164. 165. #ifdef WIZARD 166. /* explicit wizard mode requests to reduce level are never fatal. */ 167. if (drainer && !strcmp(drainer, "#levelchange")) 168. drainer = 0; 169. #endif 170. 171. if (!force && Drain_resistance) return; 172. 173. if (u.ulevel > 1) { 174. pline("%s level %d.", Goodbye(), u.ulevel--); 175. /* remove intrinsic abilities */ 176. adjabil(u.ulevel + 1, u.ulevel); 177. reset_rndmonst(NON_PM); /* new monster selection */ 178. } else { 179. if (drainer) { 180. killer_format = KILLED_BY; 181. killer = drainer; 182. done(DIED); 183. } 184. /* no drainer or lifesaved */ 185. u.uexp = 0; 186. } 187. num = newhp(); 188. u.uhpmax -= num; 189. if (u.uhpmax < 1) u.uhpmax = 1; 190. u.uhp -= num; 191. if (u.uhp < 1) u.uhp = 1; 192. else if (u.uhp > u.uhpmax) u.uhp = u.uhpmax; 193. 194. if (u.ulevel < urole.xlev) 195. num = rn1((int)ACURR(A_WIS)/2 + urole.enadv.lornd + urace.enadv.lornd, 196. urole.enadv.lofix + urace.enadv.lofix); 197. else 198. num = rn1((int)ACURR(A_WIS)/2 + urole.enadv.hirnd + urace.enadv.hirnd, 199. urole.enadv.hifix + urace.enadv.hifix); 200. num = enermod(num); /* M. Stephenson */ 201. u.uenmax -= num; 202. if (u.uenmax < 0) u.uenmax = 0; 203. u.uen -= num; 204. if (u.uen < 0) u.uen = 0; 205. else if (u.uen > u.uenmax) u.uen = u.uenmax; 206. 207. if (u.uexp > 0) 208. u.uexp = newuexp(u.ulevel) - 1; 209. flags.botl = 1; 210. } 211. 212. /* 213. * Make experience gaining similar to AD&D(tm), whereby you can at most go 214. * up by one level at a time, extra expr possibly helping you along. 215. * After all, how much real experience does one get shooting a wand of death 216. * at a dragon created with a wand of polymorph?? 217. */ 218. void 219. newexplevel() 220. { 221. if (u.ulevel < MAXULEV && u.uexp >= newuexp(u.ulevel)) 222. pluslvl(TRUE); 223. } 224. 225. #if 0 /* The old newexplevel() */ 226. { 227. register int tmp; 228. 229. if(u.ulevel < MAXULEV && u.uexp >= newuexp(u.ulevel)) { 230. 231. u.ulevel++; 232. if (u.ulevelmax < u.ulevel) u.ulevelmax = u.ulevel; /* KMH */ 233. if (u.uexp >= newuexp(u.ulevel)) u.uexp = newuexp(u.ulevel) - 1; 234. pline("Welcome to experience level %d.", u.ulevel); 235. /* give new intrinsics */ 236. adjabil(u.ulevel - 1, u.ulevel); 237. reset_rndmonst(NON_PM); /* new monster selection */ 238. /* STEPHEN WHITE'S NEW CODE */ 239. tmp = newhp(); 240. u.uhpmax += tmp; 241. u.uhp += tmp; 242. switch (Role_switch) { 243. case PM_ARCHEOLOGIST: u.uenbase += rnd(4) + 1; break; 244. case PM_BARBARIAN: u.uenbase += rnd(2); break; 245. case PM_CAVEMAN: u.uenbase += rnd(2); break; 246. case PM_DOPPELGANGER: u.uenbase += rnd(5) + 1; break; 247. case PM_ELF: case PM_DROW: u.uenbase += rnd(5) + 1; break; 248. case PM_FLAME_MAGE: u.uenbase += rnd(6) + 2; break; 249. case PM_GNOME: u.uenbase += rnd(3); break; 250. case PM_HEALER: u.uenbase += rnd(6) + 2; break; 251. case PM_ICE_MAGE: u.uenbase += rnd(6) + 2; break; 252. #ifdef YEOMAN 253. case PM_YEOMAN: 254. #endif 255. case PM_KNIGHT: u.uenbase += rnd(3); break; 256. case PM_HUMAN_WEREWOLF: u.uenbase += rnd(5) + 1; break; 257. case PM_MONK: u.uenbase += rnd(5) + 1; break; 258. case PM_NECROMANCER: u.uenbase += rnd(6) + 2; break; 259. case PM_PRIEST: u.uenbase += rnd(6) + 2; break; 260. case PM_ROGUE: u.uenbase += rnd(4) + 1; break; 261. case PM_SAMURAI: u.uenbase += rnd(2); break; 262. #ifdef TOURIST 263. case PM_TOURIST: u.uenbase += rnd(4) + 1; break; 264. #endif 265. case PM_UNDEAD_SLAYER: u.uenbase += rnd(3); break; 266. case PM_VALKYRIE: u.uenbase += rnd(2); break; 267. case PM_WIZARD: u.uenbase += rnd(6) + 2; break; 268. default: u.uenbase += rnd(2) + 1; break; 269. } 270. flags.botl = 1; 271. } 272. } 273. #endif /* old newexplevel() */ 274. 275. void 276. pluslvl(incr) 277. boolean incr; /* true iff via incremental experience growth */ 278. { /* (false for potion of gain level) */ 279. register int num; 280. 281. if (!incr) You_feel("more experienced."); 282. num = newhp(); 283. u.uhpmax += num; 284. u.uhp += num; 285. if (Upolyd) { 286. num = rnd(8); 287. u.mhmax += num; 288. u.mh += num; 289. } 290. if (u.ulevel < urole.xlev) 291. num = rn1((int)ACURR(A_WIS)/2 + urole.enadv.lornd + urace.enadv.lornd, 292. urole.enadv.lofix + urace.enadv.lofix); 293. else 294. num = rn1((int)ACURR(A_WIS)/2 + urole.enadv.hirnd + urace.enadv.hirnd, 295. urole.enadv.hifix + urace.enadv.hifix); 296. num = enermod(num); /* M. Stephenson */ 297. u.uenmax += num; 298. u.uen += num; 299. 300. if(u.ulevel < MAXULEV) { 301. if (incr) { 302. long tmp = newuexp(u.ulevel + 1); 303. if (u.uexp >= tmp) u.uexp = tmp - 1; 304. } else { 305. u.uexp = newuexp(u.ulevel); 306. } 307. ++u.ulevel; 308. if (u.ulevelmax < u.ulevel) u.ulevelmax = u.ulevel; 309. pline("Welcome to experience level %d.", u.ulevel); 310. adjabil(u.ulevel - 1, u.ulevel); /* give new intrinsics */ 311. reset_rndmonst(NON_PM); /* new monster selection */ 312. } 313. flags.botl = 1; 314. } 315. 316. /* compute a random amount of experience points suitable for the hero's 317. experience level: base number of points needed to reach the current 318. level plus a random portion of what it takes to get to the next level */ 319. long 320. rndexp(gaining) 321. boolean gaining; /* gaining XP via potion vs setting XP for polyself */ 322. { 323. long minexp, maxexp, diff, factor, result; 324. 325. minexp = (u.ulevel == 1) ? 0L : newuexp(u.ulevel - 1); 326. maxexp = newuexp(u.ulevel); 327. diff = maxexp - minexp, factor = 1L; 328. /* make sure that `diff' is an argument which rn2() can handle */ 329. while (diff >= (long)LARGEST_INT) 330. diff /= 2L, factor *= 2L; 331. result = minexp + factor * (long)rn2((int)diff); 332. /* 3.4.1: if already at level 30, add to current experience 333. points rather than to threshold needed to reach the current 334. level; otherwise blessed potions of gain level can result 335. in lowering the experience points instead of raising them */ 336. if (u.ulevel == MAXULEV && gaining) { 337. result += (u.uexp - minexp); 338. /* avoid wrapping (over 400 blessed potions needed for that...) */ 339. if (result < u.uexp) result = u.uexp; 340. } 341. return result; 342. } 343. 344. /*exper.c*/