void zedit_new_zone(struct char_data *ch, int vzone_num)
{
int result;
const char *error;
struct descriptor_data *dsc;
if ((result = create_new_zone(vzone_num, &error)) < 0) {
SEND_TO_Q(error, ch->desc);
return;
}
for (dsc = descriptor_list; dsc; dsc = dsc->next) {
switch (STATE(dsc)) {
case CON_REDIT:
OLC_ROOM(dsc)->zone += (OLC_ZNUM(dsc) >= result);
/* Fall through. */
case CON_ZEDIT:
case CON_MEDIT:
case CON_SEDIT:
case CON_OEDIT:
OLC_ZNUM(dsc) += (OLC_ZNUM(dsc) >= result);
break;
default:
break;
}
}
sprintf(buf, "OLC: %s creates new zone #%d", GET_NAME(ch), vzone_num);
mudlog(buf, BRF, MAX(LVL_BUILDER, GET_INVIS_LEV(ch)), TRUE);
SEND_TO_Q("Zone create successfully\r\n", ch->desc);
}
/*
* Print the appropriate message for the command type for arg2 and set
* up the input catch clause.
*/
void zedit_disp_arg2(struct descriptor_data *d)
{
int i;
switch (OLC_CMD(d).command) {
case 'M':
case 'O':
case 'E':
case 'P':
case 'G':
SEND_TO_Q("Input the maximum number that can exist on the mud : ", d);
break;
case 'D':
for (i = 0; *dirs[i] != '\n'; i++) {
sprintf(buf, "%d) Exit %s.\r\n", i, dirs[i]);
SEND_TO_Q(buf, d);
}
SEND_TO_Q("Enter exit number for door : ", d);
break;
case 'R':
SEND_TO_Q("Input object's vnum : ", d);
break;
default:
/*
* We should never get here, but just in case...
*/
cleanup_olc(d, CLEANUP_ALL);
mudlog("SYSERR: OLC: zedit_disp_arg2(): Help!", BRF, LVL_BUILDER, TRUE);
SEND_TO_Q("Oops...\r\n", d);
return;
}
OLC_MODE(d) = ZEDIT_ARG2;
}
/*
* Print the appropriate message for the command type for arg1 and set
* up the input catch clause
*/
void zedit_disp_arg1(struct descriptor_data *d)
{
switch (OLC_CMD(d).command) {
case 'M':
SEND_TO_Q("Input mob's vnum : ", d);
OLC_MODE(d) = ZEDIT_ARG1;
break;
case 'O':
case 'E':
case 'P':
case 'G':
SEND_TO_Q("Input object vnum : ", d);
OLC_MODE(d) = ZEDIT_ARG1;
break;
case 'D':
case 'R':
/*
* Arg1 for these is the room number, skip to arg2
*/
OLC_CMD(d).arg1 = real_room(OLC_NUM(d));
zedit_disp_arg2(d);
break;
default:
/*
* We should never get here.
*/
cleanup_olc(d, CLEANUP_ALL);
mudlog("SYSERR: OLC: zedit_disp_arg1(): Help!", BRF, LVL_BUILDER, TRUE);
SEND_TO_Q("Oops...\r\n", d);
return;
}
}
void zedit_disp_arg4(struct descriptor_data *d)
{
switch (OLC_CMD(d).command) {
case 'M':
case 'O':
case 'E':
case 'G':
SEND_TO_Q("Enter The Load % : ", d);
break;
case 'P':
case 'D':
case 'R':
break;
default:
/*
* We should never get here, but just in case...
*/
cleanup_olc(d, CLEANUP_ALL);
mudlog("SYSERR: OLC: zedit_disp_arg4(): Help!", BRF, LVL_BUILDER, TRUE);
SEND_TO_Q("Oops...\r\n", d);
return;
}
OLC_MODE(d) = ZEDIT_ARG4;
}
void medit_disp_size_flags(struct descriptor_data *d)
{
get_char_colors(d->character);
clear_screen(d);
sprintf(buf, "8 ) FINE 4 ) DIMINUTIVE 2 ) TINY\r\n"
"1 ) SMALL 0 ) MEDIUM -1) LARGE\r\n"
"-2) HUGE -4) GARGANTUAN -8) COLOSSAL\r\n");
SEND_TO_Q(buf, d);
sprintf(buf, "\r\nEnter Size: ");
SEND_TO_Q(buf, d);
}
/*
* Display attack types menu.
*/
void medit_disp_attack_types(struct descriptor_data *d)
{
int i;
get_char_colors(d->character);
clear_screen(d);
for (i = 0; i < NUM_ATTACK_TYPES; i++) {
sprintf(buf, "%s%2d%s) %s\r\n", grn, i, nrm, attack_hit_text[i].singular);
SEND_TO_Q(buf, d);
}
SEND_TO_Q("Enter attack type : ", d);
}
/*
* Display the gender of the mobile.
*/
void medit_disp_sex(struct descriptor_data *d)
{
int i;
get_char_colors(d->character);
clear_screen(d);
for (i = 0; i < NUM_GENDERS; i++) {
sprintf(buf, "%s%2d%s) %s\r\n", grn, i, nrm, genders[i]);
SEND_TO_Q(buf, d);
}
SEND_TO_Q("Enter gender number : ", d);
}
/*
* Display positions. (sitting, standing, etc)
*/
void medit_disp_positions(struct descriptor_data *d)
{
int i;
get_char_colors(d->character);
clear_screen(d);
for (i = 0; *position_types[i] != '\n'; i++) {
sprintf(buf, "%s%2d%s) %s\r\n", grn, i, nrm, position_types[i]);
SEND_TO_Q(buf, d);
}
SEND_TO_Q("Enter position number : ", d);
}
/*
* Display Race menu.
*/
void medit_disp_race_flags(struct descriptor_data *d)
{
int i, columns = 0;
get_char_colors(d->character);
clear_screen(d);
for (i = 0; i < NUM_NPC_RACE; i++) {
sprintf(buf, "%s%2d%s) %-20.20s %s", grn, i, nrm, npc_race_types[i],
!(++columns % 3) ? "\r\n" : "");
SEND_TO_Q(buf, d);
}
sprintf(buf, "\r\nEnter race type: ");
SEND_TO_Q(buf, d);
}
/*
* Change the MobProg type.
*/
void medit_disp_mprog_types(struct descriptor_data *d)
{
int i;
get_char_colors(d->character);
clear_screen(d);
for (i = 0; i < NUM_PROGS-1; i++) {
sprintf(buf, "%s%2d%s) %s\r\n", grn, i, nrm, mobprog_types[i]);
SEND_TO_Q(buf, d);
}
SEND_TO_Q("Enter mob prog type : ", d);
OLC_MODE(d) = MEDIT_MPROG_TYPE;
}
/*
* Display affection flags menu.
*/
void medit_disp_aff_flags(struct descriptor_data *d)
{
int i, columns = 0;
get_char_colors(d->character);
clear_screen(d);
for (i = 0; i < NUM_AFF_FLAGS; i++) {
sprintf(buf, "%s%2d%s) %-20.20s %s", grn, i + 1, nrm, affected_bits[i],
!(++columns % 2) ? "\r\n" : "");
SEND_TO_Q(buf, d);
}
sprintbit(AFF_FLAGS(OLC_MOB(d)), affected_bits, buf1);
sprintf(buf, "\r\nCurrent flags : %s%s%s\r\nEnter aff flags (0 to quit) : ",
cyn, buf1, nrm);
SEND_TO_Q(buf, d);
}
/*
* Print the appropriate message for the command type for arg3 and set
* up the input catch clause.
*/
void zedit_disp_arg3(struct descriptor_data *d)
{
int i = 0;
switch (OLC_CMD(d).command) {
case 'E':
while (*equipment_types[i] != '\n') {
sprintf(buf, "%2d) %26.26s %2d) %26.26s\r\n", i,
equipment_types[i], i + 1, (*equipment_types[i + 1] != '\n') ?
equipment_types[i + 1] : "");
SEND_TO_Q(buf, d);
if (*equipment_types[i + 1] != '\n')
i += 2;
else
break;
}
SEND_TO_Q("Location to equip : ", d);
break;
case 'P':
SEND_TO_Q("Virtual number of the container : ", d);
break;
case 'D':
SEND_TO_Q( "0) Door open\r\n"
"1) Door closed\r\n"
"2) Door locked\r\n"
"Enter state of the door : ", d);
break;
case 'V':
send_to_char("Enter the global name: ", d->character);
OLC_MODE(d) = ZEDIT_SARG1;
return;
case 'M':
case 'O':
case 'R':
case 'G':
default:
/*
* We should never get here, just in case.
*/
cleanup_olc(d, CLEANUP_ALL);
mudlog("SYSERR: OLC: zedit_disp_arg3(): Help!", BRF, LVL_BUILDER, TRUE);
SEND_TO_Q("Oops...\r\n", d);
return;
}
OLC_MODE(d) = ZEDIT_ARG3;
}
/*
* 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;
}
void tedit_string_cleanup(struct descriptor_data *d, int terminator)
{
FILE *fl;
char *storage = (char *)d->olc;
if (!storage)
terminator = STRINGADD_ABORT;
switch (terminator) {
case STRINGADD_SAVE:
if (!(fl = fopen(storage, "w"))) {
sprintf(buf, "SYSERR: Can't write file '%s'.", storage);
mudlog(buf, CMP, LVL_IMPL, TRUE);
} else {
if (*d->str) {
strip_cr(*d->str);
fputs(*d->str, fl);
}
fclose(fl);
sprintf(buf, "OLC: %s saves '%s'.", GET_NAME(d->character), storage);
mudlog(buf, CMP, LVL_GOD, TRUE);
SEND_TO_Q("Saved.\r\n", d);
}
break;
case STRINGADD_ABORT:
SEND_TO_Q("Edit aborted.\r\n", d);
act("$n stops editing some scrolls.", TRUE, d->character, 0, 0, TO_ROOM);
break;
default:
log("SYSERR: tedit_string_cleanup: Unknown terminator status.");
break;
}
/* Common cleanup code. */
if (d->olc) {
free(d->olc);
d->olc = NULL;
}
STATE(d) = CON_PLAYING;
}
void send_to_zone(char *messg, int zone_rnum)
{
struct descriptor_data *i;
if (!messg || !*messg)
return;
for (i = descriptor_list; i; i = i->next)
if (STATE(i) == CON_PLAYING && i->character && AWAKE(i->character) &&
(IN_ROOM(i->character) != NOWHERE) &&
(world[IN_ROOM(i->character)].zone == zone_rnum))
SEND_TO_Q(messg, i);
}
/*
* Change the MobProgs.
*/
void medit_change_mprog(struct descriptor_data *d)
{
clear_screen(d);
sprintf(buf, "1) Type: %s\r\n"
"2) Args: %s\r\n"
"3) Commands:\r\n%s\r\n\r\n"
"Enter number to edit [0 to exit]: ",
medit_get_mprog_type(OLC_MPROG(d)),
(OLC_MPROG(d)->arglist ? OLC_MPROG(d)->arglist: "NONE"),
(OLC_MPROG(d)->comlist ? OLC_MPROG(d)->comlist : "NONE"));
SEND_TO_Q(buf, d);
OLC_MODE(d) = MEDIT_CHANGE_MPROG;
}
// Check if name agree (name must be parsed)
int was_agree_name(DESCRIPTOR_DATA * d)
{
log("was_agree_name start");
FILE *fp;
char temp[MAX_INPUT_LENGTH];
char immname[MAX_INPUT_LENGTH];
char mortname[6][MAX_INPUT_LENGTH];
int immlev;
int sex;
int i;
//1. Load list
if (!(fp = fopen(ANAME_FILE, "r")))
{
perror("SYSERR: Unable to open '" ANAME_FILE "' for reading");
log("was_agree_name end");
return (1);
}
//2. Find name in list ...
while (get_line(fp, temp))
{
// Format First name/pad1/pad2/pad3/pad4/pad5/sex immname immlev
sscanf(temp, "%s %s %s %s %s %s %d %s %d", mortname[0],
mortname[1], mortname[2], mortname[3], mortname[4], mortname[5], &sex, immname, &immlev);
if (!strcmp(mortname[0], GET_NAME(d->character)))
{
// We find char ...
for (i = 1; i < 6; i++)
{
GET_PAD(d->character, i) = str_dup(mortname[i]);
}
GET_SEX(d->character) = sex;
// Auto-Agree char ...
NAME_GOD(d->character) = immlev + 1000;
NAME_ID_GOD(d->character) = get_id_by_name(immname);
sprintf(buf, "\r\nВаше имя одобрено!\r\n");
SEND_TO_Q(buf, d);
sprintf(buf, "AUTOAGREE: %s was agreed by %s", GET_PC_NAME(d->character), immname);
log(buf, d);
fclose(fp);
log("was_agree_name end");
return (0);
}
}
fclose(fp);
log("was_agree_name end");
return (1);
}
/*
* Print the command type menu and setup response catch.
*/
void zedit_disp_comtype(struct descriptor_data *d)
{
get_char_colors(d->character);
clear_screen(d);
sprintf(buf,
"%sM%s) Load Mobile to room %sO%s) Load Object to room\r\n"
"%sE%s) Equip mobile with object %sG%s) Give an object to a mobile\r\n"
"%sP%s) Put object in another object %sD%s) Open/Close/Lock a Door\r\n"
"%sR%s) Remove an object from the room\r\n"
"What sort of command will this be? : ",
grn, nrm, grn, nrm, grn, nrm, grn, nrm, grn, nrm,
grn, nrm, grn, nrm
);
SEND_TO_Q(buf, d);
OLC_MODE(d) = ZEDIT_COMMAND_TYPE;
}
int was_disagree_name(DESCRIPTOR_DATA * d)
{
log("was_disagree_name start");
FILE *fp;
char temp[MAX_INPUT_LENGTH];
char mortname[MAX_INPUT_LENGTH];
char immname[MAX_INPUT_LENGTH];
int immlev;
if (!(fp = fopen(DNAME_FILE, "r")))
{
perror("SYSERR: Unable to open '" DNAME_FILE "' for reading");
log("was_disagree_name end");
return (1);
}
//1. Load list
//2. Find name in list ...
//3. Compare names ... get next
while (get_line(fp, temp))
{
// Extract chars and
sscanf(temp, "%s %s %d", mortname, immname, &immlev);
if (!strcmp(mortname, GET_NAME(d->character)))
{
// Char found all ok;
sprintf(buf, "\r\nВаше имя запрещено!\r\n");
SEND_TO_Q(buf, d);
sprintf(buf, "AUTOAGREE: %s was disagreed by %s", GET_PC_NAME(d->character), immname);
log(buf, d);
fclose(fp);
log("was_disagree_name end");
return (0);
};
}
fclose(fp);
log("was_disagree_name end");
return (1);
}
int
new_descriptor (int s)
{
int desc;
struct sockaddr_in sock;
DESCRIPTOR_DATA *newd, *td;
char ip[MAX_STRING_LENGTH];
struct hostent *from = NULL;
socklen_t size;
size = sizeof (sock);
if ((desc = accept (s, (struct sockaddr *) &sock, &size)) < 0)
{
perror ("Accept");
return (-1);
}
nonblock (desc);
if ((maxdesc + 1) >= avail_descs)
{
write (desc, "The game is full. Try later.\n\r", 31);
close (desc);
return (0);
}
else if (desc > maxdesc)
maxdesc = desc;
newd = new struct descriptor_data;
init_descriptor (newd, desc);
*ip = '\0';
strcpy (ip, inet_ntoa (sock.sin_addr));
newd->strClientIpAddr = str_dup (ip);
newd->strClientHostname = str_dup (ip);
std::string resolved_hostname = resolved_host (newd->strClientHostname);
if (resolved_hostname.empty ())
{
from = gethostbyaddr ((char *) &sock.sin_addr,
sizeof ((char *) & sock.sin_addr),
AF_INET);
if (from && *from->h_name != '-')
{
mysql_safe_query ("INSERT INTO resolved_hosts "
"VALUES ('%s', '%s', %d)",
ip, from->h_name, (int) time (0));
mem_free (newd->strClientHostname);
newd->strClientHostname = str_dup (from->h_name);
}
else
{
mysql_safe_query
("INSERT INTO resolved_hosts VALUES ('%s', '%s', %d)", ip, ip,
(int) time (0));
}
}
else
{
mem_free (newd->strClientHostname);
newd->strClientHostname = str_dup (resolved_hostname.c_str ());
newd->resolved = 1;
}
if (!descriptor_list)
descriptor_list = newd;
else
for (td = descriptor_list; td; td = td->next)
{
if (!td->next)
{
newd->next = NULL;
td->next = newd;
break;
}
}
if (connected > MAX_CONNECTIONS)
{
SEND_TO_Q ("\r\n"
"We apologize for the inconvenience, but the MUD is currently full.\r\n"
"\r\n"
"Please try back again later. Thank you.\r\n" "\r\n", newd);
newd->connected = CON_PENDING_DISC;
return (0);
}
if (!maintenance_lock)
SEND_TO_Q (get_text_buffer (NULL, text_list, "greetings"), newd);
else
SEND_TO_Q (get_text_buffer (NULL, text_list, "greetings.maintenance"),
newd);
SEND_TO_Q ("Your Selection: ", newd);
newd->connected = CON_LOGIN;
return (0);
}
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);
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\n", d);
SEND_TO_Q("Do you wish to save the zone info? : ", 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 the changes to the zone info? (y//n) : ", 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_IMPL)
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;
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':
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));
zedit_disp_arg4(d);
break;
case 'G':
OLC_CMD(d).arg2 = atoi(arg);
zedit_disp_arg4(d);
break;
case 'P':
case 'E':
OLC_CMD(d).arg2 = atoi(arg);
zedit_disp_arg3(d);
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 goto arg4's 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_arg4(d);
}
break;
case 'P':
if ((pos = real_object(atoi(arg))) >= 0) {
OLC_CMD(d).arg3 = pos;
zedit_disp_arg4(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_arg4(d);
}
break;
case 'M':
case 'O':
case 'G':
case 'R':
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_ARG4:
/*
* Parse the input for arg4, 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 'M':
case 'O':
case 'G':
case 'E':
pos = atoi(arg);
if (pos < 0 || pos > 100)
SEND_TO_Q("Try again : ", d);
else {
OLC_CMD(d).arg4 = pos;
zedit_disp_menu(d);
}
break;
case 'P':
case 'D':
OLC_CMD(d).arg3 = 100;
break;
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_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_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;
/*-------------------------------------------------------------------*/
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;
}
}
/**
* Проверка стартовых и итоговых статов.
* Если невалидные стартовые статы - чар отправляется на реролл.
* Если невалидные только итоговые статы - идет перезапись со стартовых с учетом мортов и славы.
*/
bool check_stats(CHAR_DATA *ch)
{
// иммов травмировать не стоит
if (IS_IMMORTAL(ch))
{
return 1;
}
int have_stats = ch->get_inborn_str() + ch->get_inborn_dex() + ch->get_inborn_int() + ch->get_inborn_wis()
+ ch->get_inborn_con() + ch->get_inborn_cha();
// чар со старым роллом статов или после попыток поправить статы в файле
if (bad_start_stats(ch))
{
snprintf(buf, MAX_STRING_LENGTH, "\r\n%sВаши параметры за вычетом перевоплощений:\r\n"
"Сила: %d, Ловкость: %d, Ум: %d, Мудрость: %d, Телосложение: %d, Обаяние: %d\r\n"
"Если вы долго отсутствовали в игре, то изменения, касающиеся стартовых параметров были следующие:%s\r\n"
"\r\n"
"\tДобавлено ограничение на максимальный класс защиты:\r\n"
"\tВоры, наемники и дружинники - -250\r\n"
"\tКупцы, богатыри, витязи, охотники, кузнецы - -200\r\n"
"\tЛекари, волхвы - -150\r\n"
"\tКудесники, чернокнижники, колдуны, волшебники - -100\r\n"
"\r\n"
"\tТелосложение: изменились коэффициенты профессий и максимальное родное тело (50) в расчетах при\r\n"
"\tполучении уровня, поэтому изменены границы стартового телосложения у некоторых профессий,\r\n"
"\tв целом это увеличивает кол-во жизней персонажа тем сильнее, чем больше у него было ремортов.\r\n"
"\r\n",
CCIGRN(ch, C_SPR),
ch->get_inborn_str() - GET_REMORT(ch),
ch->get_inborn_dex() - GET_REMORT(ch),
ch->get_inborn_int() - GET_REMORT(ch),
ch->get_inborn_wis() - GET_REMORT(ch),
ch->get_inborn_con() - GET_REMORT(ch),
ch->get_inborn_cha() - GET_REMORT(ch),
CCNRM(ch, C_SPR));
SEND_TO_Q(buf, ch->desc);
// данную фигню мы делаем для того, чтобы из ролла нельзя было случайно так просто выйти
// сразу, не раскидав статы, а то много любителей тригов и просто нажатий не глядя
ch->set_str(MIN_STR(ch));
ch->set_dex(MIN_DEX(ch));
ch->set_int(MIN_INT(ch));
ch->set_wis(MIN_WIS(ch));
ch->set_con(MIN_CON(ch));
ch->set_cha(MIN_CHA(ch));
snprintf(buf, MAX_STRING_LENGTH, "%sПросим вас заново распределить основные параметры персонажа.%s\r\n",
CCIGRN(ch, C_SPR), CCNRM(ch, C_SPR));
SEND_TO_Q(buf, ch->desc);
SEND_TO_Q("\r\n* В связи с проблемами перевода фразы ANYKEY нажмите ENTER *", ch->desc);
STATE(ch->desc) = CON_RESET_STATS;
return 0;
}
// стартовые статы в поряде, но слава не сходится (снялась по времени или иммом)
if (bad_real_stats(ch, have_stats))
{
recalculate_stats(ch);
}
return 1;
}
/*
* 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;
}
/*
* 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"
"%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)->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, Percent: %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, Percent: %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, Percent: %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, Percent: %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",
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
);
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;
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.\r\n"
"%sE%s) Edit a command.\r\n"
"%sD%s) Delete a command.\r\n"
"%sQ%s) Quit\r\nEnter your choice : ",
nrm, counter, grn, nrm, grn, nrm, grn, nrm, grn, nrm
);
strcat(buf, buf1);
SEND_TO_Q(buf, d);
OLC_MODE(d) = ZEDIT_MAIN_MENU;
}
/*
* Save all the information in the player's temporary buffer back into
* the current zone table.
*/
void zedit_save_internally(struct descriptor_data *d)
{
int mobloaded = FALSE,
objloaded = FALSE,
subcmd = 0,
room_num = real_room(OLC_NUM(d));
remove_room_zone_commands(OLC_ZNUM(d), room_num);
/*
* Now add all the entries in the players descriptor list
*/
for (subcmd = 0; MYCMD.command != 'S'; subcmd++) {
add_cmd_to_list(&(zone_table[OLC_ZNUM(d)].cmd), &MYCMD, subcmd);
/*
* Since Circle does not keep track of what rooms the 'G', 'E', and
* 'P' commands are exitted in, but OasisOLC groups zone commands
* by rooms, this creates interesting problems when builders use these
* commands without loading a mob or object first. This fix prevents such
* commands from being saved and 'wandering' through the zone command
* list looking for mobs/objects to latch onto.
* C.Raehl 4/27/99
*/
switch (MYCMD.command) {
case 'M':
mobloaded = TRUE;
break;
case 'G':
case 'E':
if (mobloaded)
break;
SEND_TO_Q("Equip/Give command not saved since no mob was loaded first.\r\n", d);
remove_cmd_from_list(&(OLC_ZONE(d)->cmd), subcmd);
break;
case 'O':
objloaded = TRUE;
break;
case 'P':
if (objloaded)
break;
SEND_TO_Q("Put command not saved since another object was not loaded first.\r\n", d);
remove_cmd_from_list(&(OLC_ZONE(d)->cmd), subcmd);
break;
default:
mobloaded = objloaded = FALSE;
break;
}
}
/*
* Finally, if zone headers have been changed, copy over
*/
if (OLC_ZONE(d)->number) {
free(zone_table[OLC_ZNUM(d)].name);
zone_table[OLC_ZNUM(d)].name = str_dup(OLC_ZONE(d)->name);
zone_table[OLC_ZNUM(d)].top = OLC_ZONE(d)->top;
zone_table[OLC_ZNUM(d)].reset_mode = OLC_ZONE(d)->reset_mode;
zone_table[OLC_ZNUM(d)].lifespan = OLC_ZONE(d)->lifespan;
}
add_to_save_list(zone_table[OLC_ZNUM(d)].number, SL_ZON);
}
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;
}
void wedit_parse(struct descriptor_data *d, char *arg)
{
int number ;
switch (OLC_MODE(d))
{
case WEDIT_CONFIRM_SAVESTRING:
switch (*arg)
{
case 'y':
case 'Y':
wedit_save_internally(d);
sprintf(buf, "OLC: %s edits wild element %d.", GET_NAME(d->character), OLC_NUM(d));
mudlog(buf, CMP, MAX(LVL_BUILDER, GET_INVIS_LEV(d->character)), TRUE);
/*
* Do NOT free strings! Just the wild element structure.
*/
cleanup_olc(d, CLEANUP_STRUCTS);
send_to_char("Wild element saved to memory.\r\n", d->character);
break;
case 'n':
case 'N':
/*
* Free everything up, including strings, etc.
*/
cleanup_olc(d, CLEANUP_ALL);
break;
default:
send_to_char("Invalid choice!\r\nDo you wish to save this wild element internally? : ", d->character);
break;
}
return;
case WEDIT_MAIN_MENU:
switch (*arg)
{
case 'q':
case 'Q':
if (OLC_VAL(d)) /* Something has been modified. */
{
send_to_char("Do you wish to save this wild element internally? : ", d->character);
OLC_MODE(d) = WEDIT_CONFIRM_SAVESTRING;
}
else cleanup_olc(d, CLEANUP_ALL);
return;
case '1':
send_to_char("Enter wild type name:-\r\n] ", d->character);
OLC_MODE(d) = WEDIT_NAME;
break;
case '2':
OLC_MODE(d) = WEDIT_DESC;
#if defined(CLEAR_SCREEN)
SEND_TO_Q("\x1B[H\x1B[J", d);
#endif
SEND_TO_Q("Enter wild type description: (/s saves /h for help)\r\n\r\n", d);
d->backstr = NULL;
if (OLC_WILD(d)->description)
{
SEND_TO_Q(OLC_WILD(d)->description, d);
d->backstr = str_dup(OLC_WILD(d)->description);
}
d->str = &OLC_WILD(d)->description;
d->max_str = MAX_ROOM_DESC;
d->mail_to = 0;
OLC_VAL(d)=1;
break;
case '3':
send_to_char("Enter wild type symbol: \r\n", d->character);
OLC_MODE(d) = WEDIT_SYMBOL;
break;
case '4':
wedit_disp_color_menu(d);
break;
case '5':
wedit_disp_flag_menu(d);
break;
case '6':
wedit_disp_sector_menu(d);
break;
case '7':
send_to_char("Enter wild type movement cost: \r\n", d->character);
OLC_MODE(d) = WEDIT_MOVE_COST;
break;
case '8':
send_to_char("Enter wild type altitudine: \r\n", d->character);
OLC_MODE(d) = WEDIT_ALTITUDINE;
break;
case '9':
if (OLC_WILD(d)->can_enter==TRUE) OLC_WILD(d)->can_enter=FALSE;
else OLC_WILD(d)->can_enter=TRUE;
OLC_VAL(d) = 1;
wedit_disp_menu(d);
break;
case 'a':
case 'A':
send_to_char("This hasn't been implemented yet\r\n", d->character);
wedit_disp_menu(d);
break;
default:
send_to_char("Invalid choice!\r\n", d->character);
wedit_disp_menu(d);
break;
}
return;
case WEDIT_NAME:
if (OLC_WILD(d)->name)
free(OLC_WILD(d)->name);
if (strlen(arg) > MAX_ROOM_NAME)
arg[MAX_ROOM_NAME - 1] = '\0';
OLC_WILD(d)->name = str_dup((arg && *arg) ? arg : "undefined");
break;
case WEDIT_DESC:
/*
* We will NEVER get here, we hope.
*/
mudlog("SYSERR: Reached WEDIT_DESC case in parse_wedit", BRF, LVL_BUILDER, TRUE);
break;
case WEDIT_SYMBOL:
if (!*arg)
{
send_to_char("Invalid choice!", d->character);
wedit_disp_menu(d);
return;
}
else OLC_WILD(d)->symbol = *arg;
break;
case WEDIT_COLOR:
number = atoi(arg);
if (number < 1 || number > NUM_WILD_COLOR)
{
send_to_char("Invalid choice!", d->character);
wedit_disp_color_menu(d);
return;
}
else OLC_WILD(d)->color = number;
break;
case WEDIT_FLAGS:
number = atoi(arg);
if ((number < 0) || (number > NUM_ROOM_FLAGS))
{
send_to_char("That is not a valid choice!\r\n", d->character);
wedit_disp_flag_menu(d);
}
else if (number == 0) break;
else
{
/*
* Toggle the bit.
*/
TOGGLE_BIT(OLC_WILD(d)->room_flags, 1 << (number - 1));
wedit_disp_flag_menu(d);
}
return;
case WEDIT_SECTOR:
number = atoi(arg);
if (number < 0 || number >= NUM_ROOM_SECTORS)
{
send_to_char("Invalid choice!", d->character);
wedit_disp_sector_menu(d);
return;
}
else OLC_WILD(d)->sector_type = number;
break;
case WEDIT_MOVE_COST:
number = atoi(arg);
if (number < 1 || number > MAX_WILD_MOVE_COST)
{
send_to_char("Invalid choice!", d->character);
wedit_disp_menu(d);
return;
}
else OLC_WILD(d)->move_cost = number;
break;
case WEDIT_ALTITUDINE:
number = atoi(arg);
if (number < 1 || number > MAX_WILD_ALTITUDINE)
{
send_to_char("Invalid choice!", d->character);
wedit_disp_menu(d);
return;
}
else OLC_WILD(d)->altitudine = number;
break;
default:
/*
* We should never get here.
*/
mudlog("SYSERR: Reached default case in parse_wedit", BRF, LVL_BUILDER, TRUE);
break;
}
/*
* If we get this far, something has been changed.
*/
OLC_VAL(d) = 1;
wedit_disp_menu(d);
}
/* Extract a ch completely from the world, and leave his stuff behind */
void extract_char(struct char_data * ch)
{
struct char_data *k, *temp;
struct descriptor_data *t_desc;
struct obj_data *obj;
int i, freed = 0;
//int j;
extern struct char_data *combat_list;
ACMD(do_return);
void die_follower(struct char_data * ch);
if (!IS_NPC(ch) && !ch->desc) {
for (t_desc = descriptor_list; t_desc; t_desc = t_desc->next) {
if (t_desc->original == ch) {
do_return(t_desc->character, "", 0, 0);
}
}
}
if (ch->in_room == NOWHERE) {
log("SYSERR: NOWHERE extracting char. (handler.c, extract_char)");
exit(1);
}
if (ch->followers || ch->master) {
die_follower(ch);
}
if (RIDING(ch) || RIDDEN_BY(ch))
dismount_char(ch);
REMOVE_BIT(PLR_FLAGS(ch), PLR_FISHING);
REMOVE_BIT(PLR_FLAGS(ch), PLR_FISH_ON);
REMOVE_BIT(PLR_FLAGS(ch), PLR_DIGGING);
REMOVE_BIT(PLR_FLAGS(ch), PLR_DIG_ON);
REMOVE_BIT(PLR_FLAGS(ch), PLR_FIRE_ON);
REMOVE_BIT(PRF_FLAGS(ch), PRF_NOTSELF);
//REMOVE_BIT(PRF_FLAGS(ch), PRF_DISGUISE);
//REMOVE_BIT(PLR_FLAGS(ch), PLR_MAGE);
//REMOVE_BIT(PLR_FLAGS(ch), PLR_MONK);
//REMOVE_BIT(PLR_FLAGS(ch), PLR_KNIGHT);
//REMOVE_BIT(PLR_FLAGS(ch), PLR_CLERIC);
//REMOVE_BIT(PLR_FLAGS(ch), PLR_BARD);
//REMOVE_BIT(PLR_FLAGS(ch), PLR_BEGGAR);
REMOVE_BIT(PLR_FLAGS(ch), PLR_COURIER);
REMOVE_BIT(PLR_FLAGS(ch), PLR_BEAR);
REMOVE_BIT(PLR_FLAGS(ch), PLR_BIRD);
REMOVE_BIT(PLR_FLAGS(ch), PLR_WOLF);
REMOVE_BIT(PLR_FLAGS(ch), PLR_RABBIT);
REMOVE_BIT(PLR_FLAGS(ch), PLR_CAT);
/* Forget snooping, if applicable */
if (ch->desc) {
if (ch->desc->snooping) {
ch->desc->snooping->snoop_by = NULL;
ch->desc->snooping = NULL;
}
if (ch->desc->snoop_by) {
SEND_TO_Q("Your victim is no longer among us.\r\n",
ch->desc->snoop_by);
ch->desc->snoop_by->snooping = NULL;
ch->desc->snoop_by = NULL;
}
}
/* transfer objects to room, if any */
while (ch->carrying) {
obj = ch->carrying;
obj_from_char(obj);
obj_to_room(obj, ch->in_room);
}
/* transfer equipment to room, if any */
for (i = 0; i < NUM_WEARS; i++) {
if (GET_EQ(ch, i)) {
obj_to_room(unequip_char(ch, i), ch->in_room);
}
}
if (FIGHTING(ch)) {
stop_fighting(ch);
}
for (k = combat_list; k; k = temp) {
temp = k->next_fighting;
if (FIGHTING(k) == ch) {
stop_fighting(k);
}
}
char_from_room(ch);
/* pull the char from the list */
REMOVE_FROM_LIST(ch, character_list, next);
if (ch->desc && ch->desc->original) {
do_return(ch, NULL, 0, 0);
}
if (!IS_NPC(ch)) {
save_char(ch, NOWHERE);
Crash_delete_crashfile(ch);
} else {
if (GET_MOB_RNUM(ch) > -1) { /* if mobile */
mob_index[GET_MOB_RNUM(ch)].number--;
}
clearMemory(ch); /* Only NPC's can have memory */
if (SCRIPT(ch)) {
extract_script(SCRIPT(ch));
}
free_char(ch);
freed = 1;
}
if (!freed && ch->desc != NULL) {
STATE(ch->desc) = CON_MENU;
SEND_TO_Q(MENU, ch->desc);
} else { /* if a player gets purged from within the game */
if (ch->master || ch->followers)
die_follower(ch);
if (!freed) {
free_char(ch);
}
}
}
/* Extract a ch completely from the world, and leave his stuff behind */
void extract_char_smarter(struct char_data *ch, int save_room)
{
struct obj_data *i;
struct char_data *k, *next_char;
struct descriptor_data *t_desc;
int l, was_in, j;
extern long mob_count;
extern struct char_data *combat_list;
void do_save(struct char_data *ch, char *argument, int cmd);
void do_return(struct char_data *ch, char *argument, int cmd);
void die_follower(struct char_data *ch);
if(IS_SET(ch->specials.act, ACT_FIGURINE) && ch->link)
extract_obj(ch->link);
if(!IS_NPC(ch) && !ch->desc) {
for(t_desc = descriptor_list; t_desc; t_desc = t_desc->next)
if(t_desc->original==ch)
do_return(t_desc->character, "", 0);
}
if (ch->in_room == NOWHERE) {
logE("NOWHERE extracting char. (handler.c, extract_char)");
/*
** problem from linkdeath
*/
char_to_room(ch, 4); /* 4 == all purpose store */
}
if (ch->followers || ch->master)
die_follower(ch);
if(ch->desc) {
/* Forget snooping */
if ((ch->desc->snoop.snooping) && (ch->desc->snoop.snooping->desc))
ch->desc->snoop.snooping->desc->snoop.snoop_by = 0;
if (ch->desc->snoop.snoop_by) {
send_to_char("Your victim is no longer among us.\n\r",
ch->desc->snoop.snoop_by);
if (ch->desc->snoop.snoop_by->desc)
ch->desc->snoop.snoop_by->desc->snoop.snooping = 0;
}
ch->desc->snoop.snooping = ch->desc->snoop.snoop_by = 0;
}
if (ch->carrying) {
/* transfer ch's objects to room */
if (!IS_IMMORTAL(ch)) {
while(ch->carrying) {
i=ch->carrying;
obj_from_char(i);
obj_to_room(i, ch->in_room);
check_falling_obj(i, ch->in_room);
}
} else {
send_to_char("Here, you dropped some stuff, let me help you get rid of that.\n\r",ch);
/*
equipment too
*/
for (j=0; j<MAX_WEAR; j++) {
if (ch->equipment[j])
obj_to_char(unequip_char(ch, j), ch);
}
while (ch->carrying) {
i = ch->carrying;
obj_from_char(i);
extract_obj(i);
}
}
}
if (ch->specials.fighting)
stop_fighting(ch);
for (k = combat_list; k ; k = next_char) {
next_char = k->next_fighting;
if (k->specials.fighting == ch)
stop_fighting(k);
}
if (MOUNTED(ch)) {
Dismount(ch, MOUNTED(ch), POSITION_STANDING);
}
if (RIDDEN(ch)) {
Dismount(RIDDEN(ch), ch, POSITION_STANDING);
}
/* Must remove from room before removing the equipment! */
was_in = ch->in_room;
char_from_room(ch);
/* clear equipment_list */
for (l = 0; l < MAX_WEAR; l++)
if (ch->equipment[l])
obj_to_room(unequip_char(ch,l), was_in);
if (IS_NPC(ch)) {
for (k=character_list; k; k=k->next) {
if (k->specials.hunting)
if (k->specials.hunting == ch) {
k->specials.hunting = 0;
}
if (Hates(k, ch)) {
RemHated(k, ch);
}
if (Fears(k, ch)) {
RemFeared(k, ch);
}
if (k->orig == ch) {
k->orig = 0;
}
}
} else {
for (k=character_list; k; k=k->next) {
if (k->specials.hunting)
if (k->specials.hunting == ch) {
k->specials.hunting = 0;
}
if (Hates(k, ch)) {
ZeroHatred(k, ch);
}
if (Fears(k, ch)) {
ZeroFeared(k, ch);
}
if (k->orig == ch) {
k->orig = 0;
}
}
}
/* pull the char from the list */
if (ch == character_list)
character_list = ch->next;
else {
for(k = character_list; (k) && (k->next != ch); k = k->next);
if(k)
k->next = ch->next;
else {
logE("Trying to remove ?? from character_list.(handler.c,extract_char)");
exit(0);
}
}
if (ch->specials.gname)
free(ch->specials.gname);
GET_AC(ch) = 100;
if (ch->desc) {
if (ch->desc->original)
do_return(ch, "", 0);
if (!strcmp(GET_NAME(ch), "Odin's heroic minion")) {
free(GET_NAME(ch));
GET_NAME(ch) = strdup("111111");
}
save_char(ch, save_room);
}
t_desc = ch->desc;
if(ch->term) {
ScreenOff(ch);
ch->term = 0;
}
if (IS_NPC(ch)) {
if (ch->nr > -1) /* if mobile */
mob_index[ch->nr].number--;
FreeHates(ch);
FreeFears(ch);
mob_count--;
free_char(ch);
}
if (t_desc) {
t_desc->connected = CON_SLCT;
SEND_TO_Q(MENU, t_desc);
}
}
/*
* Load a char and inventory into a new ch structure.
*/
bool load_char_obj( struct descriptor_data * d, const char * name )
{
FILE *fp;
struct char_data *ch;
char strsave [ MAX_INPUT_LENGTH ];
bool found;
char sorry_player [] =
"********************************************************\n\r"
"** One or more of the critical fields in your player **\n\r"
"** file were corrupted since you last played. Please **\n\r"
"** contact an administrator or programmer to **\n\r"
"** investigate the recovery of your characters. **\n\r"
"********************************************************\n\r";
char sorry_object [] =
"********************************************************\n\r"
"** One or more of the critical fields in your player **\n\r"
"** file were corrupted leading to the loss of one or **\n\r"
"** more of your possessions. **\n\r"
"********************************************************\n\r";
char sorry_alias [] =
"********************************************************\n\r"
"** One or more of the critical fields in your player **\n\r"
"** file were corrupted leading to the loss of one or **\n\r"
"** more of your aliases. **\n\r"
"********************************************************\n\r";
ch = new_character( TRUE );
d->character = ch;
GET_DESC(ch) = d;
ch->player.name = str_dup( name );
/*
ch->pcdata->prompt = str_dup( daPrompt );
ch->last_note = 0;
*/
strcpy( GET_PASSWD(ch), "" );
POOFIN(ch) = str_dup( "" );
POOFOUT(ch) = str_dup( "" );
GET_TITLE(ch) = str_dup( "" );
GET_STR(ch) = 10;
GET_ADD(ch) = 10;
GET_INT(ch) = 10;
GET_WIS(ch) = 10;
GET_DEX(ch) = 10;
GET_CON(ch) = 10;
GET_CHA(ch) = 10;
GET_WILL(ch) = 10;
GET_COND(ch, DRUNK) = 48;
GET_COND(ch, FULL) = 48;
GET_COND(ch, THIRST) = 48;
GET_COND(ch, TIRED) = 48;
// ch->pcdata->switched = FALSE;
found = FALSE;
fclose( fpReserve );
/* parsed player file directories by Yaz of 4th Realm */
/* decompress if .gz file exists - Thx Alander */
sprintf( strsave, "%s/%s/%s%s", PLAYER_DIR,
player_dir( GET_NAME(ch) ),
capitalize( GET_NAME(ch) ), ".gz" );
if ( ( fp = fopen( strsave, "r" ) ) ) {
char buf [ MAX_STRING_LENGTH ];
fclose( fp );
sprintf( buf, "gzip -dfq %s", strsave );
system( buf );
}
sprintf( strsave, "%s/%s/%s", PLAYER_DIR,
player_dir( GET_NAME(ch) ),
capitalize( GET_NAME(ch) ) );
if ( ( fp = fopen( strsave, "r" ) ) ) {
char buf[ MAX_STRING_LENGTH ];
int iNest;
for ( iNest = 0; iNest < MAX_NEST; iNest++ )
rgObjNest[iNest] = NULL;
found = TRUE;
for ( ; ; )
{
char *word;
char letter;
int status;
letter = fread_letter( fp );
if ( letter == '*' )
{
fread_to_eol( fp );
continue;
}
if ( letter != '#' )
{
log( "Load_char_obj: # not found." );
break;
}
word = fread_word_stat( fp, &status );
if ( !str_cmp( word, "PLAYER" ) )
{
if ( fread_char ( ch, fp ) )
{
sprintf( buf,
"Load_char_obj: %s section PLAYER corrupt.\n\r",
name );
log( buf );
SEND_TO_Q( sorry_player, d );
/*
* In case you are curious,
* it is ok to leave ch alone for close_socket
* to free.
* We want to now kick the bad character out as
* what we are missing are MANDATORY fields. -Kahn
*/
SET_BIT( PRF_FLAGS(ch), PLR_DELETED );
return TRUE;
}
}
else if ( !str_cmp( word, "OBJECT" ) )
{
if ( !fread_obj_char( ch, fp ) )
{
sprintf( buf,
"Load_char_obj: %s section OBJECT corrupt.\n\r",
name );
log( buf );
SEND_TO_Q( sorry_object, d );
return FALSE;
}
}
else if ( !str_cmp( word, "ALIAS" ) ) {
if ( !fread_alias( ch, fp ) )
{
sprintf( buf,
"Load_char_obj: %s section ALIAS corrupt.\n\r",
name );
log( buf );
SEND_TO_Q( sorry_alias, d );
return FALSE;
}
}
else if ( !str_cmp( word, "END" ) ) break;
else
{
log( "Load_char_obj: bad section." );
break;
}
} /* for */
fclose( fp );
}
fpReserve = fopen( NULL_FILE, "r" );
if ( found )
rent_adjust( d->character );
return found;
}