#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