#ifndef _MUDMACROS_H #define _MUDMACROS_H #include "macros.h" #define fpbn(C) find_mob(False, C) #define fmbn(C) find_mob(True, C) #define fobn(obname) findob(mynum, obname, ALL, -1) #define objcont(plr, item, obname) findob(plr, obname, CONT, item) #define objinv(plr, obname) findob(plr, obname, INV, -1) #define objloc(plr, obname) findob(plr, obname, LOC, -1) #define is_host_banned(x) infile(BAN_HOSTS, x) #define is_host_who_banned(x) infile(BAN_WHOS, x) #define is_host_username_banned(x) infile(BAN_ACCTS, x) #define is_host_silent(x) infile(SILENT_LOGIN, x) #define is_player_banned(x) infile(BAN_CHARS, x) #define is_illegal_name(x) infile(ILLEGAL_FILE, x) #define privileged_user(x) infile(PRIVED_FILE, x) #define is_plr_monitored(x) infile(MONITOR_CHAR, x) #define is_host_monitored(x) infile(MONITOR_HOST, x) #define is_in_game(C) ((C) >= 0 && (C) < numchars \ && !EMPTY(pname(C)) && ploc(C) < 0 \ && ((C) >= max_players || players[C].iamon)) #define is_conn(C) players[C].is_conn #define is_ban(C) players[C].host_ban #define is_userban(C) players[C].user_ban #define ident(C) players[C].ident #define resolved(C) players[C].resolved #define his_or_her(C) (psex(C) ? "her" : "his") #define him_or_her(C) (psex(C) ? "her" : "him") #define he_or_she(C) (psex(C) ? "She" : "He") /* Players and Mobiles */ #define pfirst_obj(C) first_int(pinv(C)) #define lfirst_obj(C) first_int(linv(C)) #define lfirst_mob(C) first_int(lmobs(C)) #define ofirst_obj(C) first_int(oinv(C)) #define zfirst_obj(C) first_int(zobjs(C)) #define zfirst_mob(C) first_int(zmobs(C)) #define zfirst_loc(C) first_int(zlocs(C)) #define first_obj(C) first_int(C) #define first_mob(C) first_int(C) #define first_loc(C) first_int(C) #define ishere(C) p_ishere(mynum, C) #define dumpitems() dumpstuff(mynum, ploc(mynum)) #define create(C) oclrbit(C, OFL_DESTROYED) #define is_classname(C) (C != NULL && findclass(C) != NULL) #define needsquests(C) rplrs[C].needsquests #define iswieldby(C, V) (ocarrf(C) >= WIELDED_BY && iscarrby(C, V)) #define iswornby(C, V) (isworn(C) && iscarrby(C, V)) #define isavl(C) (ishere(C) && iscarrby(C, mynum)) #define listobject(C, V) aobjsat(C, V, 0) #define mlobjsat(C, V) aobjsat(C, CARRIED_BY, V) #define testpeace(C) (the_world->w_peace || \ ltstflg(ploc(C), LFL_PEACEFUL)) #define is_grouped(C) ((C < max_players && is_in_game(C)) ? \ pgrouped(C) : -1) #define prndsinroom(C) rplrs[C].rounds_in_room #define setprndsinroom(C, V) (prndsinroom(C) = (V)) #define pawaymsg(C) players[C].awaymsg #define pcarry(C) players[C].pcarry #define setpcarry(C, V) (pcarry(C) = (V)) #define pangry(C) ublock[C].angry #define atarget(C) rplrs[C].atarget #define amud(C) rplrs[C].amud #define ftimer(C) ublock[C].ftimer #define setpangry(C, V) (pangry(C) = (V)) #define pcoins(C) players[C].coins #define pclass(C) ublock[C].class #define pgrouped(C) rplrs[C].grouped #define setpclass(C, V) (pclass(C) = (V)) #define pac(C) ublock[C].pac #define eqbits(C, V) (C.l == V.l && C.h == V.h) #define username(C) rplrs[C].usrname #define hostname(C) rplrs[C].hostname #define snooped(C) rplrs[C].snooped #define snooptarget(C) rplrs[C].snooptarget #define fildes(C) rplrs[C].fil_des #define linkdead(C) rplrs[C].linkdead #define ip_addr(C) rplrs[C].ip_addr #define port(C) rplrs[C].port #define os(C) rplrs[C].os #define keyboard(C) rplrs[C].keyb #define pretend(C) rplrs[C].pretend #define isawiz(C) rplrs[C].isawiz #define pretend(C) rplrs[C].pretend #define polymorphed(C) rplrs[C].polymorphed #define aliased(C) rplrs[C].aliased #define aliasto(C) rplrs[C].aliasto #define ivct(C) rplrs[C].me_ivct #define wd_him(C) rplrs[C].wd_him #define wd_her(C) rplrs[C].wd_her #define wd_it(C) rplrs[C].wd_it #define newplr(C) rplrs[C].newplr #define ismonitored(C) rplrs[C].ismonitored #define oldscore(C) rplrs[C].oldscore #define last_cmd(C) rplrs[C].last_cmd #define logged_on(C) rplrs[C].logged_on #define rlast_cmd(C) rplrs[C].rlast_cmd #define plastcom(C) rplrs[C].prev_com #define replyplr(C) rplrs[C].replyplr #define wd_them(C) players[C].wd_them #define hasquit(C) players[C].hasquit #define in_cmd(C) players[C].in_cmd #define resfd(C) players[C].resfd #define dnsfd(C) players[C].dnsfd #define limbo(C) players[C].limbo #define newuaf(X) save_load_plr(X, (X)->ublock.pname, True, True) #define putuaf(X) save_load_plr(X, (X)->ublock.pname, True, False) #define getuaf(X, Y) save_load_plr(Y, X, False, False) #define inp_handler(C) iplrs[C].inp_handler #define inp_buffer(C) iplrs[C].inp_buffer #define output(C) iplrs[C].output #define out_size(C) iplrs[C].out_size #define inp_ptr(C) iplrs[C].inp_ptr #define ignore_input(C) iplrs[C].ignore_input #define out_buffer(C) iplrs[C].out_buffer #define out_write(C) iplrs[C].out_write #define out_read(C) iplrs[C].out_read /* these are to help debugging by allowing you to list open fd's in-mud */ #ifndef GENERATE #ifdef DEBUG_IO #define FOPEN(C, V) __mfopen(__FILE__, __LINE__, C, V) #define OPEN(C, V, Z) __mopen(__FILE__, __LINE__, C, V, Z) #define CLOSE(C) __mclose(C) #define FCLOSE(C) __mfclose(C) extern FILE *__mfopen(char *, int, char *, char *); extern void __mfclose(FILE *); extern int __mopen(char *, int, char *, int, mode_t); extern void __mclose(int); #else #define FOPEN(C, V) fopen(C, V) #define OPEN(C, V, Z) open(C, V, Z) #define CLOSE(C) close(C) #define FCLOSE(C) fclose(C) #endif #endif #define abits(O) (objects[O].aflags) #define abits_reset(O) (objects[O].aflags_reset) #define atstbit(O, V) xtstbit(abits(O), (V)) #define asetbit(O, V) xsetbit(abits(O), (V)) #define aclrbit(O, V) xclrbit(abits(O), (V)) #define is_head(C) atstbit(C, AFL_HEAD) #define is_foot(C) atstbit(C, AFL_FOOT) #define is_feet(C) atstbit(C, AFL_FEET) #define is_hand(C) atstbit(C, AFL_HAND) #define is_hands(C) atstbit(C, AFL_HANDS) #define is_face(C) atstbit(C, AFL_FACE) #define is_back(C) atstbit(C, AFL_BACK) #define is_arm(C) atstbit(C, AFL_ARM) #define is_arms(C) atstbit(C, AFL_ARMS) #define is_leg(C) atstbit(C, AFL_LEG) #define is_legs(C) atstbit(C, AFL_LEGS) #define is_chest(C) atstbit(C, AFL_CHEST) #define is_neck(C) atstbit(C, AFL_NECK) #define head(C) ublock[C].body.head #define r_arm(C) ublock[C].body.r_arm #define l_arm(C) ublock[C].body.l_arm #define r_leg(C) ublock[C].body.r_leg #define l_leg(C) ublock[C].body.l_leg #define r_foot(C) ublock[C].body.r_foot #define l_foot(C) ublock[C].body.l_foot #define r_hand(C) ublock[C].body.r_hand #define l_hand(C) ublock[C].body.l_hand #define chest(C) ublock[C].body.chest #define back(C) ublock[C].body.back #define face(C) ublock[C].body.face #define neck(C) ublock[C].body.neck #define armor(D) (D).armor #define bodyname(D) (D).name #define vital(D) (D).vital #define loc(D) (D).loc #define attached(D) (D).attach #define hasarmr(D) ((D)->armor != -1) #define wears_head(C) (armor(head(C)) != -1) #define wears_chest(C) (armor(chest(C)) != -1) #define wears_back(C) (armor(back(C)) != -1) #define wears_face(C) (armor(face(C)) != -1) #define wears_neck(C) (armor(neck(C)) != -1) #define wears_rfoot(C) (armor(r_foot(C)) != -1) #define wears_lfoot(C) (armor(l_foot(C)) != -1) #define wears_feet(C) (wears_rfoot(C) && wears_lfoot(C)) #define wears_rhand(C) (armor(r_hand(C)) != -1) #define wears_lhand(C) (armor(l_hand(C)) != -1) #define wears_hands(C) (wears_rhand(C) && wears_lhand(C)) #define wears_rleg(C) (armor(r_leg(C)) != -1) #define wears_lleg(C) (armor(l_leg(C)) != -1) #define wears_legs(C) (wears_rleg(C) && wears_lleg(C)) #define wears_rarm(C) (armor(r_arm(C)) != -1) #define wears_larm(C) (armor(l_arm(C)) != -1) #define wears_arms(C) (wears_rarm(C) && wears_larm(C)) #define pagg(C) ublock[C].pagg #define setpagg(C, V) (pagg(C) = (V)) #define pagg_reset(C) ublock[C].pagg_reset #define pspeed(C) ublock[C].pspeed #define setpspeed(C, V) (pspeed(C) = (V)) #define pspeed_reset(C) ublock[C].pspeed_reset #define pdam(C) ublock[C].pdam #define setpdam(C, V) (pdam(C) = (V)) #define pdam_reset(C) ublock[C].pdam_reset #define parmor(C) ublock[C].parmor #define setparmor(C, V) (parmor(C) = (V)) #define parmor_reset(C) ublock[C].parmor_reset #define pscore(C) (ublock[C].pscore) #define setpscore(C, V) (pscore(C) = (V)) #define pfighting(C) (ublock[C].pfighting) #define phelping(C) (ublock[C].phelping) #define setphelping(C, V) (phelping(C) = (V)) #define psitting(C) (ublock[C].psitting) #define setpsitting(C, V) (psitting(C) = (V)) #define pwpn(C) (ublock[C].pweapon) #define setpwpn(C, V) (pwpn(C) = (V)) #define plev(C) (ublock[C].plev) #define setplev(C, V) (plev(C) = (V)) #define plev_reset(C) (ublock[C].plev_reset) #define pmobile(C) ((C) >= max_players) #define pftxt(C) (ublock[C].pftxt) #define pexam(C) (ublock[C].p_exam) #define pflags(C) (ublock[C].pflags) #define pclrflg(C, V) dclr_bit(&pflags(C),(V)) #define psetflg(C, V) dset_bit(&pflags(C),(V)) #define ptstflg(C, V) dtst_bit(&pflags(C),(V)) #define setpflags(C, V) (pflags(C) = (V)) #define setpflgh(C, V) (pflags(C).h = (V)) #define setpflgl(C, V) (pflags(C).l = (V)) #define pflags_reset(C) (ublock[C].pflags_reset) #define pmask(C) (ublock[C].pmask) #define pclrmsk(C, V) dclr_bit(&pmask(C),(V)) #define psetmsk(C, V) dset_bit(&pmask(C),(V)) #define ptstmsk(C, V) dtst_bit(&pmask(C),(V)) #define setpmask(C, V) (pmask(C) = (V)) #define setpmskh(C, V) (pmask(C).h = (V)) #define setpmskl(C, V) (pmask(C).l = (V)) #define mflags(C) (ublock[C].pmflags) #define mclrflg(C, V) clr_bit(&mflags(C),(V)) #define msetflg(C, V) set_bit(&mflags(C),(V)) #define mtstflg(C, V) tst_bit(&mflags(C),(V)) #define setmflags(C, V) (mflags(C) = (V)) #define setmflgh(C, V) (mflags(C).h = (V)) #define setmflgl(C, V) (mflags(C).l = (V)) #define mflags_reset(C) (ublock[C].pmflags_reset) #define sflags(C) (ublock[C].psflags) #define sclrflg(C, V) clr_bit(&sflags(C),(V)) #define ssetflg(C, V) set_bit(&sflags(C),(V)) #define ststflg(C, V) tst_bit(&sflags(C),(V)) #define setsflags(C, V) (sflags(C) = (V)) #define setsflgh(C, V) (sflags(C).h = (V)) #define setsflgl(C, V) (sflags(C).l = (V)) #define sflags_reset(C) (ublock[C].psflags_reset) #define nflags(C) (ublock[C].pnflags) #define nclrflg(C, V) xclrbit(nflags(C),(V)) #define nsetflg(C, V) xsetbit(nflags(C),(V)) #define ntstflg(C, V) xtstbit(nflags(C),(V)) #define setnflags(C, V) (nflags(C) = (V)) #define nflags_reset(C) (ublock[C].pnflags_reset) #define eflags(C) (ublock[C].peflags) #define eclrflg(C, V) clr_bit(&eflags(C),(V)) #define esetflg(C, V) set_bit(&eflags(C),(V)) #define etstflg(C, V) tst_bit(&eflags(C),(V)) #define seteflags(C, V) (eflags(C) = (V)) #define eflags_reset(C) (ublock[C].peflags_reset) #define plang(C) ublock[C].planguage #define setplang(C, V) (plang(C) = (V)) #define is_eng(C) (plang(C) == NFL_ENGLISH) #define qflags(C) (players[C].pquests) #define qclrflg(C, V) xclrbit(qflags(C),(V)) #define qsetflg(C, V) xsetbit(qflags(C),(V)) #define qtstflg(C, V) xtstbit(qflags(C),(V)) #define setqflags(C, V) (qflags(C) = (V)) #define qdclrflg(C) xclrbit(qdone, (C)) #define qdsetflg(C) xsetbit(qdone, (C)) #define qdtstflg(C) xtstbit(qdone, (C)) #define setqdflags(C) (qdone = (C)) #define psex(C) bits(sflags(C).l,1) #define player_level(C) levnam(plev(C), pclass(C), psex(C)) #define pvis(C) (ublock[C].pvis) #define setpvis(C, V) (pvis(C) = (V)) #define pvis_reset(C) (ublock[C].pvis_reset) #define pstr(C) (ublock[C].pstr) #define pmaxstrength(L) (67 + 8 * (L)) #define maxstrength(P) pmaxstrength(plev(P)) #define setpstr(C, V) (pstr(C) = (V)) #define pstr_reset(C) (ublock[C].pstr_reset) #define ploc(C) (ublock[C].ploc) #define ploc_reset(C) (ublock[C].ploc_reset) #define phome(C) (ublock[C].phome) #define setphome(C, V) (phome(C) = (V)) #define pname(C) (ublock[C].pname) #define setpname(C, V) (strcpy(pname(C), (V))) #define pname_reset(C) (ublock[C].pname_reset) #define ptitle(C) players[C].ptitle #define setptitle(C, V) (strcpy(ptitle(C), (V))) #define pwimpy(C) ublock[C].pwimpy #define pwimpy_reset(C) ublock[C].pwimpy_reset #define setpwimpy(C, V) (pwimpy(C) = (V)) #define pnum(C) ublock[C].pnum #define pzone(C) ublock[C].zone #define mob_id(C) ublock[C].id #define ppermanent(C) ((C) < num_const_chars) #define plast_cmd(C) (rplrs[C].last_cmd) #define prlast_cmd(C) (rplrs[C].rlast_cmd) #define plogged_on(C) (rplrs[C].logged_on) #define powner(C) zname(pzone(C)) #define pinv(C) (&ublock[C].objects) #define pnumobs(C) set_size(pinv(C)) #define pobj_nr(N, C) int_number((N), pinv(C)) #define pkilled(C) (players[C].pkilled) #define setpkilled(C, V) (pkilled(C) = (V)) #define pdied(C) (players[C].pdied) #define setpdied(C, V) (pdied(C) = (V)) #define pchannel(C) (players[C].pchannel) #define setpchannel(C, V) (pchannel(C) = (V)) #define pmagic(C) (players[C].pmagic) #define pmaxmagic(L) (12 + 3*(L)) #define maxmagic(P) (((pclass(P) == MAGE) || (pclass(P) ==PRIEST)) \ ? pmaxmagic(plev(P)) : 0) #define setpmagic(C, V) (pmagic(C) = (V)) #define pspeech(C, V) ublock[C].pspeech[V] #define setpspeech(C, V, L) (strcpy(pspeech(C, V), (L))) #define pchance(C) ublock[C].pchance #define setpchance(C, V) (pchance(C) = (V)) #define phandler(C) iplrs[C].inp_handler->inp_handler #define pconv(C) rplrs[C].pconverse #define setpconv(C, V) (pconv(C) = (V)) #define ppager(C) (players[C].pager.len) #define setppager(C, V) (ppager(C) = (V)) #define islogged(C) rplrs[C].logged #define pfollow(C) rplrs[C].i_follow /* Locations */ #define convroom(L) (-(L)-1) #define lpermanent(L) ((L) > convroom(num_const_locs)) #define xlflags(L) room_data[convroom(L)].r_flags #define xlflags_reset(L) room_data[convroom(L)].r_flags_reset #define laltitude(L) room_data[convroom(L)].r_altitude #define laltitude_reset(L) room_data[convroom(L)].r_altitude_reset #define lclrflg(L, V) clr_bit(&xlflags(L),(V)) #define lsetflg(L, V) set_bit(&xlflags(L),(V)) #define ltstflg(L, V) tst_bit(&xlflags(L),(V)) #define loc_id(L) room_data[convroom(L)].id #define lexit(L, E) room_data[convroom(L)].r_exit[E] #define lexit_reset(L, E) room_data[convroom(L)].r_exit_reset[E] #define lshort(L) room_data[convroom(L)].r_short #define llong(L) room_data[convroom(L)].r_long #define lowner(L) zname(lzone(L)) #define lexits_to_me(L) (&room_data[convroom(L)].exits_to_me) #define ltouched(L) (room_data[convroom(L)].touched) #define lzone(L) (room_data[convroom(L)].zone) #define linv(L) (&room_data[convroom(L)].objects) #define lnumobs(C) set_size(linv(C)) #define lobj_nr(N, L) int_number((N), linv(L)) #define lmobs(L) (&room_data[convroom(L)].mobiles) #define lnumchars(C) set_size(lmobs(C)) #define lmob_nr(N, L) int_number((N), lmobs(L)) /* Objects */ #define oarmor(O) objects[O].oarmor #define oarmor_reset(O) objects[O].oarmor_reset #define odamage(O) objects[O].odamage #define odamage_reset(O) objects[O].odamage_reset #define osetarmor(O,V) (oarmor(O) = (V)) #define osetdamage(O,V) (odamage(O) = (V)) #define ovis(O) (objects[O].ovis) #define osetvis(O, V) (ovis(O) = (V)) #define ovis_reset(O) (objects[O].ovis_reset) #define obits(O) (objects[O].oflags) #define obits_reset(O) (objects[O].oflags_reset) #define otstbit(O, V) tst_bit(&obits(O),(V)) #define oclrbit(O, V) clr_bit(&obits(O),(V)) #define osetbit(O, V) set_bit(&obits(O),(V)) #define wbits(O) (objects[O].wflags) #define wbits_reset(O) (objects[O].wflags_reset) #define wtstbit(O, V) xtstbit(wbits(O),(V)) #define wclrbit(O, V) xclrbit(wbits(O),(V)) #define wsetbit(O, V) xsetbit(wbits(O),(V)) #define oloc(O) objects[O].oloc #define oloc_reset(O) objects[O].oloc_reset #define state(O) objects[O].ostate #define state_reset(O) objects[O].ostate_reset #define ocarrf(O) objects[O].ocarrf #define ocarrf_reset(O) objects[O].ocarrf_reset #define setcarrf(O,C) (ocarrf(O) = (C)) #define olongt(O, V) (objects[O].odesc[V]) #define omaxstate(O) (objects[O].omaxstate) #define oaltname(O) (objects[O].oaltname) #define osize(O) (objects[O].osize) #define osize_reset(O) (objects[O].osize_reset) #define oweight(O) (objects[O].oweight) #define oweight_reset(O) (objects[O].oweight_reset) #define osetsize(O, V) (osize(O) = (V)) #define oflannel(O) otstbit(O,OFL_NOGET) #define obaseval(O) (objects[O].ovalue) #define ovalue_reset(O) (objects[O].ovalue_reset) #define osetbaseval(O, V) (obaseval(O) = (V)) #define oname(O) objects[O].oname #define ospare(O) (otstbit(O, OFL_DESTROYED) ? -1 : 0) #define oexamine(O) objects[O].oexamine #define oexam_text(O) objects[O].oexam_text #define opermanent(O) ((O) < num_const_obs) #define otemporary(O) objects[O].temporary #define olinked(O) objects[O].linked #define ozone(O) objects[O].zone #define oowner(O) zname(ozone(O)) #define obj_id(O) objects[O].id #define onum(O) objects[O].onum #define oinv(C) (&objects[C].objects) #define onumobs(C) set_size(oinv(C)) #define oobj_nr(N, C) int_number((N), oinv(C)) /* Zones */ #define zname(Z) zoname[Z].z_name #define zlatitude(Z) zoname[Z].latitude #define zrainfall(Z) zoname[Z].rainfall #define zmaxlocs(Z) zoname[Z].maxlocs #define zmaxmobs(Z) zoname[Z].maxmobs #define zmaxobjs(Z) zoname[Z].maxobjs #define zlocs(Z) &zoname[Z].locations #define zmobs(Z) &zoname[Z].mobiles #define zobjs(Z) &zoname[Z].objects #define ztemporary(Z) zoname[Z].temporary #define zpermanent(Z) ((Z) >= 0 && (Z) < num_const_zon) #define zadd_obj(O, Z) add_int((O), zobjs(Z)) #define zadd_mob(O, Z) add_int((O), zmobs(Z)) #define zadd_loc(O, Z) add_int((O), zlocs(Z)) #define zremove_obj(O, Z) remove_int((O), zobjs(Z)) #define zremove_mob(O, Z) remove_int((O), zmobs(Z)) #define zremove_loc(O, Z) remove_int((O), zlocs(Z)) #define znumobs(O) set_size(zobjs(O)) #define znumloc(O) set_size(zlocs(O)) #define znumchars(O) set_size(zmobs(O)) #define zobj_nr(N, Z) int_number((N), zobjs(Z)) #define zmob_nr(N, Z) int_number((N), zmobs(Z)) #define zloc_nr(N, Z) int_number((N), zlocs(Z)) /* General */ #define randperc() rand() % 100 #endif