/* save the zone's triggers to internal memory and to disk */
void trigedit_save(struct descriptor_data *d)
{
int i;
trig_rnum rnum;
int found = 0;
char *s;
trig_data *proto;
trig_data *trig = OLC_TRIG(d);
trig_data *live_trig;
struct cmdlist_element *cmd, *next_cmd;
struct index_data **new_index;
struct descriptor_data *dsc;
FILE *trig_file;
int zone, top;
char buf[MAX_CMD_LENGTH];
char bitBuf[MAX_INPUT_LENGTH];
char fname[MAX_INPUT_LENGTH];
if ((rnum = real_trigger(OLC_NUM(d))) != NOTHING) {
proto = trig_index[rnum]->proto;
for (cmd = proto->cmdlist; cmd; cmd = next_cmd) {
next_cmd = cmd->next;
if (cmd->cmd)
free(cmd->cmd);
free(cmd);
}
free(proto->arglist);
free(proto->name);
/* Recompile the command list from the new script */
s = OLC_STORAGE(d);
CREATE(trig->cmdlist, struct cmdlist_element, 1);
if (s) {
char *t = strtok(s, "\n\r"); /* strtok returns NULL if s is "\r\n" */
if (t)
trig->cmdlist->cmd = strdup(t);
else
trig->cmdlist->cmd = strdup("* No script");
cmd = trig->cmdlist;
while ((s = strtok(NULL, "\n\r"))) {
CREATE(cmd->next, struct cmdlist_element, 1);
cmd = cmd->next;
cmd->cmd = strdup(s);
}
} else
/* save the zone's triggers to internal memory and to disk */
void trigedit_save(struct descriptor_data *d)
{
char *name=NULL;
char *trgarglist=NULL;
char *code=NULL;
int trig_rnum, i;
int found = 0;
char *s;
trig_data *proto;
trig_data *trig = OLC_TRIG(d);
trig_data *live_trig;
struct cmdlist_element *cmd, *next_cmd;
struct index_data **new_index;
struct descriptor_data *dsc;
int zone, top;
char buf[MAX_CMD_LENGTH];
char bitBuf[MAX_INPUT_LENGTH];
char *trg_replace = "REPLACE INTO %s ("
"znum, "
"vnum, "
"name, "
"attach_type, "
"flags, "
"numarg, "
"arglist, "
"code) "
"VALUES (%d, %d, '%s', %d, '%s', %d, '%s', '%s');";
if ((trig_rnum = real_trigger(OLC_NUM(d))) != -1) {
proto = trig_index[trig_rnum]->proto;
for (cmd = proto->cmdlist; cmd; cmd = next_cmd) {
next_cmd = cmd->next;
if (cmd->cmd)
free(cmd->cmd);
free(cmd);
}
if (proto->arglist)
free(proto->arglist);
if (proto->name)
free(proto->name);
/* Recompile the command list from the new script */
s = OLC_STORAGE(d);
CREATE(trig->cmdlist, struct cmdlist_element, 1);
trig->cmdlist->cmd = str_dup(strtok(s, "\n\r"));
cmd = trig->cmdlist;
while ((s = strtok(NULL, "\n\r"))) {
CREATE(cmd->next, struct cmdlist_element, 1);
cmd = cmd->next;
cmd->cmd = str_dup(s);
}
/* make the prorotype look like what we have */
trig_data_copy(proto, trig);
/* go through the mud and replace existing triggers */
live_trig = trigger_list;
while (live_trig)
{
if (GET_TRIG_RNUM(live_trig) == trig_rnum) {
if (live_trig->arglist) {
free(live_trig->arglist);
live_trig->arglist = NULL;
}
if (live_trig->name) {
free(live_trig->name);
live_trig->name = NULL;
}
if (proto->arglist)
live_trig->arglist = str_dup(proto->arglist);
if (proto->name)
live_trig->name = str_dup(proto->name);
live_trig->cmdlist = proto->cmdlist;
live_trig->curr_state = live_trig->cmdlist;
live_trig->trigger_type = proto->trigger_type;
live_trig->attach_type = proto->attach_type;
live_trig->narg = proto->narg;
live_trig->data_type = proto->data_type;
live_trig->depth = 0;
live_trig->wait_event = NULL;
if (GET_TRIG_WAIT(live_trig))
event_cancel(GET_TRIG_WAIT(live_trig));
free_varlist(live_trig->var_list);
}
live_trig = live_trig->next_in_world;
}
} else {
/*
* Save all the zone_table for this zone to disk. This function now
* writes simple comments in the form of (<name>) to each record. A
* header for each field is also there.
*/
int save_zone(zone_rnum zone_num)
{
int subcmd, arg1 = -1, arg2 = -1, arg3 = -1;
char fname[128], oldname[128];
const char *comment = NULL;
FILE *zfile;
#if CIRCLE_UNSIGNED_INDEX
if (zone_num == NOWHERE || zone_num > top_of_zone_table) {
#else
if (zone_num < 0 || zone_num > top_of_zone_table) {
#endif
log("SYSERR: GenOLC: save_zone: Invalid real zone number %d. (0-%d)", zone_num, top_of_zone_table);
return FALSE;
}
snprintf(fname, sizeof(fname), "%s/%d.new", ZON_PREFIX, zone_table[zone_num].number);
if (!(zfile = fopen(fname, "w"))) {
mudlog(BRF, LVL_BUILDER, TRUE, "SYSERR: OLC: save_zones: Can't write zone %d.", zone_table[zone_num].number);
return FALSE;
}
/*
* Print zone header to file
*/
fprintf(zfile, "#%d\n"
"%s~\n"
"%s~\n"
"%d %d %d %d\n",
zone_table[zone_num].number,
(zone_table[zone_num].builders && *zone_table[zone_num].builders)
? zone_table[zone_num].builders : "None.",
(zone_table[zone_num].name && *zone_table[zone_num].name)
? zone_table[zone_num].name : "undefined",
genolc_zone_bottom(zone_num),
zone_table[zone_num].top,
zone_table[zone_num].lifespan,
zone_table[zone_num].reset_mode
);
/*
* Handy Quick Reference Chart for Zone Values.
*
* Field #1 Field #3 Field #4 Field #5
* -------------------------------------------------
* M (Mobile) Mob-Vnum Wld-Max Room-Vnum
* O (Object) Obj-Vnum Wld-Max Room-Vnum
* G (Give) Obj-Vnum Wld-Max Unused
* E (Equip) Obj-Vnum Wld-Max EQ-Position
* P (Put) Obj-Vnum Wld-Max Target-Obj-Vnum
* D (Door) Room-Vnum Door-Dir Door-State
* R (Remove) Room-Vnum Obj-Vnum Unused
* T (Trigger) Trig-type Trig-Vnum Room-Vnum
* V (var) Trig-type Context Room-Vnum Varname Value
* -------------------------------------------------
*/
for (subcmd = 0; ZCMD(zone_num, subcmd).command != 'S'; subcmd++) {
switch (ZCMD(zone_num, subcmd).command) {
case 'M':
arg1 = mob_index[ZCMD(zone_num, subcmd).arg1].vnum;
arg2 = ZCMD(zone_num, subcmd).arg2;
arg3 = world[ZCMD(zone_num, subcmd).arg3].number;
comment = mob_proto[ZCMD(zone_num, subcmd).arg1].player.short_descr;
break;
case 'O':
arg1 = obj_index[ZCMD(zone_num, subcmd).arg1].vnum;
arg2 = ZCMD(zone_num, subcmd).arg2;
arg3 = world[ZCMD(zone_num, subcmd).arg3].number;
comment = obj_proto[ZCMD(zone_num, subcmd).arg1].short_description;
break;
case 'G':
arg1 = obj_index[ZCMD(zone_num, subcmd).arg1].vnum;
arg2 = ZCMD(zone_num, subcmd).arg2;
arg3 = -1;
comment = obj_proto[ZCMD(zone_num, subcmd).arg1].short_description;
break;
case 'E':
arg1 = obj_index[ZCMD(zone_num, subcmd).arg1].vnum;
arg2 = ZCMD(zone_num, subcmd).arg2;
arg3 = ZCMD(zone_num, subcmd).arg3;
comment = obj_proto[ZCMD(zone_num, subcmd).arg1].short_description;
break;
case 'P':
arg1 = obj_index[ZCMD(zone_num, subcmd).arg1].vnum;
arg2 = ZCMD(zone_num, subcmd).arg2;
arg3 = obj_index[ZCMD(zone_num, subcmd).arg3].vnum;
comment = obj_proto[ZCMD(zone_num, subcmd).arg1].short_description;
break;
case 'D':
arg1 = world[ZCMD(zone_num, subcmd).arg1].number;
arg2 = ZCMD(zone_num, subcmd).arg2;
arg3 = ZCMD(zone_num, subcmd).arg3;
comment = world[ZCMD(zone_num, subcmd).arg1].name;
break;
case 'R':
arg1 = world[ZCMD(zone_num, subcmd).arg1].number;
arg2 = obj_index[ZCMD(zone_num, subcmd).arg2].vnum;
comment = obj_proto[ZCMD(zone_num, subcmd).arg2].short_description;
arg3 = -1;
break;
case 'T':
arg1 = ZCMD(zone_num, subcmd).arg1; /* trigger type */
arg2 = trig_index[ZCMD(zone_num, subcmd).arg2]->vnum; /* trigger vnum */
arg3 = world[ZCMD(zone_num, subcmd).arg3].number; /* room num */
comment = GET_TRIG_NAME(trig_index[real_trigger(arg2)]->proto);
break;
case 'V':
arg1 = ZCMD(zone_num, subcmd).arg1; /* trigger type */
arg2 = ZCMD(zone_num, subcmd).arg2; /* context */
arg3 = world[ZCMD(zone_num, subcmd).arg3].number;
break;
case '*':
/*
* Invalid commands are replaced with '*' - Ignore them.
*/
continue;
default:
mudlog(BRF, LVL_BUILDER, TRUE, "SYSERR: OLC: z_save_to_disk(): Unknown cmd '%c' - NOT saving", ZCMD(zone_num, subcmd).command);
continue;
}
if (ZCMD(zone_num, subcmd).command != 'V')
fprintf(zfile, "%c %d %d %d %d \t(%s)\n",
ZCMD(zone_num, subcmd).command, ZCMD(zone_num, subcmd).if_flag, arg1, arg2, arg3, comment);
else
fprintf(zfile, "%c %d %d %d %d %s %s\n",
ZCMD(zone_num, subcmd).command, ZCMD(zone_num, subcmd).if_flag, arg1, arg2, arg3,
ZCMD(zone_num, subcmd).sarg1, ZCMD(zone_num, subcmd).sarg2);
}
fputs("S\n$\n", zfile);
fclose(zfile);
snprintf(oldname, sizeof(oldname), "%s/%d.zon", ZON_PREFIX, zone_table[zone_num].number);
remove(oldname);
rename(fname, oldname);
if (in_save_list(zone_table[zone_num].number, SL_ZON))
remove_from_save_list(zone_table[zone_num].number, SL_ZON);
return TRUE;
}
/*-------------------------------------------------------------------*/
/*
* Some common code to count the number of comands in the list.
*/
int count_commands(struct reset_com *list)
{
int count = 0;
while (list[count].command != 'S')
count++;
return count;
}
void trigedit_parse(struct descriptor_data *d, char *arg)
{
int i = 0;
switch (OLC_MODE(d)) {
case TRIGEDIT_MAIN_MENU:
switch (tolower(*arg)) {
case 'q':
if (OLC_VAL(d)) { /* Anything been changed? */
if (!GET_TRIG_TYPE(OLC_TRIG(d))) {
write_to_output(d, "Invalid Trigger Type! Answer a to abort quit!\r\n");
}
write_to_output(d, "Do you wish to save your changes? : ");
OLC_MODE(d) = TRIGEDIT_CONFIRM_SAVESTRING;
} else
cleanup_olc(d, CLEANUP_ALL);
return;
case '1':
OLC_MODE(d) = TRIGEDIT_NAME;
write_to_output(d, "Name: ");
break;
case '2':
OLC_MODE(d) = TRIGEDIT_INTENDED;
write_to_output(d, "0: Mobiles, 1: Objects, 2: Rooms: ");
break;
case '3':
OLC_MODE(d) = TRIGEDIT_TYPES;
trigedit_disp_types(d);
break;
case '4':
OLC_MODE(d) = TRIGEDIT_NARG;
write_to_output(d, "Numeric argument: ");
break;
case '5':
OLC_MODE(d) = TRIGEDIT_ARGUMENT;
write_to_output(d, "Argument: ");
break;
case '6':
OLC_MODE(d) = TRIGEDIT_COMMANDS;
write_to_output(d, "Enter trigger commands: (/s saves /h for help)\r\n\r\n");
d->backstr = NULL;
if (OLC_STORAGE(d)) {
write_to_output(d, "%s", OLC_STORAGE(d));
d->backstr = strdup(OLC_STORAGE(d));
}
d->str = &OLC_STORAGE(d);
d->max_str = MAX_CMD_LENGTH;
d->mail_to = 0;
OLC_VAL(d) = 1;
break;
case 'w':
case 'W':
write_to_output(d, "Copy what trigger? ");
OLC_MODE(d) = TRIGEDIT_COPY;
break;
default:
trigedit_disp_menu(d);
return;
}
return;
case TRIGEDIT_CONFIRM_SAVESTRING:
switch(tolower(*arg)) {
case 'y':
trigedit_save(d);
mudlog(CMP, MAX(LVL_BUILDER, GET_INVIS_LEV(d->character)), TRUE,
"OLC: %s edits trigger %d", GET_NAME(d->character),
OLC_NUM(d));
/* fall through */
case 'n':
cleanup_olc(d, CLEANUP_ALL);
return;
case 'a': /* abort quitting */
break;
default:
write_to_output(d, "Invalid choice!\r\n");
write_to_output(d, "Do you wish to save your changes? : ");
return;
}
break;
case TRIGEDIT_NAME:
smash_tilde(arg);
if (OLC_TRIG(d)->name)
free(OLC_TRIG(d)->name);
OLC_TRIG(d)->name = strdup((arg && *arg) ? arg : "undefined");
OLC_VAL(d)++;
break;
case TRIGEDIT_INTENDED:
if ((atoi(arg)>=MOB_TRIGGER) || (atoi(arg)<=WLD_TRIGGER))
OLC_TRIG(d)->attach_type = atoi(arg);
OLC_VAL(d)++;
break;
case TRIGEDIT_NARG:
OLC_TRIG(d)->narg = LIMIT(atoi(arg), 0, 100);
OLC_VAL(d)++;
break;
case TRIGEDIT_ARGUMENT:
smash_tilde(arg);
OLC_TRIG(d)->arglist = (*arg?strdup(arg):NULL);
OLC_VAL(d)++;
break;
case TRIGEDIT_TYPES:
if ((i = atoi(arg)) == 0)
break;
else if (!((i < 0) || (i > NUM_TRIG_TYPE_FLAGS)))
TOGGLE_BIT((GET_TRIG_TYPE(OLC_TRIG(d))), 1 << (i - 1));
OLC_VAL(d)++;
trigedit_disp_types(d);
return;
case TRIGEDIT_COPY:
if ((i = real_trigger(atoi(arg))) != NOWHERE) {
trigedit_setup_existing(d, i);
} else
write_to_output(d, "That trigger does not exist.\r\n");
break;
case TRIGEDIT_COMMANDS:
break;
}
OLC_MODE(d) = TRIGEDIT_MAIN_MENU;
trigedit_disp_menu(d);
}
void zedit_parse(struct descriptor_data *d, char *arg)
{
int pos, i = 0;
switch (OLC_MODE(d)) {
/*-------------------------------------------------------------------*/
case ZEDIT_CONFIRM_SAVESTRING:
switch (*arg) {
case 'y':
case 'Y':
/*
* Save the zone in memory, hiding invisible people.
*/
//SEND_TO_Q("Saving zone info in memory.\r\n", d);
zedit_save_internally(d);
SEND_TO_Q("Saving zone info to disk.\r\n", d);
zedit_save_to_disk(OLC_ZNUM(d));
sprintf(buf, "OLC: %s edits zone info for room %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);
break;
default:
SEND_TO_Q("Invalid choice!\r\nDo you wish to save your changes? : ", d);
break;
}
break;
/* End of ZEDIT_CONFIRM_SAVESTRING */
/*-------------------------------------------------------------------*/
case ZEDIT_MAIN_MENU:
switch (*arg) {
case 'q':
case 'Q':
if (OLC_ZONE(d)->age || OLC_ZONE(d)->number) {
SEND_TO_Q("Do you wish to save your changes? : ", d);
OLC_MODE(d) = ZEDIT_CONFIRM_SAVESTRING;
} else {
SEND_TO_Q("No changes made.\r\n", d);
cleanup_olc(d, CLEANUP_ALL);
}
break;
case 'n':
case 'N':
/*
* New entry.
*/
SEND_TO_Q("What number in the list should the new command be? : ", d);
OLC_MODE(d) = ZEDIT_NEW_ENTRY;
break;
case 'e':
case 'E':
/*
* Change an entry.
*/
SEND_TO_Q("Which command do you wish to change? : ", d);
OLC_MODE(d) = ZEDIT_CHANGE_ENTRY;
break;
case 'd':
case 'D':
/*
* Delete an entry.
*/
SEND_TO_Q("Which command do you wish to delete? : ", d);
OLC_MODE(d) = ZEDIT_DELETE_ENTRY;
break;
case 'z':
case 'Z':
/*
* Edit zone name.
*/
SEND_TO_Q("Enter new zone name : ", d);
OLC_MODE(d) = ZEDIT_ZONE_NAME;
break;
case 't':
case 'T':
/*
* Edit top of zone.
*/
if (GET_LEVEL(d->character) < LVL_DEITY)
zedit_disp_menu(d);
else {
SEND_TO_Q("Enter new top of zone : ", d);
OLC_MODE(d) = ZEDIT_ZONE_TOP;
}
break;
case 'l':
case 'L':
/*
* Edit zone lifespan.
*/
SEND_TO_Q("Enter new zone lifespan : ", d);
OLC_MODE(d) = ZEDIT_ZONE_LIFE;
break;
case 'r':
case 'R':
/*
* Edit zone reset mode.
*/
SEND_TO_Q("\r\n"
"0) Never reset\r\n"
"1) Reset only when no players in zone\r\n"
"2) Normal reset\r\n"
"Enter new zone reset type : ", d);
OLC_MODE(d) = ZEDIT_ZONE_RESET;
break;
case 'c':
case 'C':
/*
* Change loadchance (percentages)
*/
send_to_char(" \r\nWhich command? ", d->character);
OLC_MODE(d) = ZEDIT_PROB;
break;
case 'b':
case 'B':
if (GET_LEVEL(d->character) < LVL_DEITY) {
send_to_char("Only Implementors can modify the builder list.\r\n", d->character);
zedit_disp_menu(d);
} else {
/*
* Edit zone builder list.
*/
send_to_char("Enter new zone builders : ", d->character);
OLC_MODE(d) = ZEDIT_ZONE_BUILDERS;
}
break;
default:
zedit_disp_menu(d);
break;
}
break;
/* End of ZEDIT_MAIN_MENU */
/*-------------------------------------------------------------------*/
case ZEDIT_NEW_ENTRY:
/*
* Get the line number and insert the new line.
*/
pos = atoi(arg);
if (isdigit(*arg) && new_command(OLC_ZONE(d), pos)) {
if (start_change_command(d, pos)) {
zedit_disp_comtype(d);
OLC_ZONE(d)->age = 1;
}
} else
zedit_disp_menu(d);
break;
/*-------------------------------------------------------------------*/
case ZEDIT_DELETE_ENTRY:
/*
* Get the line number and delete the line.
*/
pos = atoi(arg);
if (isdigit(*arg)) {
delete_command(OLC_ZONE(d), pos);
OLC_ZONE(d)->age = 1;
}
zedit_disp_menu(d);
break;
/*-------------------------------------------------------------------*/
case ZEDIT_CHANGE_ENTRY:
/*
* Parse the input for which line to edit, and goto next quiz.
*/
pos = atoi(arg);
if (isdigit(*arg) && start_change_command(d, pos)) {
zedit_disp_comtype(d);
OLC_ZONE(d)->age = 1;
} else
zedit_disp_menu(d);
break;
/*-------------------------------------------------------------------*/
case ZEDIT_COMMAND_TYPE:
/*
* Parse the input for which type of command this is, and goto next
* quiz.
*/
OLC_CMD(d).command = toupper(*arg);
if (!OLC_CMD(d).command || (strchr("MOPEDGR", OLC_CMD(d).command) == NULL)) {
SEND_TO_Q("Invalid choice, try again : ", d);
} else {
if (OLC_VAL(d)) { /* If there was a previous command. */
SEND_TO_Q("Is this command dependent on the success of the previous one? (y/n)\r\n", d);
OLC_MODE(d) = ZEDIT_IF_FLAG;
} else { /* 'if-flag' not appropriate. */
OLC_CMD(d).if_flag = 0;
zedit_disp_arg1(d);
}
}
break;
/*-------------------------------------------------------------------*/
case ZEDIT_IF_FLAG:
/*
* Parse the input for the if flag, and goto next quiz.
*/
switch (*arg) {
case 'y':
case 'Y':
OLC_CMD(d).if_flag = 1;
break;
case 'n':
case 'N':
OLC_CMD(d).if_flag = 0;
break;
default:
SEND_TO_Q("Try again : ", d);
return;
}
zedit_disp_arg1(d);
break;
/*-------------------------------------------------------------------*/
case ZEDIT_ARG1:
/*
* Parse the input for arg1, and goto next quiz.
*/
if (!isdigit(*arg)) {
SEND_TO_Q("Must be a numeric value, try again : ", d);
return;
}
switch (OLC_CMD(d).command) {
case 'M':
if ((pos = real_mobile(atoi(arg))) >= 0) {
OLC_CMD(d).arg1 = pos;
zedit_disp_arg2(d);
} else
SEND_TO_Q("That mobile does not exist, try again : ", d);
break;
case 'O':
case 'P':
case 'E':
case 'G':
if ((pos = real_object(atoi(arg))) >= 0) {
OLC_CMD(d).arg1 = pos;
zedit_disp_arg2(d);
} else
SEND_TO_Q("That object does not exist, try again : ", d);
break;
case 'D':
case 'R':
case 'T':
case 'V':
if (atoi(arg)<MOB_TRIGGER || atoi(arg)>WLD_TRIGGER)
send_to_char("Invalid input.", d->character);
else {
OLC_CMD(d).arg1 = atoi(arg);
zedit_disp_arg2(d);
}
break;
default:
/*
* We should never get here.
*/
cleanup_olc(d, CLEANUP_ALL);
mudlog("SYSERR: OLC: zedit_parse(): case ARG1: Ack!", BRF, LVL_BUILDER, TRUE);
SEND_TO_Q("Oops...\r\n", d);
break;
}
break;
/*-------------------------------------------------------------------*/
case ZEDIT_ARG2:
/*
* Parse the input for arg2, and goto next quiz.
*/
if (!isdigit(*arg)) {
SEND_TO_Q("Must be a numeric value, try again : ", d);
return;
}
switch (OLC_CMD(d).command) {
case 'M':
case 'O':
OLC_CMD(d).arg2 = atoi(arg);
OLC_CMD(d).arg3 = real_room(OLC_NUM(d));
OLC_CMD(d).arg4 = 0;
zedit_disp_menu(d);
break;
case 'G':
OLC_CMD(d).arg2 = atoi(arg);
OLC_CMD(d).arg4 = 0;
zedit_disp_menu(d);
break;
case 'P':
case 'E':
OLC_CMD(d).arg2 = atoi(arg);
OLC_CMD(d).arg4 = 0;
zedit_disp_arg3(d);
break;
case 'V':
OLC_CMD(d).arg2 = atoi(arg);
if (OLC_CMD(d).arg1 == WLD_TRIGGER)
OLC_CMD(d).arg3 = OLC_NUM(d);
send_to_char("Enter the global name : ", d->character);
OLC_MODE(d) = ZEDIT_SARG1;
break;
case 'T':
if (real_trigger(atoi(arg)) >= 0) {
OLC_CMD(d).arg2 = atoi(arg);
zedit_disp_menu(d);
} else
send_to_char("That trigger does not exist, try again : ", d->character);
break;
case 'D':
pos = atoi(arg);
/*
* Count directions.
*/
if (pos < 0 || pos > NUM_OF_DIRS)
SEND_TO_Q("Try again : ", d);
else {
OLC_CMD(d).arg2 = pos;
zedit_disp_arg3(d);
}
break;
case 'R':
if ((pos = real_object(atoi(arg))) >= 0) {
OLC_CMD(d).arg2 = pos;
zedit_disp_menu(d);
} else
SEND_TO_Q("That object does not exist, try again : ", d);
break;
default:
/*
* We should never get here, but just in case...
*/
cleanup_olc(d, CLEANUP_ALL);
mudlog("SYSERR: OLC: zedit_parse(): case ARG2: Ack!", BRF, LVL_BUILDER, TRUE);
SEND_TO_Q("Oops...\r\n", d);
break;
}
break;
/*-------------------------------------------------------------------*/
case ZEDIT_ARG3:
/*
* Parse the input for arg3, and go back to main menu.
*/
if (!isdigit(*arg)) {
SEND_TO_Q("Must be a numeric value, try again : ", d);
return;
}
switch (OLC_CMD(d).command) {
case 'E':
pos = atoi(arg);
/*
* Count number of wear positions. We could use NUM_WEARS, this is
* more reliable.
*/
while (*equipment_types[i] != '\n')
i++;
if (pos < 0 || pos > i)
SEND_TO_Q("Try again : ", d);
else {
OLC_CMD(d).arg3 = pos;
zedit_disp_menu(d);
}
break;
case 'P':
if ((pos = real_object(atoi(arg))) >= 0) {
OLC_CMD(d).arg3 = pos;
zedit_disp_menu(d);
} else
SEND_TO_Q("That object does not exist, try again : ", d);
break;
case 'D':
pos = atoi(arg);
if (pos < 0 || pos > 2)
SEND_TO_Q("Try again : ", d);
else {
OLC_CMD(d).arg3 = pos;
zedit_disp_menu(d);
}
break;
case 'M':
case 'O':
case 'G':
case 'R':
case 'T':
case 'V':
default:
/*
* We should never get here, but just in case...
*/
cleanup_olc(d, CLEANUP_ALL);
mudlog("SYSERR: OLC: zedit_parse(): case ARG3: Ack!", BRF, LVL_BUILDER, TRUE);
SEND_TO_Q("Oops...\r\n", d);
break;
}
break;
/*-------------------------------------------------------------------*/
case ZEDIT_SARG1:
if (strlen(arg)) {
OLC_CMD(d).sarg1 = str_dup(arg);
OLC_MODE(d) = ZEDIT_SARG2;
send_to_char("Enter the global value : ", d->character);
} else
send_to_char("Must have some name to assign : ", d->character);
break;
/*-------------------------------------------------------------------*/
case ZEDIT_SARG2:
if (strlen(arg)) {
OLC_CMD(d).sarg2 = str_dup(arg);
zedit_disp_menu(d);
} else
send_to_char("Must have some value to set it to :", d->character);
break;
/*-------------------------------------------------------------------*/
case ZEDIT_ZONE_NAME:
/*
* Add new name and return to main menu.
*/
if (genolc_checkstring(d, arg)) {
if (OLC_ZONE(d)->name)
free(OLC_ZONE(d)->name);
else
log("SYSERR: OLC: ZEDIT_ZONE_NAME: no name to free!");
OLC_ZONE(d)->name = str_dup(arg);
OLC_ZONE(d)->number = 1;
zedit_disp_menu(d);
break;
/*-------------------------------------------------------------------*/
case ZEDIT_ZONE_BUILDERS:
/*
* Add new builders and return to main menu.
*/
if (OLC_ZONE(d)->builders)
free(OLC_ZONE(d)->builders);
OLC_ZONE(d)->builders = str_dup(arg);
OLC_ZONE(d)->number = 1;
}
zedit_disp_menu(d);
break;
/*-------------------------------------------------------------------*/
case ZEDIT_ZONE_RESET:
/*
* Parse and add new reset_mode and return to main menu.
*/
pos = atoi(arg);
if (!isdigit(*arg) || pos < 0 || pos > 2)
SEND_TO_Q("Try again (0-2) : ", d);
else {
OLC_ZONE(d)->reset_mode = pos;
OLC_ZONE(d)->number = 1;
zedit_disp_menu(d);
}
break;
/*-------------------------------------------------------------------*/
case ZEDIT_ZONE_LIFE:
/*
* Parse and add new lifespan and return to main menu.
*/
pos = atoi(arg);
if (!isdigit(*arg) || pos < 0 || pos > 240)
SEND_TO_Q("Try again (0-240) : ", d);
else {
OLC_ZONE(d)->lifespan = pos;
OLC_ZONE(d)->number = 1;
zedit_disp_menu(d);
}
break;
/*-------------------------------------------------------------------*/
case ZEDIT_ZONE_TOP:
/*
* Parse and add new top room in zone and return to main menu.
*/
if (OLC_ZNUM(d) == top_of_zone_table)
OLC_ZONE(d)->top = LIMIT(atoi(arg), OLC_ZNUM(d) * 100, 32000);
else
OLC_ZONE(d)->top = LIMIT(atoi(arg), OLC_ZNUM(d) * 100, zone_table[OLC_ZNUM(d) + 1].number * 100);
zedit_disp_menu(d);
break;
/*-------------------------------------------------------------------*/
case ZEDIT_PROB:
/*
* Which command to change loadchance for? :/
*/
pos = atoi(arg);
if (isdigit(*arg) && start_change_command(d, pos)) {
OLC_MODE(d) = ZEDIT_PROB2;
OLC_ZONE(d)->age = 1;
send_to_char("\r\nChance of NOT loading (0-100) (input 0 for 'always load'): ", d->character);
break;
} else
send_to_char("\r\nInvalid choice.\r\n\r\n", d->character);
zedit_disp_menu(d);
break;
/*-------------------------------------------------------------------*/
case ZEDIT_PROB2:
/*
* Change the loadchance
*/
OLC_CMD(d).arg4 = atoi(arg);
OLC_MODE(d) = ZEDIT_MAIN_MENU;
zedit_disp_menu(d);
break;
/*-------------------------------------------------------------------*/
default:
/*
* We should never get here, but just in case...
*/
cleanup_olc(d, CLEANUP_ALL);
mudlog("SYSERR: OLC: zedit_parse(): Reached default case!", BRF, LVL_BUILDER, TRUE);
SEND_TO_Q("Oops...\r\n", d);
break;
}
}
/*
* the main menu
*/
void zedit_disp_menu(struct descriptor_data *d)
{
int subcmd = 0, room, counter = 0;
get_char_colors(d->character);
clear_screen(d);
room = real_room(OLC_NUM(d));
/*
* Menu header
*/
sprintf(buf,
"Room number: %s%d%s Room zone: %s%d\r\n"
"%sZ%s) Zone name : %s%s\r\n"
"%sB%s) Builders : %s%s\r\n"
"%sL%s) Lifespan : %s%d minutes\r\n"
"%sT%s) Top of zone : %s%d\r\n"
"%sR%s) Reset Mode : %s%s%s\r\n"
"[Command list]\r\n",
cyn, OLC_NUM(d), nrm,
cyn, zone_table[OLC_ZNUM(d)].number,
grn, nrm, yel, OLC_ZONE(d)->name ? OLC_ZONE(d)->name : "<NONE!>",
grn, nrm, yel, OLC_ZONE(d)->builders ? OLC_ZONE(d)->builders : "<NONE!>",
grn, nrm, yel, OLC_ZONE(d)->lifespan,
grn, nrm, yel, OLC_ZONE(d)->top,
grn, nrm,
yel,
OLC_ZONE(d)->reset_mode ? ((OLC_ZONE(d)->reset_mode == 1) ? "Reset when no players are in zone." : "Normal reset.") : "Never reset",
nrm
);
/*
* Print the commands for this room into display buffer.
*/
while (MYCMD.command != 'S') {
/*
* Translate what the command means.
*/
switch (MYCMD.command) {
case 'M':
sprintf(buf2, "%sLoad %s [%s%d%s], Max : %d %% %d",
MYCMD.if_flag ? " then " : "",
mob_proto[MYCMD.arg1].player.short_descr, cyn,
mob_index[MYCMD.arg1].vnum, yel, MYCMD.arg2, MYCMD.arg4
);
break;
case 'G':
sprintf(buf2, "%sGive it %s [%s%d%s], Max : %d %% %d",
MYCMD.if_flag ? " then " : "",
obj_proto[MYCMD.arg1].short_description,
cyn, obj_index[MYCMD.arg1].vnum, yel,
MYCMD.arg2, MYCMD.arg4
);
break;
case 'O':
sprintf(buf2, "%sLoad %s [%s%d%s], Max : %d %% %d",
MYCMD.if_flag ? " then " : "",
obj_proto[MYCMD.arg1].short_description,
cyn, obj_index[MYCMD.arg1].vnum, yel,
MYCMD.arg2, MYCMD.arg4
);
break;
case 'E':
sprintf(buf2, "%sEquip with %s [%s%d%s], %s, Max : %d %% %d",
MYCMD.if_flag ? " then " : "",
obj_proto[MYCMD.arg1].short_description,
cyn, obj_index[MYCMD.arg1].vnum, yel,
equipment_types[MYCMD.arg3],
MYCMD.arg2, MYCMD.arg4
);
break;
case 'P':
sprintf(buf2, "%sPut %s [%s%d%s] in %s [%s%d%s], Max : %d %% %d",
MYCMD.if_flag ? " then " : "",
obj_proto[MYCMD.arg1].short_description,
cyn, obj_index[MYCMD.arg1].vnum, yel,
obj_proto[MYCMD.arg3].short_description,
cyn, obj_index[MYCMD.arg3].vnum, yel,
MYCMD.arg2, MYCMD.arg4
);
break;
case 'R':
sprintf(buf2, "%sRemove %s [%s%d%s] from room.",
MYCMD.if_flag ? " then " : "",
obj_proto[MYCMD.arg2].short_description,
cyn, obj_index[MYCMD.arg2].vnum, yel
);
break;
case 'D':
sprintf(buf2, "%sSet door %s as %s.",
MYCMD.if_flag ? " then " : "",
dirs[MYCMD.arg2],
MYCMD.arg3 ? ((MYCMD.arg3 == 1) ? "closed" : "locked") : "open"
);
break;
case 'T':
sprintf(buf2, "%sAttach trigger %s%s%s [%s%d%s] to %s",
MYCMD.if_flag ? " then " : "",
cyn, trig_index[real_trigger(MYCMD.arg2)]->proto->name, yel,
cyn, MYCMD.arg2, yel,
((MYCMD.arg1 == MOB_TRIGGER) ? "mobile" :
((MYCMD.arg1 == OBJ_TRIGGER) ? "object" :
((MYCMD.arg1 == WLD_TRIGGER)? "room" : "????"))));
break;
case 'V':
sprintf(buf2, "%sAssign global %s:%d to %s = %s",
MYCMD.if_flag ? " then " : "",
MYCMD.sarg1, MYCMD.arg2,
((MYCMD.arg1 == MOB_TRIGGER) ? "mobile" :
((MYCMD.arg1 == OBJ_TRIGGER) ? "object" :
((MYCMD.arg1 == WLD_TRIGGER)? "room" : "????"))),
MYCMD.sarg2);
break;
default:
strcpy(buf2, "<Unknown Command>");
break;
}
/*
* Build the display buffer for this command
*/
sprintf(buf1, "%s%d - %s%s\r\n", nrm, counter++, yel, buf2);
strcat(buf, buf1);
subcmd++;
}
/*
* Finish off menu
*/
sprintf(buf1,
"%s%d - <END OF LIST>\r\n"
"%sN%s) New command. %sE%s) Edit a command.\r\n"
"%sD%s) Delete a command. %sC%s) Change a command's chance of happening.\r\n"
"%sQ%s) Quit\r\nEnter your choice : ",
nrm, counter, grn, nrm, grn, nrm, grn, nrm, grn, nrm, grn, nrm
);
strcat(buf, buf1);
SEND_TO_Q(buf, d);
OLC_MODE(d) = ZEDIT_MAIN_MENU;
}
