#ifndef __MUDMACROS_H__ 
#define __MUDMACROS_H__ 

#include "macros.h"

#define A_COMMAND(x)		void x(void)

#define is_in_game(C)           ((C) >= 0 && (C) < numchars \
				 && !EMPTY(pname(C)) && ploc(C) < 0 \
				 && ((C) >= max_players || players[C].iamon))

#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")

#define phandler(C)             players[C].inp_handler->inp_handler

#define amud(C)			players[C].amud
#define atarget(C)		players[C].atarget

#ifdef GROUP
#define IN_GROUP(P)		(players[P].party != NULL)
#define P_GROUP(P)              (players[P].party)
#define P_GROUP_LEADER(P)       (players[P].party->leader)
#define P_GROUP_NAME(P)         (players[P].party->name)
#define P_GROUP_SHARES(P)       (players[P].party->shares)
#define P_GROUP_XP(P)           (players[P].party->xp)
#define P_SHARE(P)              (players[P].share)
#define SET_P_SHARE(P,V)        (players[P].share = (V))
#endif

/* Players & Mobiles:
 */
#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)
#ifndef GROUP       /* else its a function in mobile.c */
#define setpscore(C, V)		(pscore(C) = (V))
#endif

#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 xflags(C)               (ublock[C].pxflags)
#define xtstflg(C, V)           tst_octetbit(&xflags(C),(V))
#define xsetflg(C, V)           set_octetbit(&xflags(C),(V))
#define xclrflg(C, V)           clr_octetbit(&xflags(C),(V))

#define setxflags(C,V)          (xflags(C) = (V))
#define xflags_reset(C)         (ublock[C].pxflags_reset)

#define pflags(C)		(ublock[C].pflags)
#define pclrflg(C, V)		clr_doublebit(&pflags(C),(V))
#define psetflg(C, V)		set_doublebit(&pflags(C),(V))
#define ptstflg(C, V)		tst_doublebit(&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)		clr_doublebit(&pmask(C),(V))
#define psetmsk(C, V)		set_doublebit(&pmask(C),(V))
#define ptstmsk(C, V)		tst_doublebit(&pmask(C),(V))
#define setpmask(C, V)		(pmask(C) = (V))
#define setpmsk1(C, V)		(pmask(C).b1 = (V))
#define setpmsk2(C, V)		(pmask(C).b2 = (V))
#define setpmsk3(C, V)		(pmask(C).b3 = (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_doublebit(&sflags(C),(V))
#define ssetflg(C, V)           set_doublebit(&sflags(C),(V))
#define ststflg(C, V)           tst_doublebit(&sflags(C),(V))

#define setsflags(C, V)		(sflags(C) = (V))
#define sflags_reset(C)		(ublock[C].psflags_reset)

#define qflags(C)		(ublock[C].pquests)
#define qclrflg(C, V)		clr_bit(&qflags(C),(V))
#define qsetflg(C, V)		set_bit(&qflags(C),(V))
#define qtstflg(C, V)		tst_bit(&qflags(C),(V))
#define qpoints(C)		(ublock[C].pquestpoints)
#define addqpoints(C,F)		(ublock[C].pquestpoints += QuestPoints[F]);
#define subqpoints(C,F)		(ublock[C].pquestpoints -= QuestPoints[F]);

#define psex(C)			tst_doublebit(&sflags(C),0)
#define pvis(C)			(ublock[C].pvis)
#define setpvis(C, V)		(pvis(C) = (V))
#define pvis_reset(C)		(ublock[C].pvis_reset)
#define pdrunk(C)		(players[C].me_drunkct)
#define setpdrunk(C,V)		(pdrunk(C) = (V))

#define pstr(C)			(ublock[C].pstr)
#define pmaxstrength(L)		(50 + 6*(L))
#define setpstr(C, V)		(pstr(C) = (V))
#define pstr_reset(C)		(ublock[C].pstr_reset)

#define ploc(C)			(ublock[C].ploc)
/* setploc() is now a function */
#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 pemail(C)		(players[C].email)

#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 ptemporary(C)           ublock[C].temporary
#define pzone(C)                ublock[C].zone
#define mob_id(C)               ublock[C].id
#define ppermanent(C)           ((C) < num_const_chars)
#define plast_cmd(C)            (players[C].last_cmd)
#define plogged_on(C)           (players[C].logged_on)
#define powner(C)               zname(pzone(C))

#define pinv(C)                 (&ublock[C].objects)
#define pfirst_obj(C)           first_int(pinv(C))
#define pnext_obj(C)            next_int(pinv(C))
#define pnumobs(C)              set_size(pinv(C))
#define pobj_nr(N, C)           int_number((N), pinv(C))

#define ppager(C)		(players[C].pager.len)
#define setppager(C, V)		(ppager(C) = (V))

#define up_pkilled(C)           (ublock[C].pkilled++)
#define up_pdied(C)             (ublock[C].pdied++)
#define setpkilled(C,V)         (ublock[C].pkilled = (V))
#define pkilled(C)              (ublock[C].pkilled)
#define pdied(C)		(ublock[C].pdied)
#define setpdied(C,V)           (ublock[C].pdied = (V))

#define pcorpsecount(C)		(ublock[C].corpse_ct)
#define pftxt_reset(C)		(ublock[C].pftxt_reset)
#define pexam_reset(C)		(ublock[C].pexam_reset)

/* 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 lclrflg(L, V)		clr_doublebit(&xlflags(L),(V))
#define lsetflg(L, V)           set_doublebit(&xlflags(L),(V))
#define ltstflg(L, V)           tst_doublebit(&xlflags(L),(V))
/* Masking and shifting only happens on the first long of the DoubleLongInt */
/*#define lmaskflg(L, V)          (xlflags(L).b1 & (V))
#define llslflg(L, V)           ((V) << (V))
#define llsrflg(L, V)           ((V) >> (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 ltemporary(L)           room_data[convroom(L)].temporary
#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 lfirst_obj(C)           first_int(linv(C))
#define lnext_obj(C)            next_int(linv(C))
#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 lfirst_mob(C)           first_int(lmobs(C))
#define lnext_mob(C)            next_int(lmobs(C))
#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_doublebit(&obits(O),(V))
#define oclrbit(O, V)		clr_doublebit(&obits(O),(V))
#define osetbit(O, V)		set_doublebit(&obits(O),(V))

#define oloc(O)			objects[O].oloc
#define oloc_reset(O)		objects[O].oloc_reset
/* setoloc() is a function. */

#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 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 ofirst_obj(C)           first_int(oinv(C))
#define onext_obj(C)            next_int(oinv(C))
#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 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 zstartloc(Z)		zoname[Z].startloc

#define ztemporary(Z)           zoname[Z].temporary
#define zpermanent(Z)           ((Z) >= 0 && (Z) < num_const_zon)

#define zfirst_obj(C)           first_int(zobjs(C))
#define znext_obj(C)            next_int(zobjs(C))

#define zfirst_mob(C)           first_int(zmobs(C))
#define znext_mob(C)            next_int(zmobs(C))

#define zfirst_loc(C)           first_int(zlocs(C))
#define znext_loc(C)            next_int(zlocs(C))

#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 first_obj(C)            first_int(C)
#define next_obj(C)             next_int(C)
#define first_mob(C)            first_int(C)
#define next_mob(C)             next_int(C)
#define first_loc(C)            first_int(C)
#define next_loc(C)             next_int(C)

#endif /* Add nothing past this line... */