void medit_setup_new(struct descriptor_data *d)
{
struct char_data *mob;
/*
* Allocate a scratch mobile structure.
*/
CREATE(mob, struct char_data, 1);
init_mobile(mob);
GET_MOB_RNUM(mob) = -1;
/*
* Set up some default strings.
*/
GET_ALIAS(mob) = str_dup("mob unfinished");
GET_SDESC(mob) = str_dup("the unfinished mob");
GET_LDESC(mob) = str_dup("An unfinished mob stands here.\r\n");
GET_DDESC(mob) = str_dup("It looks unfinished.\r\n");
#if CONFIG_OASIS_MPROG
OLC_MPROGL(d) = NULL;
OLC_MPROG(d) = NULL;
#endif
OLC_MOB(d) = mob;
/* Has changed flag. (It hasn't so far, we just made it.) */
OLC_VAL(d) = FALSE;
medit_disp_menu(d);
}
void medit_setup_existing(struct descriptor_data *d, int rmob_num)
{
struct char_data *mob;
#if defined(OASIS_MPROG)
MPROG_DATA *temp;
MPROG_DATA *head;
#endif
/*
* Allocate a scratch mobile structure.
*/
CREATE(mob, struct char_data, 1);
copy_mobile(mob, mob_proto + rmob_num);
#if defined(OASIS_MPROG)
/*
* I think there needs to be a brace from the if statement to the #endif
* according to the way the original patch was indented. If this crashes,
* try it with the braces and report to [email protected] on if that works.
*/
if (GET_MPROG(mob))
CREATE(OLC_MPROGL(d), MPROG_DATA, 1);
head = OLC_MPROGL(d);
for (temp = GET_MPROG(mob); temp;temp = temp->next) {
OLC_MPROGL(d)->type = temp->type;
OLC_MPROGL(d)->arglist = str_dup(temp->arglist);
OLC_MPROGL(d)->comlist = str_dup(temp->comlist);
if (temp->next) {
CREATE(OLC_MPROGL(d)->next, MPROG_DATA, 1);
OLC_MPROGL(d) = OLC_MPROGL(d)->next;
}
}
OLC_MPROGL(d) = head;
OLC_MPROG(d) = OLC_MPROGL(d);
#endif
OLC_MOB(d) = mob;
OLC_ITEM_TYPE(d) = MOB_TRIGGER;
dg_olc_script_copy(d);
medit_disp_menu(d);
}
void medit_setup_existing(struct descriptor_data *d, int rmob_num)
{
struct char_data *mob;
/*
* Allocate a scratch mobile structure.
*/
CREATE(mob, struct char_data, 1);
copy_mobile(mob, mob_proto + rmob_num);
#if CONFIG_OASIS_MPROG
{
MPROG_DATA *temp;
MPROG_DATA *head;
if (GET_MPROG(mob))
CREATE(OLC_MPROGL(d), MPROG_DATA, 1);
head = OLC_MPROGL(d);
for (temp = GET_MPROG(mob); temp; temp = temp->next) {
OLC_MPROGL(d)->type = temp->type;
OLC_MPROGL(d)->arglist = str_dup(temp->arglist);
OLC_MPROGL(d)->comlist = str_dup(temp->comlist);
if (temp->next) {
CREATE(OLC_MPROGL(d)->next, MPROG_DATA, 1);
OLC_MPROGL(d) = OLC_MPROGL(d)->next;
}
}
OLC_MPROGL(d) = head;
OLC_MPROG(d) = OLC_MPROGL(d);
}
#endif
OLC_MOB(d) = mob;
medit_disp_menu(d);
}
/*
* Display the MobProgs.
*/
void medit_disp_mprog(struct descriptor_data *d)
{
struct mob_prog_data *mprog = OLC_MPROGL(d);
OLC_MTOTAL(d) = 1;
clear_screen(d);
while (mprog) {
sprintf(buf, "%d) %s %s\r\n", OLC_MTOTAL(d), medit_get_mprog_type(mprog),
(mprog->arglist ? mprog->arglist : "NONE"));
SEND_TO_Q(buf, d);
OLC_MTOTAL(d)++;
mprog = mprog->next;
}
sprintf(buf, "%d) Create New Mob Prog\r\n"
"%d) Purge Mob Prog\r\n"
"Enter number to edit [0 to exit]: ",
OLC_MTOTAL(d), OLC_MTOTAL(d) + 1);
SEND_TO_Q(buf, d);
OLC_MODE(d) = MEDIT_MPROG;
}
int add_mobile(struct char_data *mob, mob_vnum vnum)
{
int rnum, i, found = FALSE, shop, cmd_no;
zone_rnum zone;
struct char_data *live_mob;
if ((rnum = real_mobile(vnum)) != NOBODY) {
/* Copy over the mobile and free() the old strings. */
copy_mobile(&mob_proto[rnum], mob);
/* Now re-point all existing mobile strings to here. */
for (live_mob = character_list; live_mob; live_mob = live_mob->next)
if (rnum == live_mob->nr)
update_mobile_strings(live_mob, &mob_proto[rnum]);
add_to_save_list(zone_table[real_zone_by_thing(vnum)].number, SL_MOB);
log("GenOLC: add_mobile: Updated existing mobile #%d.", vnum);
return TRUE;
}
RECREATE(mob_proto, struct char_data, top_of_mobt + 2);
RECREATE(mob_index, struct index_data, top_of_mobt + 2);
top_of_mobt++;
for (i = top_of_mobt; i > 0; i--) {
if (vnum > mob_index[i - 1].vnum) {
mob_proto[i] = *mob;
mob_proto[i].nr = i;
copy_mobile_strings(mob_proto + i, mob);
mob_index[i].vnum = vnum;
mob_index[i].number = 0;
mob_index[i].func = 0;
found = i;
break;
}
mob_index[i] = mob_index[i - 1];
mob_proto[i] = mob_proto[i - 1];
mob_proto[i].nr++;
}
if (!found) {
mob_proto[0] = *mob;
mob_proto[0].nr = 0;
copy_mobile_strings(&mob_proto[0], mob);
mob_index[0].vnum = vnum;
mob_index[0].number = 0;
mob_index[0].func = 0;
}
log("GenOLC: add_mobile: Added mobile %d at index #%d.", vnum, found);
#if CONFIG_GENOLC_MOBPROG
GET_MPROG(OLC_MOB(d)) = OLC_MPROGL(d);
GET_MPROG_TYPE(OLC_MOB(d)) = (OLC_MPROGL(d) ? OLC_MPROGL(d)->type : 0);
while (OLC_MPROGL(d)) {
GET_MPROG_TYPE(OLC_MOB(d)) |= OLC_MPROGL(d)->type;
OLC_MPROGL(d) = OLC_MPROGL(d)->next;
}
#endif
/*
* Update live mobile rnums.
*/
for (live_mob = character_list; live_mob; live_mob = live_mob->next)
GET_MOB_RNUM(live_mob) += (GET_MOB_RNUM(live_mob) >= found);
/*
* Update zone table.
*/
for (zone = 0; zone <= top_of_zone_table; zone++)
for (cmd_no = 0; ZCMD(zone, cmd_no).command != 'S'; cmd_no++)
if (ZCMD(zone, cmd_no).command == 'M')
ZCMD(zone, cmd_no).arg1 += (ZCMD(zone, cmd_no).arg1 >= found);
/*
* Update shop keepers.
*/
if (shop_index)
for (shop = 0; shop <= top_shop - top_shop_offset; shop++)
SHOP_KEEPER(shop) += (SHOP_KEEPER(shop) >= found);
add_to_save_list(zone_table[real_zone_by_thing(vnum)].number, SL_MOB);
return found;
}
void medit_parse(struct descriptor_data *d, char *arg)
{
int i = -1;
char *oldtext = NULL;
if (OLC_MODE(d) > MEDIT_NUMERICAL_RESPONSE) {
i = atoi(arg);
if (!*arg || (!isdigit(arg[0]) && ((*arg == '-') && !isdigit(arg[1])))) {
SEND_TO_Q("Field must be numerical, try again : ", d);
return;
}
} else { /* String response. */
if (!genolc_checkstring(d, arg))
return;
}
switch (OLC_MODE(d)) {
/*-------------------------------------------------------------------*/
case MEDIT_CONFIRM_SAVESTRING:
/*
* Ensure mob has MOB_ISNPC set or things will go pear shaped.
*/
SET_BIT(MOB_FLAGS(OLC_MOB(d)), MOB_ISNPC);
switch (*arg) {
case 'y':
case 'Y':
/*
* Save the mob in memory and to disk.
*/
SEND_TO_Q("Saving mobile to memory.\r\n", d);
medit_save_internally(d);
sprintf(buf, "OLC: %s edits mob %d", GET_NAME(d->character), OLC_NUM(d));
mudlog(buf, CMP, MAX(LVL_BUILDER, GET_INVIS_LEV(d->character)), TRUE);
/* FALL THROUGH */
case 'n':
case 'N':
cleanup_olc(d, CLEANUP_ALL);
return;
default:
SEND_TO_Q("Invalid choice!\r\n", d);
SEND_TO_Q("Do you wish to save the mobile? : ", d);
return;
}
break;
/*-------------------------------------------------------------------*/
case MEDIT_MAIN_MENU:
i = 0;
switch (*arg) {
case 'q':
case 'Q':
if (OLC_VAL(d)) { /* Anything been changed? */
SEND_TO_Q("Do you wish to save the changes to the mobile? (y//n) : ", d);
OLC_MODE(d) = MEDIT_CONFIRM_SAVESTRING;
} else
cleanup_olc(d, CLEANUP_ALL);
return;
case '1':
OLC_MODE(d) = MEDIT_SEX;
medit_disp_sex(d);
return;
case '2':
OLC_MODE(d) = MEDIT_ALIAS;
i--;
break;
case '3':
OLC_MODE(d) = MEDIT_S_DESC;
i--;
break;
case '4':
OLC_MODE(d) = MEDIT_L_DESC;
i--;
break;
case '5':
OLC_MODE(d) = MEDIT_D_DESC;
send_editor_help(d);
SEND_TO_Q("Enter mob description:\r\n\r\n", d);
if (OLC_MOB(d)->player.description) {
SEND_TO_Q(OLC_MOB(d)->player.description, d);
oldtext = str_dup(OLC_MOB(d)->player.description);
}
string_write(d, &OLC_MOB(d)->player.description, MAX_MOB_DESC, 0, oldtext);
OLC_VAL(d) = 1;
return;
case '6':
OLC_MODE(d) = MEDIT_LEVEL;
i++;
break;
case '7':
OLC_MODE(d) = MEDIT_ALIGNMENT;
i++;
break;
case '8':
OLC_MODE(d) = MEDIT_HITROLL;
i++;
break;
case '9':
OLC_MODE(d) = MEDIT_DAMROLL;
i++;
break;
case 'a':
case 'A':
OLC_MODE(d) = MEDIT_NDD;
i++;
break;
case 'b':
case 'B':
OLC_MODE(d) = MEDIT_SDD;
i++;
break;
case 'c':
case 'C':
OLC_MODE(d) = MEDIT_NUM_HP_DICE;
i++;
break;
case 'd':
case 'D':
OLC_MODE(d) = MEDIT_SIZE_HP_DICE;
i++;
break;
case 'e':
case 'E':
OLC_MODE(d) = MEDIT_ADD_HP;
i++;
break;
case 'f':
case 'F':
OLC_MODE(d) = MEDIT_AC;
i++;
break;
case 'g':
case 'G':
OLC_MODE(d) = MEDIT_EXP;
i++;
break;
case 'h':
case 'H':
OLC_MODE(d) = MEDIT_GOLD;
i++;
break;
case 'i':
case 'I':
OLC_MODE(d) = MEDIT_POS;
medit_disp_positions(d);
return;
case 'j':
case 'J':
OLC_MODE(d) = MEDIT_DEFAULT_POS;
medit_disp_positions(d);
return;
case 'k':
case 'K':
OLC_MODE(d) = MEDIT_ATTACK;
medit_disp_attack_types(d);
return;
case 'l':
case 'L':
OLC_MODE(d) = MEDIT_NPC_FLAGS;
medit_disp_mob_flags(d);
return;
case 'm':
case 'M':
OLC_MODE(d) = MEDIT_AFF_FLAGS;
medit_disp_aff_flags(d);
return;
case 'n':
case 'N':
OLC_MODE(d) = MEDIT_CLASS;
medit_disp_class_flags(d);
return;
case 'r':
case 'R':
OLC_MODE(d) = MEDIT_RACE;
medit_disp_race_flags(d);
return;
case 's':
case 'S':
OLC_MODE(d) = MEDIT_MSIZE;
medit_disp_size_flags(d);
return;
case 'w':
case 'W':
OLC_MODE(d) = MEDIT_WEIGHT;
send_to_char("Please enter the mobiles weight in pounds: ", d->character);
return;
#if CONFIG_OASIS_MPROG
case 'p':
case 'P':
OLC_MODE(d) = MEDIT_MPROG;
medit_disp_mprog(d);
return;
#endif
default:
medit_disp_menu(d);
return;
}
if (i == 0)
break;
else if (i == 1)
SEND_TO_Q("\r\nEnter new value : ", d);
else if (i == -1)
SEND_TO_Q("\r\nEnter new text :\r\n] ", d);
else
SEND_TO_Q("Oops...\r\n", d);
return;
/*-------------------------------------------------------------------*/
case MEDIT_ALIAS:
if (GET_ALIAS(OLC_MOB(d)))
free(GET_ALIAS(OLC_MOB(d)));
GET_ALIAS(OLC_MOB(d)) = str_udup(arg);
break;
/*-------------------------------------------------------------------*/
case MEDIT_S_DESC:
if (GET_SDESC(OLC_MOB(d)))
free(GET_SDESC(OLC_MOB(d)));
GET_SDESC(OLC_MOB(d)) = str_udup(arg);
break;
/*-------------------------------------------------------------------*/
case MEDIT_L_DESC:
if (GET_LDESC(OLC_MOB(d)))
free(GET_LDESC(OLC_MOB(d)));
if (arg && *arg) {
strcpy(buf, arg);
strcat(buf, "\r\n");
GET_LDESC(OLC_MOB(d)) = str_dup(buf);
} else
GET_LDESC(OLC_MOB(d)) = str_dup("undefined");
break;
/*-------------------------------------------------------------------*/
case MEDIT_D_DESC:
/*
* We should never get here.
*/
cleanup_olc(d, CLEANUP_ALL);
mudlog("SYSERR: OLC: medit_parse(): Reached D_DESC case!", BRF, LVL_BUILDER, TRUE);
SEND_TO_Q("Oops...\r\n", d);
break;
/*-------------------------------------------------------------------*/
#if CONFIG_OASIS_MPROG
case MEDIT_MPROG_COMLIST:
/*
* We should never get here, but if we do, bail out.
*/
cleanup_olc(d, CLEANUP_ALL);
mudlog("SYSERR: OLC: medit_parse(): Reached MPROG_COMLIST case!", BRF, LVL_BUILDER, TRUE);
break;
#endif
/*-------------------------------------------------------------------*/
case MEDIT_NPC_FLAGS:
if ((i = atoi(arg)) <= 0)
break;
else if (i <= NUM_MOB_FLAGS)
TOGGLE_BIT(MOB_FLAGS(OLC_MOB(d)), 1 << (i - 1));
medit_disp_mob_flags(d);
return;
/*-------------------------------------------------------------------*/
case MEDIT_AFF_FLAGS:
if ((i = atoi(arg)) <= 0)
break;
else if (i <= NUM_AFF_FLAGS)
TOGGLE_BIT(AFF_FLAGS(OLC_MOB(d)), 1 << (i - 1));
medit_disp_aff_flags(d);
return;
/*-------------------------------------------------------------------*/
#if CONFIG_OASIS_MPROG
case MEDIT_MPROG:
if ((i = atoi(arg)) == 0)
medit_disp_menu(d);
else if (i == OLC_MTOTAL(d)) {
struct mob_prog_data *temp;
CREATE(temp, struct mob_prog_data, 1);
temp->next = OLC_MPROGL(d);
temp->type = -1;
temp->arglist = NULL;
temp->comlist = NULL;
OLC_MPROG(d) = temp;
OLC_MPROGL(d) = temp;
OLC_MODE(d) = MEDIT_CHANGE_MPROG;
medit_change_mprog (d);
} else if (i < OLC_MTOTAL(d)) {
struct mob_prog_data *temp;
int x = 1;
for (temp = OLC_MPROGL(d); temp && x < i; temp = temp->next)
x++;
OLC_MPROG(d) = temp;
OLC_MODE(d) = MEDIT_CHANGE_MPROG;
medit_change_mprog (d);
} else if (i == (OLC_MTOTAL(d) + 1)) {
SEND_TO_Q("Which mob prog do you want to purge? ", d);
OLC_MODE(d) = MEDIT_PURGE_MPROG;
} else
medit_disp_menu(d);
return;
case MEDIT_PURGE_MPROG:
if ((i = atoi(arg)) > 0 && i < OLC_MTOTAL(d)) {
struct mob_prog_data *temp;
int x = 1;
for (temp = OLC_MPROGL(d); temp && x < i; temp = temp->next)
x++;
OLC_MPROG(d) = temp;
REMOVE_FROM_LIST(OLC_MPROG(d), OLC_MPROGL(d), next);
free(OLC_MPROG(d)->arglist);
free(OLC_MPROG(d)->comlist);
free(OLC_MPROG(d));
OLC_MPROG(d) = NULL;
OLC_VAL(d) = 1;
}
medit_disp_mprog(d);
return;
case MEDIT_CHANGE_MPROG:
if ((i = atoi(arg)) == 1)
medit_disp_mprog_types(d);
else if (i == 2) {
SEND_TO_Q("Enter new arg list: ", d);
OLC_MODE(d) = MEDIT_MPROG_ARGS;
} else if (i == 3) {
SEND_TO_Q("Enter new mob prog commands:\r\n", d);
/*
* Pass control to modify.c for typing.
*/
OLC_MODE(d) = MEDIT_MPROG_COMLIST;
if (OLC_MPROG(d)->comlist) {
SEND_TO_Q(OLC_MPROG(d)->comlist, d);
oldtext = str_dup(OLC_MPROG(d)->comlist);
}
string_write(d, &OLC_MPROG(d)->comlist, MAX_STRING_LENGTH, 0, oldtext);
OLC_VAL(d) = 1;
} else
medit_disp_mprog(d);
return;
#endif
/*-------------------------------------------------------------------*/
/*
* Numerical responses.
*/
#if CONFIG_OASIS_MPROG
case MEDIT_MPROG_TYPE:
/*
* This calculation may be off by one too many powers of 2?
* Someone who actually uses MobProgs will have to check.
*/
OLC_MPROG(d)->type = (1 << LIMIT(atoi(arg), 0, NUM_PROGS - 1));
OLC_VAL(d) = 1;
medit_change_mprog(d);
return;
case MEDIT_MPROG_ARGS:
OLC_MPROG(d)->arglist = str_dup(arg);
OLC_VAL(d) = 1;
medit_change_mprog(d);
return;
#endif
case MEDIT_SEX:
GET_SEX(OLC_MOB(d)) = LIMIT(i, 0, NUM_GENDERS - 1);
break;
case MEDIT_HITROLL:
GET_HITROLL(OLC_MOB(d)) = LIMIT(i, 0, 50);
break;
case MEDIT_DAMROLL:
GET_DAMROLL(OLC_MOB(d)) = LIMIT(i, 0, 50);
break;
case MEDIT_NDD:
GET_NDD(OLC_MOB(d)) = LIMIT(i, 0, 30);
break;
case MEDIT_SDD:
GET_SDD(OLC_MOB(d)) = LIMIT(i, 0, 127);
break;
case MEDIT_NUM_HP_DICE:
GET_HIT(OLC_MOB(d)) = LIMIT(i, 0, 30);
break;
case MEDIT_SIZE_HP_DICE:
GET_MANA(OLC_MOB(d)) = LIMIT(i, 0, 1000);
break;
case MEDIT_ADD_HP:
GET_MOVE(OLC_MOB(d)) = LIMIT(i, 0, 30000);
break;
case MEDIT_AC:
GET_AC(OLC_MOB(d)) = LIMIT(i, 10, 200);
break;
case MEDIT_EXP:
GET_EXP(OLC_MOB(d)) = MAX(i, 0);
break;
case MEDIT_GOLD:
add_money_to_char(OLC_MOB(d), MAX(i, 0), COPPER_COINS);
break;
case MEDIT_POS:
GET_POS(OLC_MOB(d)) = LIMIT(i, 0, NUM_POSITIONS - 1);
break;
case MEDIT_DEFAULT_POS:
GET_DEFAULT_POS(OLC_MOB(d)) = LIMIT(i, 0, NUM_POSITIONS - 1);
break;
case MEDIT_ATTACK:
GET_ATTACK(OLC_MOB(d)) = LIMIT(i, 0, NUM_ATTACK_TYPES - 1);
break;
case MEDIT_LEVEL:
GET_LEVEL(OLC_MOB(d)) = i;
break;
case MEDIT_ALIGNMENT:
GET_ALIGNMENT(OLC_MOB(d)) = LIMIT(i, -1000, 1000);
break;
case MEDIT_CLASS:
GET_CLASS(OLC_MOB(d)) = MAX(0, MIN(NUM_NPC_CLASS, atoi(arg)));
break;
case MEDIT_RACE:
GET_RACE(OLC_MOB(d)) = MAX(0, MIN(NUM_NPC_RACE, atoi(arg)));
// INT, WIS, STR, DEX, CON, CHA
GET_INT(OLC_MOB(d)) = mob_stats[(int)GET_RACE(OLC_MOB(d))][0];
GET_WIS(OLC_MOB(d)) = mob_stats[(int)GET_RACE(OLC_MOB(d))][1];
GET_STR(OLC_MOB(d)) = mob_stats[(int)GET_RACE(OLC_MOB(d))][2];
GET_DEX(OLC_MOB(d)) = mob_stats[(int)GET_RACE(OLC_MOB(d))][3];
GET_CON(OLC_MOB(d)) = mob_stats[(int)GET_RACE(OLC_MOB(d))][4];
GET_CHA(OLC_MOB(d)) = mob_stats[(int)GET_RACE(OLC_MOB(d))][5];
GET_HIT(OLC_MOB(d)) = mob_hp[i][0];
GET_MANA(OLC_MOB(d)) = mob_hp[i][2];
GET_MOVE(OLC_MOB(d)) = mob_hp[i][3];
break;
case MEDIT_WEIGHT:
GET_MOB_WEIGHT(OLC_MOB(d)) = LIMIT(i, 1, 1000);
break;
case MEDIT_MSIZE:
GET_MOB_SIZE(OLC_MOB(d)) = atoi(arg);
break;
/*-------------------------------------------------------------------*/
default:
/*
* We should never get here.
*/
cleanup_olc(d, CLEANUP_ALL);
mudlog("SYSERR: OLC: medit_parse(): Reached default case!", BRF, LVL_BUILDER, TRUE);
SEND_TO_Q("Oops...\r\n", d);
break;
}
/*
* Display main menu.
*/
void medit_disp_menu(struct descriptor_data *d)
{
struct char_data *mob;
mob = OLC_MOB(d);
get_char_colors(d->character);
clear_screen(d);
sprintf(buf,
"-- Mob Number: [%s%d%s]\r\n"
"%s1%s) Sex: %s%-7.7s%s %s2%s) Alias: %s%s\r\n"
"%s3%s) S-Desc: %s%s\r\n"
"%s4%s) L-Desc:-\r\n%s%s"
"%s5%s) D-Desc:-\r\n%s%s"
"%s6%s) Level: [%s%4d%s], %s7%s) Alignment: [%s%4d%s]\r\n"
"%s8%s) HR//SKY: [%s%4d%s], %s9%s) DR//FD: [%s%4d%s]\r\n"
"%sA%s) NumDamDice: [%s%4d%s], %sB%s) SizeDamDice: [%s%4d%s]\r\n"
"%sC%s) Num HP Dice: [%s%4d%s], %sD%s) Size HP Dice: [%s%4d%s], %sE%s) HP Bonus: [%s%5d%s]\r\n"
"%sF%s) Armor Class: [%s%4d%s], %sG%s) Exp: [%s%9d%s], %sH%s) Gold: [%s%8d%s]\r\n",
cyn, OLC_NUM(d), nrm,
grn, nrm, yel, genders[(int)GET_SEX(mob)], nrm,
grn, nrm, yel, GET_ALIAS(mob),
grn, nrm, yel, GET_SDESC(mob),
grn, nrm, yel, GET_LDESC(mob),
grn, nrm, yel, GET_DDESC(mob),
grn, nrm, cyn, GET_LEVEL(mob), nrm,
grn, nrm, cyn, GET_ALIGNMENT(mob), nrm,
grn, nrm, cyn, GET_HITROLL(mob), nrm,
grn, nrm, cyn, GET_DAMROLL(mob), nrm,
grn, nrm, cyn, GET_NDD(mob), nrm,
grn, nrm, cyn, GET_SDD(mob), nrm,
grn, nrm, cyn, GET_HIT(mob), nrm,
grn, nrm, cyn, GET_MANA(mob), nrm,
grn, nrm, cyn, GET_MOVE(mob), nrm,
grn, nrm, cyn, GET_AC(mob), nrm,
grn, nrm, cyn, GET_EXP(mob), nrm,
grn, nrm, cyn, convert_all_to_copper(mob), nrm
);
SEND_TO_Q(buf, d);
sprintbit(MOB_FLAGS(mob), action_bits, buf1);
sprintbit(AFF_FLAGS(mob), affected_bits, buf2);
sprintf(buf,
"%sI%s) Position : %s%s\r\n"
"%sJ%s) Default : %s%s\r\n"
"%sK%s) Attack : %s%s\r\n"
"%sN%s) Class : %s%s\r\n"
"%sR%s) Race : %s%s\r\n"
"%sS%s) Size : %s%d\r\n"
"%sW%s) Weight : %s%d\r\n"
"%sL%s) NPC Flags : %s%s\r\n"
"%sM%s) AFF Flags : %s%s\r\n"
#if CONFIG_OASIS_MPROG
"%sP%s) Mob Progs : %s%s\r\n"
#endif
"%sQ%s) Quit\r\n"
"Enter choice : ",
grn, nrm, yel, position_types[(int)GET_POS(mob)],
grn, nrm, yel, position_types[(int)GET_DEFAULT_POS(mob)],
grn, nrm, yel, attack_hit_text[GET_ATTACK(mob)].singular,
grn, nrm, cyn, npc_class_types[(int)GET_CLASS(mob)],
grn, nrm, cyn, npc_race_types[(int)GET_RACE(mob)],
grn, nrm, cyn, GET_MOB_SIZE(mob),
grn, nrm, cyn, GET_MOB_WEIGHT(mob),
grn, nrm, cyn, buf1,
grn, nrm, cyn, buf2,
#if CONFIG_OASIS_MPROG
grn, nrm, cyn, (OLC_MPROGL(d) ? "Set." : "Not Set."),
#endif
grn, nrm
);
SEND_TO_Q(buf, d);
OLC_MODE(d) = MEDIT_MAIN_MENU;
}