| abstract
| - Below is the full text to mondata.c from the source code of NetHack 3.0.0. To link to a particular line, write [[NetHack 3.0.0/mondata.c#line123]], for example. Warning! This is the source code from an old release. For the latest release, see Source code 1. /* SCCS Id: @(#)mondata.c 3.0 89/01/10 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 "eshk.h" 7. #include "epri.h" 8. 9. /* These routines provide basic data for any type of monster. */ 10. 11. boolean 12. attacktype(ptr, atyp) 13. register struct permonst *ptr; 14. register int atyp; 15. { 16. int i; 17. 18. for(i = 0; i < NATTK; i++) 19. if(ptr->mattk[i].aatyp == atyp) return(TRUE); 20. 21. return(FALSE); 22. } 23. 24. boolean 25. resists_ston(ptr) /* returns TRUE if monster is petrify resistant */ 26. register struct permonst *ptr; 27. { 28. return (ptr->mflags1 & M1_STON_RES || dmgtype(ptr, AD_STON) || 29. dmgtype(ptr, AD_ACID)); 30. } 31. 32. boolean 33. resists_drli(ptr) /* returns TRUE if monster is drain-life resistant */ 34. 35. register struct permonst *ptr; 36. { 37. return(is_undead(ptr) || is_demon(ptr) || is_were(ptr)); 38. } 39. 40. boolean 41. ranged_attk(ptr) /* returns TRUE if monster can attack at range */ 42. register struct permonst *ptr; 43. { 44. return (attacktype(ptr, AT_BREA) || attacktype(ptr, AT_WEAP) || 45. attacktype(ptr, AT_SPIT) || attacktype(ptr, AT_GAZE) || 46. attacktype(ptr, AT_MAGC)); 47. } 48. 49. boolean 50. can_track(ptr) /* returns TRUE if monster can track well */ 51. register struct permonst *ptr; 52. { 53. #ifdef NAMED_ITEMS 54. if(uwep && !strcmp(ONAME(uwep), "Excalibur")) return TRUE; 55. #endif 56. return(haseyes(ptr)); 57. } 58. 59. #ifdef POLYSELF 60. boolean 61. breakarm(ptr) /* creature will break out of armor */ 62. register struct permonst *ptr; 63. { 64. return(bigmonst(ptr) || (!verysmall(ptr) && !humanoid(ptr)) 65. #ifdef HARD 66. || ptr == &mons[PM_MARILITH] 67. #endif 68. ); 69. /* Marilith is about the only case of a monster which is otherwise 70. * humanoid but cannot wear armor (too many arms). Centaurs would 71. * be another except that they are already accounted for by 72. * bigmonst. 73. */ 74. } 75. 76. boolean 77. sliparm(ptr) /* creature will slide out of armor */ 78. register struct permonst *ptr; 79. { 80. return(!bigmonst(ptr) && (verysmall(ptr) || ptr == &mons[PM_GHOST])); 81. } 82. #endif 83. 84. boolean 85. sticks(ptr) /* creature sticks other creatures it hits */ 86. register struct permonst *ptr; 87. { 88. return(dmgtype(ptr,AD_STCK) || dmgtype(ptr,AD_WRAP) || 89. attacktype(ptr,AT_HUGS)); 90. } 91. 92. /* not one hundred percent correct: now a snake may hide under an 93. * invisible object. 94. */ 95. boolean 96. canseemon(mtmp) 97. register struct monst *mtmp; 98. { 99. return((!mtmp->minvis || See_invisible) 100. && (!mtmp->mhide || 101. (levl[mtmp->mx][mtmp->my].omask == 0 && 102. levl[mtmp->mx][mtmp->my].gmask == 0)) 103. && cansee(mtmp->mx, mtmp->my)); 104. } 105. 106. boolean 107. dmgtype(ptr, dtyp) 108. register struct permonst *ptr; 109. register int dtyp; 110. { 111. int i; 112. 113. for(i = 0; i < NATTK; i++) 114. if(ptr->mattk[i].adtyp == dtyp) return TRUE; 115. 116. return FALSE; 117. } 118. 119. int 120. monsndx(ptr) /* return an index into the mons array */ 121. struct permonst *ptr; 122. { 123. register int i; 124. register struct permonst *mdat; 125. 126. if(ptr == &playermon) return(-1); 127. 128. for(i = 0, mdat = &mons[0]; mdat->mlet; i++) 129. if(ptr == mdat++) return(i); 130. 131. panic("monsndx - could not index monster (%x)", ptr); 132. return FALSE; /* will not get here */ 133. } 134. 135. int 136. name_to_mon(str) 137. char *str; 138. { 139. /* Be careful. We must check the entire string in case it was 140. * something such as "ettin zombie corpse". The calling routine 141. * doesn't know about the "corpse" until the monster name has 142. * already been taken off the front, so we have to be able to 143. * read the name with extraneous stuff such as "corpse" stuck on 144. * the end. 145. * This causes a problem for names which prefix other names such 146. * as "ettin" on "ettin zombie". In this case we want the _longest_ 147. * name which exists. 148. * This also permits plurals created by adding suffixes such as 's' 149. * or 'es'. Other plurals must still be handled explicitly. 150. */ 151. register int i; 152. register int mntmp = -1; 153. register char *s; 154. char buf[BUFSZ]; 155. int len=0; 156. 157. Strcpy(buf, str); 158. str = buf; 159. if (!strncmp(str, "a ", 2)) str += 2; 160. else if (!strncmp(str, "an ", 3)) str += 3; 161. 162. /* Some irregular plurals */ 163. #ifdef HARD 164. if (!strncmp(str, "incubi", 6)) return PM_INCUBUS; 165. if (!strncmp(str, "succubi", 7)) return PM_SUCCUBUS; 166. #endif 167. if (!strncmp(str, "violet fungi", 12)) return PM_VIOLET_FUNGUS; 168. if (!strncmp(str, "homunculi", 9)) return PM_HOMUNCULUS; 169. if (!strncmp(str, "baluchitheria", 13)) return PM_BALUCHITHERIUM; 170. if (!strncmp(str, "lurkers above", 13)) return PM_LURKER_ABOVE; 171. if (!strncmp(str, "cavemen", 7)) return PM_CAVEMAN; 172. if (!strncmp(str, "cavewomen", 9)) return PM_CAVEWOMAN; 173. if (!strncmp(str, "zruties", 7)) return PM_ZRUTY; 174. if (!strncmp(str, "djinn", 5)) return PM_DJINNI; 175. /* be careful with "ies"; "priest", "zombies" */ 176. for(s=str; *s; s++) { 177. if (!strncmp(s, "vortices", 8)) { 178. Strcpy(s+4, "ex"); 179. break; 180. } 181. if (!strncmp(s, "jellies", 7) || !strncmp(s, "mummies", 7)) { 182. Strcpy(s+4, "y"); 183. break; 184. } 185. if (!strncmp(s, "ves", 3)) { 186. /* luckily no monster names end in fe or ve with ves plurals */ 187. Strcpy(s, "f"); 188. break; 189. } 190. } 191. 192. for(i = 0; mons[i].mlet; i++) { 193. if(!strncmp(mons[i].mname, str, strlen(mons[i].mname))) { 194. if (strlen(mons[i].mname) > len) { 195. mntmp = i; 196. len = strlen(mons[i].mname); 197. } 198. } 199. } 200. return mntmp; 201. } 202. 203. #ifdef POLYSELF 204. boolean 205. webmaker(ptr) /* creature can spin a web */ 206. register struct permonst *ptr; 207. { 208. return (ptr->mlet == S_SPIDER && ptr != &mons[PM_SCORPION]); 209. } 210. #endif 211. 212. boolean 213. is_female(mtmp) 214. register struct monst *mtmp; 215. { 216. if (mtmp->isshk) return !ESHK(mtmp)->ismale; 217. #if defined(ALTARS) && defined(THEOLOGY) 218. if (mtmp->ispriest) return !EPRI(mtmp)->ismale; 219. #endif 220. return !!(mtmp->data->mflags1 & M1_FEM); 221. } 222. 223. /* Gender function. Differs from is_female() in that 1) It allows the monster 224. * type of a polymorphed shopkeeper to override ESHK(mtmp)->ismale, and 2) 225. * it returns 3 values (0=male, 1=female, 2=none) instead of 2. 226. */ 227. int 228. gender(mtmp) 229. register struct monst *mtmp; 230. { 231. if (!humanoid(mtmp->data)) return 2; 232. if (mtmp->data->mflags1 & M1_FEM) return 1; 233. if (mtmp->data == &mons[PM_CAVEMAN] 234. || mtmp->data == &mons[PM_PRIEST] 235. #ifdef HARD 236. || mtmp->data == &mons[PM_INCUBUS] 237. #endif 238. ) return 0; 239. #if defined(ALTARS) && defined(THEOLOGY) 240. if (mtmp->ispriest) return !EPRI(mtmp)->ismale; 241. #endif 242. if (mtmp->isshk) return !ESHK(mtmp)->ismale; 243. return 0; 244. } 245. 246. boolean 247. levl_follower(mtmp) 248. register struct monst *mtmp; 249. { 250. return (mtmp->mtame || (mtmp->data->mflags1 & M1_STALK) || is_fshk(mtmp) 251. || (mtmp->iswiz && !mon_has_amulet(mtmp))); 252. } 253. 254. struct permonst * 255. player_mon() 256. { 257. switch (pl_character[0]) { 258. case 'A': return &mons[PM_ARCHEOLOGIST]; 259. case 'B': return &mons[PM_BARBARIAN]; 260. case 'C': if (flags.female) return &mons[PM_CAVEWOMAN]; 261. else return &mons[PM_CAVEMAN]; 262. case 'E': return &mons[PM_ELF]; 263. case 'H': return &mons[PM_HEALER]; 264. case 'K': return &mons[PM_KNIGHT]; 265. case 'P': if (flags.female) return &mons[PM_PRIESTESS]; 266. else return &mons[PM_PRIEST]; 267. case 'R': return &mons[PM_ROGUE]; 268. case 'S': return &mons[PM_SAMURAI]; 269. case 'T': return &mons[PM_TOURIST]; 270. case 'V': return &mons[PM_VALKYRIE]; 271. case 'W': return &mons[PM_WIZARD]; 272. default: impossible("what are you?"); 273. return &mons[PM_HUMAN]; 274. } 275. } 276. 277. const int grownups[][2] = { {PM_LITTLE_DOG, PM_DOG}, {PM_DOG, PM_LARGE_DOG}, 278. {PM_HELL_HOUND_PUP, PM_HELL_HOUND}, {PM_KITTEN, PM_HOUSECAT}, 279. {PM_HOUSECAT, PM_LARGE_CAT}, {PM_BABY_GREY_DRAGON, PM_GREY_DRAGON}, 280. {PM_BABY_RED_DRAGON, PM_RED_DRAGON}, 281. {PM_BABY_WHITE_DRAGON, PM_WHITE_DRAGON}, 282. {PM_BABY_BLUE_DRAGON, PM_BLUE_DRAGON}, 283. {PM_BABY_GREEN_DRAGON, PM_GREEN_DRAGON}, 284. {PM_BABY_ORANGE_DRAGON, PM_ORANGE_DRAGON}, 285. {PM_BABY_BLACK_DRAGON, PM_BLACK_DRAGON}, 286. {PM_BABY_YELLOW_DRAGON, PM_YELLOW_DRAGON}, 287. {PM_RED_NAGA_HATCHLING, PM_RED_NAGA}, 288. {PM_BLACK_NAGA_HATCHLING, PM_BLACK_NAGA}, 289. {PM_GOLDEN_NAGA_HATCHLING, PM_GOLDEN_NAGA}, 290. {PM_GUARDIAN_NAGA_HATCHLING, PM_GUARDIAN_NAGA}, 291. {PM_BABY_PURPLE_WORM, PM_PURPLE_WORM}, 292. #ifdef WORM 293. {PM_BABY_LONG_WORM, PM_LONG_WORM}, 294. #endif 295. #ifdef ARMY 296. {PM_SOLDIER, PM_SERGEANT}, 297. {PM_SERGEANT, PM_LIEUTENANT}, 298. {PM_LIEUTENANT, PM_CAPTAIN}, 299. #endif 300. {-1,-1} 301. }; 302. 303. int little_to_big(montype) 304. int montype; 305. { 306. register int *i; 307. 308. for(i=grownups[0]; *i >= 0; i++) 309. if(montype == *i) return *(i+1); 310. return montype; 311. } 312. 313. int big_to_little(montype) 314. int montype; 315. { 316. register int *i; 317. 318. for(i=grownups[0]; *i >= 0; i++) 319. if(montype == *(i+1)) return *i; 320. return montype; 321. } 322. 323. 324. #ifdef STUPID_CPP /* otherwise these functions are macros in mondata.h */ 325. 326. int 327. bigmonst(ptr) struct permonst *ptr; { 328. return((ptr->mflags1 & M1_BIG) != 0L); 329. } 330. 331. int 332. verysmall(ptr) struct permonst *ptr; { 333. return((ptr->mflags1 & M1_VSMALL) != 0L); 334. } 335. 336. int 337. is_flyer(ptr) struct permonst *ptr; { 338. return((ptr->mflags1 & M1_FLY) != 0L); 339. } 340. 341. int 342. is_floater(ptr) struct permonst *ptr; { 343. return(ptr->mlet == S_EYE); 344. } 345. 346. int 347. is_swimmer(ptr) struct permonst *ptr; { 348. return((ptr->mflags1 & M1_SWIM) != 0L); 349. } 350. 351. int 352. passes_walls(ptr) struct permonst *ptr; { 353. return((ptr->mflags1 & M1_WALLWALK) != 0L); 354. } 355. 356. int 357. noncorporeal(ptr) struct permonst *ptr; { 358. return(ptr->mlet == S_GHOST); 359. } 360. 361. int 362. is_animal(ptr) struct permonst *ptr; { 363. return((ptr->mflags1 & M1_ANIMAL) != 0L); 364. } 365. 366. int 367. humanoid(ptr) struct permonst *ptr; { 368. return((ptr->mflags1 & M1_HUMANOID) != 0L); 369. } 370. 371. int 372. is_undead(ptr) struct permonst *ptr; { 373. return((ptr->mflags1 & M1_UNDEAD) != 0L); 374. } 375. 376. int 377. is_were(ptr) struct permonst *ptr; { 378. return((ptr->mflags1 & M1_WERE) != 0L); 379. } 380. 381. int haseyes(ptr) struct permonst *ptr; { 382. return((ptr->mflags1 & M1_NOEYES) == 0L); 383. } 384. 385. int 386. nohands(ptr) struct permonst *ptr; { 387. return((ptr->mflags1 & M1_NOHANDS) != 0L); 388. } 389. 390. int 391. lays_eggs(ptr) struct permonst *ptr; { 392. return((ptr->mflags1 & M1_EGGS) != 0L); 393. } 394. 395. int 396. poisonous(ptr) struct permonst *ptr; { 397. return((ptr->mflags1 & M1_POIS) != 0L); 398. } 399. 400. int 401. resists_poison(ptr) struct permonst *ptr; { 402. return((ptr->mflags1 & (M1_POIS | M1_POIS_RES)) != 0L); 403. } 404. 405. int 406. resists_fire(ptr) struct permonst *ptr; { 407. return((ptr->mflags1 & M1_FIRE_RES) != 0L); 408. } 409. 410. int 411. resists_cold(ptr) struct permonst *ptr; { 412. return((ptr->mflags1 & M1_COLD_RES) != 0L); 413. } 414. 415. int 416. resists_acid(ptr) struct permonst *ptr; { 417. return(dmgtype(ptr, AD_ACID)); 418. } 419. 420. int 421. resists_elec(ptr) struct permonst *ptr; { 422. return((ptr->mflags1 & M1_ELEC_RES) != 0L); 423. } 424. 425. int 426. resists_sleep(ptr) struct permonst *ptr; { 427. return((ptr->mflags1 & (M1_SLEE_RES | M1_UNDEAD)) != 0L); 428. } 429. 430. int 431. resists_disint(ptr) struct permonst *ptr; { 432. return(ptr == &mons[PM_BLACK_DRAGON] || 433. ptr == &mons[PM_BABY_BLACK_DRAGON]); 434. } 435. 436. int 437. regenerates(ptr) struct permonst *ptr; { 438. return((ptr->mflags1 & M1_REGEN) != 0L); 439. } 440. 441. int 442. perceives(ptr) struct permonst *ptr; { 443. return((ptr->mflags1 & M1_SEE_INVIS) != 0L); 444. } 445. 446. int 447. can_teleport(ptr) struct permonst *ptr; { 448. return((ptr->mflags1 & M1_TPORT) != 0L); 449. } 450. 451. int 452. control_teleport(ptr) struct permonst *ptr; { 453. return((ptr->mflags1 & M1_TPORT_CONTROL) != 0L); 454. } 455. 456. int 457. is_armed(ptr) struct permonst *ptr; { 458. return(attacktype(ptr, AT_WEAP)); 459. } 460. 461. int 462. likes_gold(ptr) struct permonst *ptr; { 463. return((ptr->mflags1 & M1_GREEDY) != 0L); 464. } 465. 466. int 467. likes_gems(ptr) struct permonst *ptr; { 468. return((ptr->mflags1 & M1_JEWELS) != 0L); 469. } 470. 471. int 472. likes_objs(ptr) struct permonst *ptr; { 473. return((ptr->mflags1 & M1_COLLECT) != 0L || is_armed(ptr)); 474. } 475. 476. int 477. likes_magic(ptr) struct permonst *ptr; { 478. return((ptr->mflags1 & M1_MAGIC) != 0L); 479. } 480. 481. int 482. hides_under(ptr) struct permonst *ptr; { 483. return((ptr->mflags2 & M2_CONCEAL) != 0L); 484. } 485. 486. int 487. is_hider(ptr) struct permonst *ptr; { 488. return((ptr->mflags2 & M2_HIDE) != 0L); 489. } 490. 491. # ifdef POLYSELF 492. int 493. polyok(ptr) struct permonst *ptr; { 494. return((ptr->mflags1 & M1_NOPOLY) == 0L); 495. } 496. # endif /* POLYSELF */ 497. 498. int 499. tunnels(ptr) struct permonst *ptr; { 500. return((ptr->mflags2 & M2_TUNNEL) != 0L); 501. } 502. 503. int 504. needspick(ptr) struct permonst *ptr; { 505. return((ptr->mflags2 & M2_NEEDPICK) != 0L); 506. } 507. 508. int 509. is_elf(ptr) struct permonst *ptr; { 510. return((ptr->mflags2 & M2_ELF) != 0L); 511. } 512. 513. int 514. is_dwarf(ptr) struct permonst *ptr; { 515. return((ptr->mflags2 & M2_DWARF) != 0L); 516. } 517. 518. int 519. is_giant(ptr) struct permonst *ptr; { 520. return((ptr->mflags2 & M2_GIANT) != 0L); 521. } 522. 523. # ifdef GOLEMS 524. int 525. is_golem(ptr) struct permonst *ptr; { 526. return(ptr->mlet == S_GOLEM); 527. } 528. # endif /* GOLEMS */ 529. 530. int 531. is_orc(ptr) struct permonst *ptr; { 532. return((ptr->mflags2 & M2_ORC) != 0L); 533. } 534. 535. int 536. is_human(ptr) struct permonst *ptr; { 537. return((ptr->mflags2 & M2_HUMAN) != 0L); 538. } 539. 540. int 541. is_demon(ptr) struct permonst *ptr; { 542. return((ptr->mflags2 & M2_DEMON) != 0L); 543. } 544. 545. int 546. is_mercenary(ptr) struct permonst *ptr; { 547. return((ptr->mflags2 & M2_MERC) != 0L); 548. } 549. 550. int 551. throws_rocks(ptr) struct permonst *ptr; { 552. return((ptr->mflags2 & M2_ROCKTHROW) != 0L); 553. } 554. 555. int 556. is_wanderer(ptr) struct permonst *ptr; { 557. return((ptr->mflags2 & M2_WANDER) != 0L); 558. } 559. 560. int 561. is_lord(ptr) struct permonst *ptr; { 562. return((ptr->mflags1 & M1_LORD) != 0L); 563. } 564. 565. int 566. is_prince(ptr) struct permonst *ptr; { 567. return((ptr->mflags1 & M1_PRINCE) != 0L); 568. } 569. 570. # ifdef HARD 571. int 572. is_ndemon(ptr) struct permonst *ptr; { 573. return(is_demon(ptr) && 574. (ptr->mflags1 & (M1_LORD | M1_PRINCE)) == 0L); 575. } 576. # else /* HARD */ 577. int 578. is_ndemon(ptr) struct permonst *ptr; { 579. return(ptr == &mons[PM_DEMON]); 580. } 581. # endif /* HARD */ 582. 583. int 584. is_dlord(ptr) struct permonst *ptr; { 585. return(is_demon(ptr) && is_lord(ptr)); 586. } 587. 588. int 589. is_dprince(ptr) struct permonst *ptr; { 590. return(is_demon(ptr) && is_prince(ptr)); 591. } 592. 593. int 594. type_is_pname(ptr) struct permonst *ptr; { 595. return((ptr->mflags2 & M2_PNAME) != 0L); 596. } 597. 598. int 599. always_hostile(ptr) struct permonst *ptr; { 600. return((ptr->mflags2 & M2_HOSTILE) != 0L); 601. } 602. 603. int 604. always_peaceful(ptr) struct permonst *ptr; { 605. return((ptr->mflags2 & M2_PEACEFUL) != 0L); 606. } 607. 608. int 609. strongmonst(ptr) struct permonst *ptr; { 610. return((ptr->mflags2 & M2_STRONG) != 0L); 611. } 612. 613. int 614. extra_nasty(ptr) struct permonst *ptr; { 615. return((ptr->mflags2 & M2_NASTY) != 0L); 616. } 617. 618. # ifdef POLYSELF 619. int 620. can_breathe(ptr) struct permonst *ptr; { 621. return(attacktype(ptr, AT_BREA)); 622. } 623. 624. int 625. cantwield(ptr) struct permonst *ptr; { 626. return(nohands(ptr) || verysmall(ptr)); 627. } 628. 629. int 630. cantweararm(ptr) struct permonst *ptr; { 631. return(breakarm(ptr) || sliparm(ptr)); 632. } 633. 634. int 635. nolimbs(ptr) struct permonst *ptr; { 636. return((ptr->mflags2 & M2_NOLIMBS) != 0L); 637. } 638. # endif /* POLYSELF */ 639. 640. int 641. carnivorous(ptr) struct permonst *ptr; { 642. return((ptr->mflags2 & M2_CARNIVORE) != 0L); 643. } 644. 645. int 646. herbivorous(ptr) struct permonst *ptr; { 647. return((ptr->mflags2 & M2_HERBIVORE) != 0L); 648. } 649. 650. int 651. thick_skinned(ptr) struct permonst *ptr; { 652. return((ptr->mflags2 & M2_THICK_HIDE) != 0L); 653. } 654. 655. int 656. amorphous(ptr) struct permonst *ptr; { 657. return((ptr->mflags2 & M2_AMORPHOUS) != 0L); 658. } 659. 660. #endif /* STUPID_CPP */
|
![[RDF Data]](/fct/images/sw-rdf-blue.png)