/* ***************************************************
* file: zedit.cc *
* (c) 1996-2000 Christopher J. Dickey, Andrew *
* Hynek, and Nick Robertson (c) 2001 The AwakeMUD *
* Consortium *
*************************************************** */
#include <stdio.h>
#include <string.h>
#include "structs.h"
#include "awake.h"
#include "interpreter.h"
#include "comm.h"
#include "spells.h"
#include "utils.h"
#include "db.h"
#include <stdlib.h>
#include "boards.h"
#include "screen.h"
#include "olc.h"
extern struct room_data *world;
extern struct obj_data *obj_proto;
extern struct index_data *obj_index;
extern struct char_data *mob_proto;
extern struct index_data *mob_index;
extern struct zone_data *zone_table;
extern int top_of_zone_table;
extern int real_zone(int);
extern const char *dirs[];
extern const char *short_where[];
const char *reset_mode[] = {
"Don't reset",
"Reset if no PCs are in zone",
"Always reset",
"\n"
};
#define COM d->edit_cmd
#define ZONENUM d->character->player_specials->saved.zonenum
#define ZON d->edit_zon
#define MOB(rnum) mob_index[rnum].virt
#define OBJ(rnum) obj_index[rnum].virt
#define ROOM(rnum) world[rnum].number
#define ZONE zone_table[zonenum]
#define Zcmd zone_table[zonenum].cmd[i]
void write_zone_to_disk(int vnum) {
int zonenum = real_zone(vnum);
if (zonenum < 0) {
mudlog("Attempted to write Non-Existent zone!", NULL, LOG_SYSLOG, TRUE);
return;
}
FILE *fp;
int i;
sprintf(buf, "%s/%d.zon", ZON_PREFIX, vnum);
fp = fopen(buf, "w+");
// write it out!
fprintf(fp, "#%d\n", vnum);
fprintf(fp, "%s~\n", ZONE.name);
fprintf(fp, "%d %d %d %d %d\n", ZONE.top, ZONE.lifespan, ZONE.reset_mode, ZONE.security, ZONE.connected);
fprintf(fp, "%d %d %d %d %d\n", ZONE.editor_ids[0], ZONE.editor_ids[1],
ZONE.editor_ids[2], ZONE.editor_ids[3], ZONE.editor_ids[4]);
for (i = 0; i < ZONE.num_cmds; ++i) {
switch (ZONE.cmd[i].command) {
case 'M':
fprintf(fp, "%c %d %d %d %d\n", Zcmd.command, Zcmd.if_flag, MOB(Zcmd.arg1),
Zcmd.arg2, ROOM(Zcmd.arg3));
break;
case 'O':
fprintf(fp, "%c %d %d %d %d\n", Zcmd.command, Zcmd.if_flag, OBJ(Zcmd.arg1),
Zcmd.arg2, ROOM(Zcmd.arg3));
break;
case 'P':
fprintf(fp, "%c %d %d %d %d\n", Zcmd.command, Zcmd.if_flag, OBJ(Zcmd.arg1),
Zcmd.arg2, OBJ(Zcmd.arg3));
break;
case 'D':
fprintf(fp, "%c %d %d %d %d\n", Zcmd.command, Zcmd.if_flag, ROOM(Zcmd.arg1),
Zcmd.arg2, Zcmd.arg3);
break;
case 'E': case 'N':
fprintf(fp, "%c %d %d %d %d\n", Zcmd.command, Zcmd.if_flag, OBJ(Zcmd.arg1),
Zcmd.arg2, Zcmd.arg3);
break;
case 'G': case 'C':
fprintf(fp, "%c %d %d %d\n", Zcmd.command, Zcmd.if_flag, OBJ(Zcmd.arg1),
Zcmd.arg2);
break;
case 'R':
fprintf(fp, "%c %d %d %d\n", Zcmd.command, Zcmd.if_flag, ROOM(Zcmd.arg1),
OBJ(Zcmd.arg2));
break;
}
}
fprintf(fp, "$\n");
fclose(fp);
}
#undef ZONE
#undef Zcmd
void zedit_disp_wear_menu(struct descriptor_data *d)
{
CLS(CH);
int counter;
for (counter = 0; counter < (NUM_WEARS - 1); counter += 2)
send_to_char(CH, "^G%2d^Y) ^W%-20s ^G%2d^Y) ^W%-20s\r\n",
counter + 1, short_where[counter],
counter + 2, counter + 1 < (NUM_WEARS - 1) ?
short_where[counter + 1] : "");
send_to_char("^wEnter wear position ^Y(^G0 ^Wto quit^Y)^w: ", CH);
}
void zedit_disp_state_menu(struct descriptor_data *d)
{
send_to_char("\r\n^G1^Y) ^WOpen\r\n^G2^Y) ^WClosed\r\n^G3^Y) ^WClosed and locked\r\n"
"^G0^Y) ^WQuit\r\n^wEnter a selection: ", CH);
}
void zedit_disp_data_menu(struct descriptor_data *d)
{
CLS(CH);
send_to_char(CH, "^WZone: ^c%d^n\r\n", ZON->number );
send_to_char(CH, "^G1^Y) ^WName: ^c%s^n\r\n", ZON->name );
send_to_char(CH, "^G2^Y) ^WTop of zone: ^c%d^n\r\n", ZON->top );
send_to_char(CH, "^G3^Y) ^WLifespan: ^c%d^n\r\n", ZON->lifespan );
send_to_char(CH, "^G4^Y) ^WReset mode: ^c%s^n\r\n", reset_mode[ZON->reset_mode] );
send_to_char(CH, "^G5^Y) ^WSecurity level: ^c%d^n\r\n", ZON->security );
if (access_level(CH, LVL_PRESIDENT))
{
send_to_char(CH, "^G6^Y) ^WEditor's ID Numbers: ^c%d^w, ^c%d^w, ^c%d^w, ^c%d^w, ^c%d^n\r\n",
ZON->editor_ids[0], ZON->editor_ids[1], ZON->editor_ids[2],
ZON->editor_ids[3], ZON->editor_ids[4]);
send_to_char(CH, "^G7^Y) ^WConnected: ^c%d^n\r\n", ZON->connected);
}
send_to_char("^Gq^Y) ^WQuit\r\n^wEnter selection: ", CH);
d->edit_mode = ZEDIT_DATA_MENU;
}
char *get_type(char c) {
switch (c) {
case 'M': return "MOB";
case 'O': return "OBJECT";
case 'P': return "PUT";
case 'E': return "EQUIP";
case 'G': return "GIVE";
case 'R': return "REMOVE";
case 'D': return "DOOR";
case 'N': return "GIVENUM";
case 'C': return "CYBER/BIOWARE";
default: return "NONE";
}
}
char get_real_type(int i) {
switch (i) {
case 1: return 'M';
case 2: return 'O';
case 3: return 'P';
case 4: return 'E';
case 5: return 'G';
case 6: return 'R';
case 7: return 'D';
case 8: return 'N';
case 9: return 'C';
case 0: return '*';
}
return '*';
}
void zedit_disp_type_cmd(struct descriptor_data *d)
{
CLS(CH);
send_to_char("^G1^Y) ^WMOB\r\n"
"^G2^Y) ^WOBJECT\r\n"
"^G3^Y) ^WPUT\r\n"
"^G4^Y) ^WEQUIP\r\n"
"^G5^Y) ^WGIVE\r\n"
"^G6^Y) ^WREMOVE\r\n"
"^G7^Y) ^WDOOR\r\n"
"^G8^Y) ^WGIVE NUMBER\r\n"
"^G9^Y) ^WCYBER/BIOWARE\r\n"
"^G0^Y) ^WNOTHING\r\n"
"^wEnter command type: ", CH);
}
void zedit_disp_direction_menu(struct descriptor_data *d)
{
CLS(CH);
send_to_char("^G 1^Y) ^Wnorth\r\n"
"^G 2^Y) ^Wnortheast\r\n"
"^G 3^Y) ^Weast\r\n"
"^G 4^Y) ^Wsoutheast\r\n"
"^G 5^Y) ^Wsouth\r\n"
"^G 6^Y) ^Wsouthwest\r\n"
"^G 7^Y) ^Wwest\r\n"
"^G 8^Y) ^Wnorthwest\r\n"
"^G 9^Y) ^Wup\r\n"
"^G10^Y) ^Wdown\r\n"
"^wEnter selection: ", CH);
}
void zedit_disp_command_menu(struct descriptor_data *d)
{
CLS(CH);
send_to_char(CH, "^WCommand: ^c%d^n\r\n", d->edit_number );
send_to_char(CH, "^G1^Y) ^WType: ^c%s^n\r\n", get_type(COM->command) );
send_to_char(CH, "^G2^Y) ^WConditional: ^c%s^n\r\n", (!COM->if_flag ?
"Always" : "If Last") );
switch (COM->command) {
case 'M':
send_to_char(CH, "^G3^Y) ^WLoad mob: ^c%s ^y(^B%d)^n\r\n", mob_proto[COM->arg1].player.short_descr, MOB(COM->arg1) );
send_to_char(CH, "^G4^Y) ^WMaximum number in game: ^c%d^n\r\n", COM->arg2 );
send_to_char(CH, "^G5^Y) ^WLoad in room: ^c%s ^y(^B%d^y)^n\r\n", world[COM->arg3].name, ROOM(COM->arg3) );
break;
case 'O':
send_to_char(CH, "^G3^Y) ^WLoad obj: ^c%s ^y(^B%d^y)^n\r\n", obj_proto[COM->arg1].short_description, OBJ(COM->arg1) );
send_to_char(CH, "^G4^Y) ^WMaximum number in game: ^c%d^n\r\n", COM->arg2 );
send_to_char(CH, "^G5^Y) ^WLoad in room: ^c%s ^y(^B%d^y)^n\r\n", world[COM->arg3].name, ROOM(COM->arg3) );
break;
case 'P':
send_to_char(CH, "^G3^Y) ^WPut obj: ^c%s ^y(^B%d^y)^n\r\n", obj_proto[COM->arg1].short_description, OBJ(COM->arg1) );
send_to_char(CH, "^G4^Y) ^WMaximum number in game: ^c%d^n\r\n", COM->arg2 );
send_to_char(CH, "^G5^Y) ^WInto obj: ^c%s ^y(^B%d^y)^n\r\n", obj_proto[COM->arg3].short_description, OBJ(COM->arg3) );
break;
case 'G':
send_to_char(CH, "^G3^Y) ^WGive obj: ^c%s ^y(^B%d^y)^n\r\n", obj_proto[COM->arg1].short_description, OBJ(COM->arg1) );
send_to_char(CH, "^G4^Y) ^WMaximum number in game: ^c%d^n\r\n", COM->arg2 );
break;
case 'E':
send_to_char(CH, "^G3^Y) ^WEquip obj: ^c%s (%d)^n\r\n", obj_proto[COM->arg1].short_description, OBJ(COM->arg1));
send_to_char(CH, "^G4^Y) ^WMaximum number in game: ^c%d^n\r\n", COM->arg2 );
send_to_char(CH, "^G5^Y) ^WAt ^c%s^W position\r\n", short_where[COM->arg3] );
break;
case 'N':
send_to_char(CH, "^G3^Y) ^WGive obj: ^c%s (%d)^n\r\n", obj_proto[COM->arg1].short_description, OBJ(COM->arg1));
send_to_char(CH, "^G4^Y) ^WMaximum number in game: ^c%d^n\r\n", COM->arg2);
send_to_char(CH, "^G5^Y) ^WTotal number to give: ^c%d^n\r\n", COM->arg3);
break;
case 'R':
send_to_char(CH, "^G3^Y) ^WRemove obj: ^c%s ^y(^B%d^y)^n\r\n", obj_proto[COM->arg2].short_description, OBJ(COM->arg2) );
send_to_char(CH, "^G4^Y) ^WFrom room: ^c%s ^y(^B%d^y)^n\r\n", world[COM->arg1].name, ROOM(COM->arg1) );
break;
case 'D':
send_to_char(CH, "^G3^Y) ^WSet door: ^c%s^n\r\n", dirs[COM->arg2] );
send_to_char(CH, "^G4^Y) ^WIn room: ^c%s ^y(^B%d^y)^n\r\n", world[COM->arg1].name, ROOM(COM->arg1) );
send_to_char(CH, "^G5^Y) ^WTo state: ^c%s^n\r\n", (COM->arg3 == 0 ? "open" : (COM->arg3 == 1 ? "closed" : "closed and locked")) );
break;
case 'C':
send_to_char(CH, "^G3^Y) ^WObj: ^c%s ^y(^B%d^y)^n\r\n", obj_proto[COM->arg1].short_description, OBJ(COM->arg1) );
send_to_char(CH, "^G4^Y) ^WTo: ^c%s^n\r\n", (COM->arg2 == 1 ? "bioware" : "cyberware") );
break;
}
send_to_char("^Gq^Y) ^WQuit\r\n^wEnter your selection: ", CH);
d->edit_mode = ZEDIT_COMMAND_MENU;
}
// MAIN LOOP!
void zedit_parse(struct descriptor_data *d, char *arg)
{
int number, i = 0, zone;
switch (d->edit_mode) {
case ZEDIT_CONFIRM_EDIT_DATA:
switch (*arg) {
case 'y':
case 'Y':
d->edit_zon = new zone_data;
// we do need to zero it out since we're accessing its elements
memset((char *) ZON, 0, sizeof(struct zone_data));
*d->edit_zon = zone_table[d->edit_number];
if (zone_table[d->edit_number].name)
d->edit_zon->name = str_dup(zone_table[d->edit_number].name);
zedit_disp_data_menu(d);
break;
case 'n':
case 'N':
STATE(d) = CON_PLAYING;
REMOVE_BIT(PLR_FLAGS(d->character), PLR_EDITING);
break;
default:
send_to_char("That's not a valid choice!\r\n", d->character);
send_to_char("Do you wish to edit the data?\r\n", d->character);
break;
}
break;
case ZEDIT_CONFIRM_CREATE_DATA:
switch (*arg) {
case 'y':
case 'Y':
d->edit_zon = new zone_data;
// we do need to zero it out since we're accessing its elements
memset((char *) ZON, 0, sizeof(struct zone_data));
// set a few vars
ZON->name = str_dup("an unfinished zone");
ZON->number = CH->player_specials->saved.zonenum;
ZON->top = ZON->number * 100 + 99;
zedit_disp_data_menu(d);
break;
case 'n':
case 'N':
STATE(d) = CON_PLAYING;
REMOVE_BIT(PLR_FLAGS(d->character), PLR_EDITING);
break;
default:
send_to_char("That's not a valid choice!\r\n", d->character);
send_to_char("Do you wish to edit the data?\r\n", d->character);
break;
}
break;
case ZEDIT_CONFIRM_SAVEDATA:
switch (*arg) {
int zone_num, c;
case 'y':
case 'Y':
zone_num = real_zone(ZON->number);
// first we insert into memory
if (zone_num > -1) { // ie, it already exists
ZON->cmd = zone_table[zone_num].cmd;
delete [] zone_table[zone_num].name;
zone_table[zone_num] = *ZON;
} else { // here we got to add a new spot
int counter;
int counter2;
int found = 0;
struct zone_data *new_z_table;
// create new table + 2
new_z_table = new struct zone_data[top_of_zone_table + 2];
for (counter = 0; counter < top_of_zone_table + 1; counter++) {
if (!found) {
if (zone_table[counter].number > CH->player_specials->saved.zonenum) {
new_z_table[counter] = *(ZON);
found = 1;
new_z_table[counter + 1] = zone_table[counter];
} else
new_z_table[counter] = zone_table[counter];
} else
new_z_table[counter + 1] = zone_table[counter];
}
if (!found)
new_z_table[top_of_zone_table + 1] = *(ZON);
top_of_zone_table++;
delete [] zone_table;
zone_table = new_z_table;
}
write_zone_to_disk(ZONENUM);
write_index_file("zon");
d->edit_mode = 0;
delete ZON;
ZON = NULL;
REMOVE_BIT(PLR_FLAGS(d->character), PLR_EDITING);
STATE(d) = CON_PLAYING;
send_to_char("Done.\r\n", d->character);
break; // end of 'y' case in confirm savestring
case 'n':
case 'N':
if (ZON) {
if (ZON->name)
delete [] ZON->name;
delete ZON;
}
STATE(d) = CON_PLAYING;
ZON = NULL;
d->edit_number = 0;
REMOVE_BIT(PLR_FLAGS(CH), PLR_EDITING);
break; // end of 'n' case in confirm savestring
default:
send_to_char("Please enter yes or no.\r\n"
"Do you wish to save this zone internally?\r\n", CH);
break;
}
break; // end of confirm savestring
case ZEDIT_CONFIRM_ADD_CMD:
switch (*arg) {
case 'y':
case 'Y':
COM = new reset_com;
COM->command = '*';
zedit_disp_command_menu(d);
break;
case 'n':
case 'N':
STATE(d) = CON_PLAYING;
REMOVE_BIT(PLR_FLAGS(d->character), PLR_EDITING);
break;
default:
send_to_char("That's not a valid choice!\r\n", CH);
send_to_char("Do you wish to add a command?\r\n", CH);
break;
}
break;
case ZEDIT_CONFIRM_INSERT_CMD:
switch (*arg) {
case 'y':
case 'Y':
COM = new reset_com;
COM->command = '*';
// so it knows to insert if they decide to save
d->edit_number2 = TRUE;
zedit_disp_command_menu(d);
break;
case 'n':
case 'N':
STATE(d) = CON_PLAYING;
REMOVE_BIT(PLR_FLAGS(d->character), PLR_EDITING);
break;
default:
send_to_char("That's not a valid choice!\r\n", CH);
send_to_char("Do you wish to insert a command?\r\n", CH);
break;
}
break;
case ZEDIT_CONFIRM_EDIT_CMD:
switch (*arg) {
case 'y':
case 'Y':
COM = new reset_com;
*COM = zone_table[real_zone(ZONENUM)].cmd[d->edit_number];
zedit_disp_command_menu(d);
break;
case 'n':
case 'N':
STATE(d) = CON_PLAYING;
REMOVE_BIT(PLR_FLAGS(d->character), PLR_EDITING);
break;
default:
send_to_char("That's not a valid choice!\r\n", CH);
send_to_char("Do you wish to edit the command?\r\n", CH);
break;
}
break;
case ZEDIT_DATA_MENU:
switch (*arg) {
case 'q':
case 'Q':
send_to_char("Do you wish to save this zone internally?\r\n", CH);
d->edit_mode = ZEDIT_CONFIRM_SAVEDATA;
break;
case '1':
send_to_char("Enter zone name: ", CH);
d->edit_mode = ZEDIT_ZONE_NAME;
break;
case '2':
send_to_char("Enter top of zone: ", CH);
d->edit_mode = ZEDIT_TOP_OF_ZONE;
break;
case '3':
send_to_char("Lifespan (in ticks between resets): ", CH);
d->edit_mode = ZEDIT_LIFESPAN;
break;
case '4':
CLS(CH);
send_to_char("1) Don't reset\r\n"
"2) Reset only if no PCs are in the zone\r\n"
"3) Always reset\r\n"
"0) Quit\r\n"
"Enter reset mode: ", CH);
d->edit_mode = ZEDIT_RESET_MODE;
break;
case '5':
send_to_char("Zone security (1 (none) - 15 (paranoid)):\r\n", CH);
d->edit_mode = ZEDIT_SECURITY;
break;
case '6':
if (!access_level(CH, LVL_PRESIDENT)) {
send_to_char("That's not a valid choice.\r\n", CH);
return;
}
send_to_char("Enter ID list seperated by spaces:\r\n", CH);
d->edit_mode = ZEDIT_ID_LIST;
break;
case '7':
if (!access_level(CH, LVL_PRESIDENT)) {
send_to_char("That's not a valid choice.\r\n", CH);
return;
}
send_to_char("Zone is connected (1 - yes, 0 - no)? ", CH);
d->edit_mode = ZEDIT_CONNECTED;
break;
default:
send_to_char("That's not a valid choice.\r\n", CH);
zedit_disp_data_menu(d);
break;
}
break;
case ZEDIT_COMMAND_MENU:
switch (*arg) {
case 'q':
case 'Q':
send_to_char("Do you wish to save this zone command internally?\r\n", CH);
d->edit_mode = ZEDIT_CONFIRM_SAVECMDS;
break;
case '1':
zedit_disp_type_cmd(d);
d->edit_mode = ZEDIT_CMD_TYPE;
break;
case '2':
send_to_char("\r\n1) Always\r\n2) If last\r\nEnter your selection: ",
CH);
d->edit_mode = ZEDIT_IF_FLAG_CMD;
break;
case '3':
switch (COM->command) {
case 'M':
send_to_char("\r\nEnter virtual number of mob: ", CH);
d->edit_mode = ZEDIT_ARG1;
break;
case 'O': case 'P': case 'E': case 'G': case 'R': case 'N': case 'C':
send_to_char("\r\nEnter virtual number of obj: ", CH);
d->edit_mode = ZEDIT_ARG1;
break;
case 'D':
zedit_disp_direction_menu(d);
d->edit_mode = ZEDIT_DIRECTION_OF_DOOR;
break;
default:
zedit_disp_command_menu(d);
break;
}
break;
case '4':
switch (COM->command) {
case 'M': case 'O': case 'P': case 'E': case 'N': case 'G':
send_to_char("Enter max allowed to exist in game: ", CH);
d->edit_mode = ZEDIT_ARG2;
break;
case 'R': case 'D':
send_to_char("Enter the room number: ", CH);
d->edit_mode = ZEDIT_REMOVE_ROOM;
break;
case 'C':
send_to_char(" 0) Cyberware\r\n 1) Bioware\r\nEnter location to place obj: ", CH);
d->edit_mode = ZEDIT_ARG2;
break;
default:
zedit_disp_command_menu(d);
break;
}
break;
case '5':
switch (COM->command) {
case 'M': case 'O':
send_to_char("Enter the room number: ", CH);
d->edit_mode = ZEDIT_ARG3;
break;
case 'P':
send_to_char("Enter the object number: ", CH);
d->edit_mode = ZEDIT_ARG3;
break;
case 'E':
zedit_disp_wear_menu(d);
d->edit_mode = ZEDIT_WEAR;
break;
case 'D':
zedit_disp_state_menu(d);
d->edit_mode = ZEDIT_DOOR_STATE;
break;
case 'N':
send_to_char("Enter total number to give mob: ", CH);
d->edit_mode = ZEDIT_ARG3;
break;
default:
zedit_disp_command_menu(d);
break;
}
break;
}
break;
case ZEDIT_CONFIRM_SAVECMDS:
int zone_num, top_of_cmds;
switch (*arg) {
case 'y':
case 'Y':
zone_num = real_zone(ZONENUM);
top_of_cmds = zone_table[zone_num].num_cmds;
// first, determine if you're adding or replacing
if (d->edit_number < top_of_cmds) {
if (!d->edit_number2)
zone_table[zone_num].cmd[d->edit_number] = *(COM);
else {
int counter, counter2;
int found = 0;
struct reset_com *new_cmds;
new_cmds = new struct reset_com[top_of_cmds + 1];
if (top_of_cmds > 1) {
// first count your way up
for (counter = 0; counter < d->edit_number; counter++)
new_cmds[counter] = zone_table[zone_num].cmd[counter];
for (counter = top_of_cmds; counter > d->edit_number;
counter--)
new_cmds[counter] = zone_table[zone_num].cmd[counter-1];
new_cmds[d->edit_number] = *(COM);
zone_table[zone_num].num_cmds++;
delete [] zone_table[zone_num].cmd;
zone_table[zone_num].cmd = new_cmds;
} else {
new_cmds[1] = zone_table[zone_num].cmd[0];
new_cmds[0] = *(COM);
zone_table[zone_num].num_cmds++;
if (zone_table[zone_num].cmd)
delete [] zone_table[zone_num].cmd;
zone_table[zone_num].cmd = new_cmds;
}
}
} else {
int counter;
int counter2;
int found = 0;
struct reset_com *new_cmds;
// create a new set of commands, with 1 extra spot
new_cmds = new struct reset_com[top_of_cmds + 1];
// we know it's always going in at the end, so we copy the old 1st
if (top_of_cmds > 0) { // you have to do this in case there's 0 cmds
for (counter = 0; counter < top_of_cmds; counter++)
new_cmds[counter] = zone_table[zone_num].cmd[counter];
// tada, here it goes now, don't increase counter, for loop
new_cmds[counter] = *(COM); // already did!
zone_table[zone_num].num_cmds++;
delete [] zone_table[zone_num].cmd;
zone_table[zone_num].cmd = new_cmds;
} else {
new_cmds[0] = *(COM);
zone_table[zone_num].num_cmds++;
if (zone_table[zone_num].cmd)
delete [] zone_table[zone_num].cmd;
zone_table[zone_num].cmd = new_cmds;
}
} // end else
write_zone_to_disk(ZONENUM);
d->edit_mode = 0;
delete COM;
COM = NULL;
REMOVE_BIT(PLR_FLAGS(d->character), PLR_EDITING);
STATE(d) = CON_PLAYING;
send_to_char("Done.\r\n", d->character);
break; // for 'y' case
case 'n':
case 'N':
if (COM)
delete COM;
STATE(d) = CON_PLAYING;
COM = NULL;
d->edit_number = 0;
REMOVE_BIT(PLR_FLAGS(CH), PLR_EDITING);
break; // for 'n' case
default:
send_to_char("That's not a valid choice.\r\n", CH);
send_to_char("Do you wish to save this zone command internally?\r\n", CH);
break;
} // for switch in confirm save cmds
break; // for ZEDIT_CONFIRM_SAVECMDS
case ZEDIT_ARG3:
number = atoi(arg);
switch (COM->command) {
case 'M':
case 'O':
COM->arg3 = MAX(0, real_room(number));
if (!access_level(CH, LVL_PRESIDENT) && !(number >= (ZONENUM * 100) &&
number <= zone_table[real_zone(ZONENUM)].top))
COM->arg3 = 0;
break;
case 'P':
COM->arg3 = MAX(0, real_object(number));
if (!access_level(CH, LVL_PRESIDENT) && (number < 600 || number > 699)) {
for (zone = 0; zone <= top_of_zone_table; zone++)
if (number >= (zone_table[zone].number * 100) && number <= zone_table[zone].top)
break;
if (zone <= top_of_zone_table) {
for (i = 0; i < 5; i++)
if (zone_table[zone].editor_ids[i] == GET_IDNUM(CH))
break;
} else i = 5;
}
if (i >= 5)
COM->arg3 = 0;
break;
case 'N':
COM->arg3 = MIN(25, MAX(0, number));
break;
}
zedit_disp_command_menu(d);
break;
case ZEDIT_DOOR_STATE:
number = atoi(arg);
if ((number < 0) || (number > 3)) {
zedit_disp_state_menu(d);
return;
} else
if (number != 0)
COM->arg3 = number - 1;
zedit_disp_command_menu(d);
break;
case ZEDIT_WEAR:
number = atoi(arg);
if ((number < 0) || (number > (NUM_WEARS - 1))) {
zedit_disp_wear_menu(d);
return;
} else if (number != 0)
COM->arg3 = number - 1;
zedit_disp_command_menu(d);
break;
case ZEDIT_REMOVE_ROOM:
number = atoi(arg);
COM->arg1 = MAX(0, real_room(number));
if (!access_level(CH, LVL_PRESIDENT) && !(number >= (ZONENUM * 100) &&
number <= zone_table[real_zone(ZONENUM)].top))
COM->arg1 = 0;
zedit_disp_command_menu(d);
break;
case ZEDIT_ARG2:
number = atoi(arg);
if (COM->command == 'C' && (number < 0 || number > 1)) {
send_to_char("Value must be either 0 (cyberware) or 1 (bioware).\r\n"
"Enter location to place obj: ", CH);
return;
} else if ((number < -1) || (number > 1000)) {
send_to_char("Value must be between -1 and 1000.\r\n"
"Enter max allowed to exist in game: ", CH);
return;
}
COM->arg2 = number;
zedit_disp_command_menu(d);
break;
case ZEDIT_DIRECTION_OF_DOOR:
number = atoi(arg);
if (number < 0 || number > 10) {
zedit_disp_direction_menu(d);
return;
} else
if (number != 0)
COM->arg2 = number - 1;
zedit_disp_command_menu(d);
break;
case ZEDIT_ARG1:
number = atoi(arg);
if (COM->command == 'M') {
COM->arg1 = MAX(0, real_mobile(number));
if (!access_level(CH, LVL_PRESIDENT)) {
for (zone = 0; zone <= top_of_zone_table; zone++)
if (number >= (zone_table[zone].number * 100) && number <= zone_table[zone].top)
break;
if (zone <= top_of_zone_table) {
for (i = 0; i < 5; i++)
if (zone_table[zone].editor_ids[i] == GET_IDNUM(CH))
break;
} else i = 5;
}
if (i >= 5)
COM->arg1 = 0;
} else {
if (COM->command == 'R')
COM->arg2 = MAX(0, real_object(number));
else COM->arg1 = MAX(0, real_object(number));
if (!access_level(CH, LVL_PRESIDENT) && (number < 300 || number > 699 || (number > 499 && number < 600))) {
for (zone = 0; zone <= top_of_zone_table; zone++)
if (number >= (zone_table[zone].number * 100) && number <= zone_table[zone].top)
break;
if (zone <= top_of_zone_table) {
for (i = 0; i < 5; i++)
if (zone_table[zone].editor_ids[i] == GET_IDNUM(CH))
break;
} else i = 5;
}
if (i >= 5) {
if (COM->command == 'R')
COM->arg2 = 0;
else COM->arg1 = 0;
}
}
zedit_disp_command_menu(d);
break;
case ZEDIT_CMD_TYPE:
number = atoi(arg);
if ((number < 0) || (number > 9)) {
zedit_disp_type_cmd(d);
send_to_char("\r\nInvalid selection. Please try again: ", CH);
return;
} else {
COM->command = get_real_type(number);
if ((COM->command == 'E') || (COM->command == 'G') ||
(COM->command == 'P') || (COM->command == 'N') || (COM->command == 'C'))
COM->if_flag = 1;
else COM->if_flag = 0;
COM->arg1 = 0;
COM->arg2 = 0;
COM->arg3 = 0;
}
zedit_disp_command_menu(d);
break;
case ZEDIT_IF_FLAG_CMD:
number = atoi(arg);
if ((number < 1) || (number > 2)) {
send_to_char("Invalid selection.\r\n1) Always\r\n2) If last\r\n"
"Enter your selection: ", CH);
} else {
COM->if_flag = COM->if_flag;
zedit_disp_command_menu(d);
}
break;
case ZEDIT_ZONE_NAME:
if (ZON->name)
delete [] ZON->name;
ZON->name = str_dup(arg);
zedit_disp_data_menu(d);
break;
case ZEDIT_SECURITY:
number = atoi(arg);
if (number < 1 || number > 15) {
send_to_char("Security rating must range from 1 to 15.\r\nZone security: ", CH);
return;
}
ZON->security = number;
zedit_disp_data_menu(d);
break;
case ZEDIT_ID_LIST:
{
int t[5] = {0, 0, 0, 0, 0};
if (sscanf(arg, "%d %d %d %d %d\n", &t[0], &t[1], &t[2], &t[3], &t[4]) == 5) {
ZON->editor_ids[0] = t[0];
ZON->editor_ids[1] = t[1];
ZON->editor_ids[2] = t[2];
ZON->editor_ids[3] = t[3];
ZON->editor_ids[4] = t[4];
}
zedit_disp_data_menu(d);
}
break;
case ZEDIT_CONNECTED:
number = atoi(arg);
if (number != 0 && number != 1) {
send_to_char("Value must be 0 or 1! Zone is connected? ", CH);
return;
}
ZON->connected = number;
zedit_disp_data_menu(d);
break;
case ZEDIT_TOP_OF_ZONE:
number = atoi(arg);
if ((d->edit_number == top_of_zone_table) || (d->edit_number == -1))
if ((number < ZON->number * 100) || (number > (ZON->number * 100 + 499))) {
send_to_char(CH, "Value must range from %d to %d\r\n", ZON->number * 100,
(ZON->number * 100 + 499));
send_to_char("Enter top of zone: ", CH);
return;
} else
ZON->top = number;
else
if ((number < ZON->number * 100) ||
(number > zone_table[d->edit_number + 1].number * 100 - 1)) {
send_to_char(CH, "Value must range from %d to %d\r\n", ZON->number * 100,
zone_table[d->edit_number + 1].number * 100 - 1);
send_to_char("Enter top of zone: ", CH);
return;
} else
ZON->top = number;
zedit_disp_data_menu(d);
break;
case ZEDIT_LIFESPAN:
number = atoi(arg);
if ((number < 0) || (number > 1440)) {
send_to_char("Value must range from 0 to 1440\r\n", CH);
send_to_char("Lifespan (in ticks between resets): ", CH);
} else {
ZON->lifespan = number;
zedit_disp_data_menu(d);
}
break;
case ZEDIT_RESET_MODE:
number = atoi(arg);
if ((number < 0) || (number > 3)) {
send_to_char("Invalid choice. Please enter from 0 to 3.\r\n", CH);
send_to_char("Enter reset mode: ", CH);
return;
} else
if (number != 0)
ZON->reset_mode = number - 1;
zedit_disp_data_menu(d);
break;
}
}