agroschim/grenzland-mud
1
0
Fork 0
forked from kyonshi/grenzland-mud
Code Pull Requests Activity
Files
b06cf00639b1918323f42b80549d43a693b22c08
grenzland-mud/src/house.c

1461 lines
42 KiB
C
Raw Blame History

/**************************************************************************
* File: house.c Part of tbaMUD *
* Usage: Handling of player houses. *
* *
* All rights reserved. See license for complete information. *
* *
* Copyright (C) 1993, 94 by the Trustees of the Johns Hopkins University *
* CircleMUD is based on DikuMUD, Copyright (C) 1990, 1991. *
**************************************************************************/
#include "conf.h"
#include "sysdep.h"
#include "structs.h"
#include "utils.h"
#include "comm.h"
#include "handler.h"
#include "db.h"
#include "interpreter.h"
#include "act.h"
#include "house.h"
#include "constants.h"
#include "modify.h"
#include "genolc.h"
#include "screen.h"
/* local globals */
struct house_control_data *house_control = NULL;
/* External Functions */
const char *get_spec_func_name(SPECIAL(*func));
/* local functions */
static int House_get_filename(room_vnum vnum, char *filename, size_t maxlen);
static int House_load(room_vnum vnum);
static void House_restore_weight(struct obj_data *obj);
static void hcontrol_build_house(struct char_data *ch, char *arg);
static void hcontrol_destroy_house(struct char_data *ch, char *arg);
static void hcontrol_pay_house(struct char_data *ch, char *arg);
static void House_listrent(struct char_data *ch, room_vnum vnum);
/* Control List Functions */
/* House loading */
static void parse_house_flags(struct house_control_data *h, char *line);
static void parse_house_guests(struct house_control_data *h, FILE *fl);
/* CONVERSION code starts here -- see comment below. */
static int ascii_convert_house(struct char_data *ch, obj_vnum vnum);
static void hcontrol_convert_houses(struct char_data *ch);
static struct obj_data *Obj_from_store(struct obj_file_elem object, int *location);
/* CONVERSION code ends here -- see comment below. */
/* First, the basics: finding the filename; loading/saving objects */
/* Return a filename given a house vnum */
static int House_get_filename(room_vnum vnum, char *filename, size_t maxlen)
{
if (vnum == NOWHERE)
return (0);
snprintf(filename, maxlen, LIB_HOUSE"%d.house", vnum);
return (1);
}
/* Load all objects for a house */
static int House_load(room_vnum vnum)
{
FILE *fl;
char filename[MAX_STRING_LENGTH];
obj_save_data *loaded, *current;
room_rnum rnum;
if ((rnum = real_room(vnum)) == NOWHERE)
return (0);
if (!House_get_filename(vnum, filename, sizeof(filename)))
return (0);
if (!(fl = fopen(filename, "r"))) /* no file found */
return (0);
loaded = objsave_parse_objects(fl);
for (current = loaded; current != NULL; current = current->next)
obj_to_room(current->obj, rnum);
/* now it's safe to free the obj_save_data list - all members of it
* have been put in the correct lists by obj_to_room()
*/
while (loaded != NULL) {
current = loaded;
loaded = loaded->next;
free(current);
}
fclose(fl);
return (1);
}
/* Save all objects for a house (recursive; initial call must be followed by a
* call to House_restore_weight) Assumes file is open already. */
int House_save(struct obj_data *obj, FILE *fp)
{
struct house_control_data *hse;
struct obj_data *tmp;
int result;
room_vnum rv;
if (!obj) return(1);
rv = world[(IN_ROOM(obj))].number;
hse = find_house(rv);
/* NORENT objects are skipped, unless house is flagged to save them */
if ( obj && (!OBJ_FLAGGED(obj, ITEM_NORENT) || HOUSE_FLAGGED(hse, HOUSE_SAVENORENT)) ) {
House_save(obj->contains, fp);
House_save(obj->next_content, fp);
result = objsave_save_obj_record(obj, fp, 0);
if (!result)
return (0);
for (tmp = obj->in_obj; tmp; tmp = tmp->in_obj)
GET_OBJ_WEIGHT(tmp) -= GET_OBJ_WEIGHT(obj);
}
return (1);
}
/* restore weight of containers after House_save has changed them for saving */
static void House_restore_weight(struct obj_data *obj)
{
if (obj) {
House_restore_weight(obj->contains);
House_restore_weight(obj->next_content);
if (obj->in_obj)
GET_OBJ_WEIGHT(obj->in_obj) += GET_OBJ_WEIGHT(obj);
}
}
/* Save all objects in a house */
void House_crashsave(room_vnum vnum)
{
int rnum;
char buf[MAX_STRING_LENGTH];
FILE *fp;
struct house_control_data *hse;
hse = find_house(vnum);
if (hse && HOUSE_FLAGGED(hse, HOUSE_NOSAVE))
return;
if ((rnum = real_room(vnum)) == NOWHERE)
return;
if (!House_get_filename(vnum, buf, sizeof(buf)))
return;
if (!(fp = fopen(buf, "wb"))) {
perror("SYSERR: Error saving house file");
return;
}
if (!House_save(world[rnum].contents, fp)) {
fclose(fp);
return;
}
fclose(fp);
House_restore_weight(world[rnum].contents);
REMOVE_BIT_AR(ROOM_FLAGS(rnum), ROOM_HOUSE_CRASH);
}
/* Delete a house save file */
void House_delete_file(room_vnum vnum)
{
char filename[MAX_INPUT_LENGTH];
FILE *fl;
if (!House_get_filename(vnum, filename, sizeof(filename)))
return;
if (!(fl = fopen(filename, "rb"))) {
if (errno != ENOENT)
log("SYSERR: Error deleting house file #%d. (1): %s", vnum, strerror(errno));
return;
}
fclose(fl);
if (remove(filename) < 0)
log("SYSERR: Error deleting house file #%d. (2): %s", vnum, strerror(errno));
}
/* List all objects in a house file */
static void House_listrent(struct char_data *ch, room_vnum vnum)
{
FILE *fl;
struct house_control_data *hse;
char filename[MAX_STRING_LENGTH];
char buf[MAX_STRING_LENGTH];
obj_save_data *loaded, *current;
int len = 0;
hse = find_house(vnum);
if (hse && HOUSE_FLAGGED(hse, HOUSE_RENTFREE)) {
send_to_char(ch, "House #%d is rent free!\r\n", vnum);
}
if (!House_get_filename(vnum, filename, sizeof(filename)))
return;
if (!(fl = fopen(filename, "rb"))) {
send_to_char(ch, "No objects on file for house #%d.\r\n", vnum);
return;
}
*buf = '\0';
len = snprintf(buf, sizeof(buf), "filename: %s\r\n", filename);
loaded = objsave_parse_objects(fl);
for (current = loaded; current != NULL; current = current->next)
len += snprintf(buf+len, sizeof(buf)-len, " [%5d] (%5dau) %s\r\n",
GET_OBJ_VNUM(current->obj), GET_OBJ_RENT(current->obj), current->obj->short_description);
/* now it's safe to free the obj_save_data list - all members of it
* have been put in the correct lists by obj_to_room()
*/
while (loaded != NULL) {
current = loaded;
loaded = loaded->next;
extract_obj(current->obj);
free(current);
}
page_string(ch->desc,buf,0);
fclose(fl);
}
/* Functions for house administration (creation, deletion, etc. */
struct house_control_data *find_house(room_vnum vnum)
{
struct house_control_data *h = NULL, *next_h = NULL;
for (h = house_control; h; h = next_h) {
next_h = h->next;
if (h->vnum == vnum)
return (h);
}
return (NULL);
}
void clear_house_control_data(struct house_control_data *h)
{
int i;
h->vnum = NOWHERE;
h->atrium = NOWHERE;
h->owner = NOBODY;
h->mode = HOUSE_PRIVATE;
h->exit_num = 0;
h->built_on = 0;
h->built_by = NOBODY;
h->last_payment = 0;
h->receptionist = NOBODY;
h->guests = NULL;
h->next = NULL;
for (i=0; i< HS_ARRAY_MAX; i++)
h->house_flags[i] = 0;
}
/* Create a new house control struct with 'default' values, not in the list */
struct house_control_data *new_house(void)
{
struct house_control_data *h;
CREATE(h, struct house_control_data, 1);
clear_house_control_data(h);
return(h);
}
/* Add a guest ID to the specified house */
void add_house_guest(struct house_control_data *h_data, long guest_id)
{
struct guest_data *g = NULL;
if (!h_data || guest_id <= 0 || guest_id == NOBODY) return;
CREATE(g, struct guest_data, 1);
if (!g) {
log("SYSERR: Unable to add house guest (vnum=%d, id=%ld)", h_data->vnum, guest_id);
}
/* Store the ID */
g->id = guest_id;
/* add it onto the front of the list */
g->next = h_data->guests;
h_data->guests = g;
}
/* Return the number of house guests in the specified house */
int count_house_guests(struct house_control_data *h)
{
int count = 0;
struct guest_data *g, *next_g;
for (g=h->guests, count=0; g; g = next_g) {
next_g = g->next;
count++;
}
return count;
}
/* Return TRUE if the specified player ID is in the house guest list */
bool is_house_guest(struct house_control_data *h, long id_num)
{
int count = 0;
struct guest_data *g, *next_g;
for (g=h->guests, count=0; g; g = next_g) {
next_g = g->next;
if (g->id == id_num) return TRUE;
}
return FALSE;
}
/* remove a guest from the guest list for the house */
bool remove_house_guest(struct house_control_data *h, long id_num)
{
int count = 0;
struct guest_data *g, *next_g;
/* First entry in the list? */
g = (h->guests);
if (g->id == id_num) {
next_g = g->next;
free (g);
h->guests = next_g;
}
for (g=h->guests, count=0; g; g = next_g) {
next_g = g->next;
if (next_g->id == id_num) {
g->next = next_g->next;
free(next_g);
return TRUE;
}
}
return FALSE;
}
/* Return the number of houses in the list */
int count_houses(void)
{
int count = 0;
struct house_control_data *h, *next_h;
for (h=house_control, count=0; h; h = next_h) {
next_h = h->next;
count++;
}
return count;
}
/* Add a house to the house_control list, allocating memory for it */
struct house_control_data *add_house(struct house_control_data *h_data)
{
struct house_control_data *h;
struct guest_data *g, *next_g = NULL;
room_rnum real_house, real_atrium;
/* Only valid houses can be added to the list, ignore all others */
if (get_name_by_id(h_data->owner) == NULL)
return NULL; /* owner no longer exists -- skip */
if ((real_house = real_room(h_data->vnum)) == NOWHERE)
return NULL; /* this vnum doesn't exist -- skip */
if (find_house(h_data->vnum) != NULL)
return NULL; /* this vnum is already a house -- skip */
if ((real_atrium = real_room(h_data->atrium)) == NOWHERE)
return NULL; /* house doesn't have an atrium -- skip */
if (h_data->exit_num < 0 || h_data->exit_num >= DIR_COUNT)
return NULL; /* invalid exit num -- skip */
if (TOROOM(real_house, h_data->exit_num) != real_atrium)
return NULL; /* exit num mismatch -- skip */
/* All checks passed, add this house to the house_control list */
h = new_house();
/* Copy the data from the temp struct */
*h = *h_data;
/* Except the pointer to the guest list */
h->guests = NULL;
/* Then, add the guests */
for (g=h_data->guests; g; g=next_g) {
next_g = g->next;
add_house_guest(h,g->id);
}
/* Finally, add it to the current list */
h->next = house_control;
house_control = h;
return (h);
}
/* Set up a house with flags, contents and receptionist */
void set_house(struct house_control_data *h)
{
struct char_data *mob = NULL;
room_rnum real_house, real_atrium;
mob_rnum real_mob;
SPECIAL(*sp_func);
if ((real_house = real_room(h->vnum)) == NOWHERE)
return; /* this vnum doesn't exist -- skip */
if ((real_atrium = real_room(h->atrium)) == NOWHERE)
return; /* house doesn't have an atrium -- skip */
/* House is OK, set flags and load contents */
SET_BIT_AR(ROOM_FLAGS(real_house), ROOM_HOUSE);
SET_BIT_AR(ROOM_FLAGS(real_house), ROOM_PRIVATE);
SET_BIT_AR(ROOM_FLAGS(real_atrium), ROOM_ATRIUM);
House_load(h->vnum);
if ((real_mob = real_mobile(h->receptionist)) == NOBODY)
return; /* Invalid Receptionist Mob VNUM */
/* Attach the required 'standard' Spec-Proc, unless flagged */
if (!HOUSE_FLAGGED(h, HOUSE_NOSPEC)) {
switch (h->mode) {
case HOUSE_PRIVATE:
case HOUSE_GOD:
/* Load a standard receptionist */
sp_func = house_receptionist;
break;
case HOUSE_SHOP:
/* Load a Player-Owned Shopkeeper */
sp_func = house_shopkeeper;
break;
default:
sp_func = NULL;
break;
}
/* NOTE: if the mob had a previous spec-proc assigned, it loses it */
if (sp_func) {
if ((mob_index[(real_mob)].func) && (sp_func != mob_index[(real_mob)].func)) {
log("SYSERR: House %d, receptionist %d already had %s spec-proc in set_house",
h->vnum, h->receptionist, get_spec_func_name(mob_index[(real_mob)].func));
}
mob_index[(real_mob)].func = sp_func;
}
/* Finally, load the mob */
mob = read_mobile(real_mob, REAL);
char_to_room(mob, real_atrium);
}
House_crashsave(h->vnum);
}
/* Free memory used by house guest list for the specified house */
void free_house_guests(struct house_control_data *h)
{
struct guest_data *g;
while (h->guests) {
g = (h->guests)->next;
free(h->guests);
h->guests = g;
}
}
/* Free memory used by specifed house */
void free_house(struct house_control_data *h)
{
/* Free guest list */
if (h->guests)
free_house_guests(h);
/* Free house struct */
free(h);
}
/* erase all houses, and free memory */
void free_house_list(void)
{
struct house_control_data *h;
while (house_control) {
h = house_control->next;
free_house(house_control);
house_control = h;
}
}
/* Remove a house from the control list, and free memory */
bool delete_house_control(struct house_control_data *to_del)
{
struct house_control_data *h, *next_h = NULL;
if (!house_control) return FALSE;
/* Is it the first in the list */
if (house_control == to_del) {
h = house_control;
house_control = h->next;
free_house(h);
return TRUE;
}
/* Find it in the list */
for (h = house_control; h; h = next_h) {
next_h = h->next;
if (next_h == to_del) {
h->next = next_h->next;
free_house(next_h);
return TRUE;
}
}
return FALSE;
}
/* Save the house control information */
void House_save_control(void)
{
FILE *fl;
char bits[127], bits2[127], bits3[127], bits4[127];
struct house_control_data *h, *next_h;
struct guest_data *g, *next_g;
if (!(fl = fopen(HCONTROL_FILE, "w"))) {
perror("SYSERR: Unable to open house control file.");
return;
}
for (h=house_control; h; h = next_h) {
next_h = h->next;
fprintf(fl, "#%d\n", h->vnum); /* New House, Room VNUM */
fprintf(fl, "Atrm: %d\n", h->atrium); /* Atrium Room VNUM */
fprintf(fl, "ADir: %d\n", h->exit_num); /* Atrium Direction */
fprintf(fl, "Bldr: %ld\n", h->built_by); /* House Builder ID */
fprintf(fl, "BldT: %d\n", (int)(h->built_on)); /* House Build Date/Time */
sprintascii(bits, h->house_flags[0]);
sprintascii(bits2, h->house_flags[1]);
sprintascii(bits3, h->house_flags[2]);
sprintascii(bits4, h->house_flags[3]);
fprintf(fl, "Flgs: %s %s %s %s\n", bits, bits2, bits3, bits4); /* House Flags */
if (h->guests) {
fprintf(fl, "Gsts: \n"); /* Guest List */
for (g=(h->guests); g; g = next_g) {
next_g = g->next;
fprintf(fl, "%ld\n", g->id); /* Individual Guest */
}
fprintf(fl, "~\n"); /* End Guest List */
}
fprintf(fl, "Mode: %d\n", h->mode); /* House Mode (Type) */
fprintf(fl, "Ownr: %ld\n", h->owner); /* Owner ID Number */
fprintf(fl, "Paym: %d\n", (int)(h->last_payment)); /* Last Payment Date */
fprintf(fl, "Recp: %d\n", h->receptionist); /* Receptionist VNUM */
}
fprintf(fl, "$\n"); /* End of file */
fclose(fl);
}
static void parse_house_flags(struct house_control_data *h, char *line)
{
char f1[128], f2[128], f3[128], f4[128];
if (sscanf(line, "%s %s %s %s", f1, f2, f3, f4) == 4) {
h->house_flags[0] = asciiflag_conv(f1);
h->house_flags[1] = asciiflag_conv(f2);
h->house_flags[2] = asciiflag_conv(f3);
h->house_flags[3] = asciiflag_conv(f4);
} else
h->house_flags[0] = asciiflag_conv(line);
}
static void parse_house_guests(struct house_control_data *h, FILE *fl)
{
long num = 0;
char line[MAX_INPUT_LENGTH + 1];
do {
get_line(fl, line);
/* Add guest if line isn't end of list or a comment */
if ((*line != '*') && (*line != '~')) {
sscanf(line, "%ld", &num);
if (num != 0)
add_house_guest(h, num);
}
} while (!feof(fl) && *line && *line != '~' && *line != '$' && num != 0);
}
/* Call from boot_db - will load control recs, load objs, set atrium bits.
* Should do sanity checks on vnums & remove invalid records. */
void House_boot(void)
{
struct house_control_data temp_house, *h;
FILE *fl;
char line[MAX_INPUT_LENGTH + 1], tag[6];;
bool first = TRUE, bad_tag = FALSE;
/* Clear any old lists in memory */
if (house_control) free_house_list();
if (!(fl = fopen(HCONTROL_FILE, "r"))) {
if (errno == ENOENT)
log(" No houses to load. File '%s' does not exist.", HCONTROL_FILE);
else
perror("SYSERR: " HCONTROL_FILE);
return;
}
while (get_line(fl, line)) {
while (*line == '*') {
get_line(fl, line); /* Skip comment lines */
}
/* Start a new house or end of file? */
if (*line == '#' || *line == '$' || feof(fl)) {
/* Save the current house */
if (!first) {
if ((h = add_house(&temp_house)) != NULL)
set_house(h); /* Set up the room flags, contents and spec mob */
} else {
first = FALSE;
}
if (*line == '$') {
/* End of file reached, tidy up, and get out */
fclose(fl);
House_save_control(); /* Re-save, losing invalid houses */
return;
} else if (feof(fl)) {
/* End of file incorrectly reached, warn, tidy up, and get out */
log("SYSERR: End of house control file reached before '$'");
fclose(fl);
House_save_control(); /* Re-save, losing invalid houses */
return;
}
/* We didn't reach the end of the file, so start a new house */
clear_house_control_data(&temp_house);
temp_house.vnum = atoi(line+1);
} else {
tag_argument(line, tag);
switch (*tag) {
case 'A':
if (!strcmp(tag, "Atrm")) temp_house.atrium = atoi(line);
else if (!strcmp(tag, "ADir")) temp_house.exit_num = atoi(line);
else bad_tag = TRUE;
break;
case 'B':
if (!strcmp(tag, "Bldr")) temp_house.built_by = atol(line);
else if (!strcmp(tag, "BldT")) temp_house.built_on = atol(line);
else bad_tag = TRUE;
break;
case 'F':
if (!strcmp(tag, "Flgs")) parse_house_flags(&temp_house, line);
else bad_tag = TRUE;
break;
case 'G':
if (!strcmp(tag, "Gsts")) parse_house_guests(&temp_house, fl);
else bad_tag = TRUE;
break;
case 'M':
if (!strcmp(tag, "Mode")) temp_house.mode = atoi(line);
else bad_tag = TRUE;
break;
case 'O':
if (!strcmp(tag, "Ownr")) temp_house.owner = atol(line);
else bad_tag = TRUE;
break;
case 'P':
if (!strcmp(tag, "Paym")) temp_house.last_payment = atol(line);
else bad_tag = TRUE;
break;
case 'R':
if (!strcmp(tag, "Recp")) temp_house.receptionist = (mob_vnum)(atoi(line));
else bad_tag = TRUE;
break;
default:
bad_tag = TRUE;
break;
}
if (bad_tag) {
bad_tag = FALSE;
log("SYSERR: Unknown tag %s in house control file %s", tag, HCONTROL_FILE);
}
}
}
/* End of file incorrectly reached, warn, tidy up, and get out */
log("SYSERR: End of house control file reached before '$'");
fclose(fl);
House_save_control(); /* Re-save, losing invalid houses */
}
void stat_house(struct char_data *ch, struct house_control_data *hse)
{
room_rnum rm;
char *timestr;
char built_on[128], last_pay[128], buf[MAX_STRING_LENGTH];
if (!ch || !hse) return;
if (hse->built_on) {
timestr = asctime(localtime(&(hse->built_on)));
*(timestr + 10) = '\0';
strlcpy(built_on, timestr, sizeof(built_on));
} else
strcpy(built_on, "Unknown"); /* strcpy: OK (for 'strlen("Unknown") < 128') */
if (hse->last_payment) {
timestr = asctime(localtime(&(hse->last_payment)));
*(timestr + 10) = '\0';
strlcpy(last_pay, timestr, sizeof(last_pay));
} else
strcpy(last_pay, "None"); /* strcpy: OK (for 'strlen("None") < 128') */
send_to_char(ch, "House Type : %s%d%s - %s%s%s\r\n",
QYEL, hse->mode, QNRM,
QCYN, house_types[(hse->mode)], QNRM);
send_to_char(ch, "Owner : %s[%s%5ld%s]%s - %s%s%s\r\n",
QCYN, QYEL, hse->owner, QCYN, QNRM,
QCYN, CAP(get_name_by_id(hse->owner)), QNRM);
rm = real_room(hse->vnum);
send_to_char(ch, "Private Room: %s[%s%5d%s]%s - %s%s%s\r\n",
QCYN, QYEL, hse->vnum, QCYN, QNRM,
QCYN, (rm == NOWHERE) ? "<Not Set>" : world[rm].name, QNRM);
rm = real_room(hse->atrium);
send_to_char(ch, "Atrium Room : %s[%s%5d%s]%s - %s%s%s\r\n",
QCYN, QYEL, hse->atrium, QCYN, QNRM,
QCYN, (rm == NOWHERE) ? "<Not Set>" : world[rm].name, QNRM);
send_to_char(ch, "House Built : %s%s%s by %s%s%s\r\n",
QYEL, built_on, QNRM,
QCYN, (get_name_by_id(hse->built_by) == NULL) ? "<Unknown>" : CAP(get_name_by_id(hse->built_by)), QNRM);
send_to_char(ch, "Last Payment: %s%s%s\r\n",
QYEL, last_pay, QNRM);
sprintbitarray((hse->house_flags), house_bits, HS_ARRAY_MAX, buf);
send_to_char(ch, "House Flags : %s%s%s\r\n",
QCYN, buf, QNRM);
send_to_char(ch, "There are %d guests:\r\n", count_house_guests(hse));
House_list_guests(ch, hse, TRUE);
send_to_char(ch, "Rent Info:\r\n");
House_listrent(ch, hse->vnum);
}
/* "House Control" functions */
const char *HCONTROL_FORMAT =
"Usage: hcontrol build <house vnum> <exit direction> <player name>\r\n"
" hcontrol destroy <house vnum>\r\n"
" hcontrol pay <house vnum>\r\n"
" hcontrol show [house vnum | .]\r\n";
void hcontrol_list_houses(struct char_data *ch, char *arg)
{
struct house_control_data *h = NULL, *next_h = NULL;
char *timestr, *temp;
char built_on[128], last_pay[128], own_name[MAX_NAME_LENGTH + 1];
room_vnum toshow;
if (arg && *arg) {
if (*arg == '.')
toshow = GET_ROOM_VNUM(IN_ROOM(ch));
else
toshow = atoi(arg);
if ((h = find_house(toshow)) == NULL) {
send_to_char(ch, "Unknown house, \"%s\".\r\n", arg);
return;
}
stat_house(ch, h);
return;
}
if (!house_control) {
send_to_char(ch, "No houses have been defined.\r\n");
return;
}
send_to_char(ch,
"Address Atrium Build Date Guests Owner Last Paymt\r\n"
"------- ------ ---------- ------ ------------ ----------\r\n");
for (h = house_control; h; h = next_h) {
next_h = h->next;
/* Avoid seeing <UNDEF> entries from self-deleted people. -gg 6/21/98 */
if ((temp = get_name_by_id(h->owner)) == NULL)
continue;
if (h->built_on) {
timestr = asctime(localtime(&(h->built_on)));
*(timestr + 10) = '\0';
strlcpy(built_on, timestr, sizeof(built_on));
} else
strcpy(built_on, "Unknown"); /* strcpy: OK (for 'strlen("Unknown") < 128') */
if (h->last_payment) {
timestr = asctime(localtime(&(h->last_payment)));
*(timestr + 10) = '\0';
strlcpy(last_pay, timestr, sizeof(last_pay));
} else
strcpy(last_pay, "None"); /* strcpy: OK (for 'strlen("None") < 128') */
/* Now we need a copy of the owner's name to capitalize. -gg 6/21/98 */
strcpy(own_name, temp); /* strcpy: OK (names guaranteed <= MAX_NAME_LENGTH+1) */
send_to_char(ch, "%7d %7d %-10s %2d %-12s %s\r\n",
h->vnum, h->atrium, built_on,
count_house_guests(h), CAP(own_name), last_pay);
House_list_guests(ch, h, TRUE);
}
}
static void hcontrol_build_house(struct char_data *ch, char *arg)
{
char arg1[MAX_INPUT_LENGTH];
struct house_control_data *temp_house, *h = NULL;
room_vnum virt_house, virt_atrium;
room_rnum real_house, real_atrium;
sh_int exit_num;
long owner;
if (count_houses() >= MAX_HOUSES) {
send_to_char(ch, "Max houses already defined.\r\n");
return;
}
/* first arg: house's vnum */
arg = one_argument(arg, arg1);
if (!*arg1) {
send_to_char(ch, "%s", HCONTROL_FORMAT);
return;
}
virt_house = atoi(arg1);
if ((real_house = real_room(virt_house)) == NOWHERE) {
send_to_char(ch, "No such room exists.\r\n");
return;
}
if ((find_house(virt_house)) != NULL) {
send_to_char(ch, "House already exists.\r\n");
return;
}
/* second arg: direction of house's exit */
arg = one_argument(arg, arg1);
if (!*arg1) {
send_to_char(ch, "%s", HCONTROL_FORMAT);
return;
}
if ((exit_num = search_block(arg1, dirs, FALSE)) < 0) {
send_to_char(ch, "'%s' is not a valid direction.\r\n", arg1);
return;
}
if (TOROOM(real_house, exit_num) == NOWHERE) {
send_to_char(ch, "There is no exit %s from room %d.\r\n", dirs[exit_num], virt_house);
return;
}
real_atrium = TOROOM(real_house, exit_num);
virt_atrium = GET_ROOM_VNUM(real_atrium);
if (TOROOM(real_atrium, rev_dir[exit_num]) != real_house) {
send_to_char(ch, "A house's exit must be a two-way door.\r\n");
return;
}
/* third arg: player's name */
one_argument(arg, arg1);
if (!*arg1) {
send_to_char(ch, "%s", HCONTROL_FORMAT);
return;
}
if ((owner = get_id_by_name(arg1)) < 0) {
send_to_char(ch, "Unknown player '%s'.\r\n", arg1);
return;
}
/* allocate memory for temp_house */
if ((temp_house = new_house()) == NULL) {
send_to_char(ch, "Unable to build a house right now...\r\n");
log("SYSERR: Unable to allocate memory for a house in hcontrol_build_house");
return;
}
temp_house->mode = HOUSE_PRIVATE;
temp_house->vnum = virt_house;
temp_house->atrium = virt_atrium;
temp_house->exit_num = exit_num;
temp_house->built_on = time(0);
temp_house->last_payment = 0;
temp_house->owner = owner;
temp_house->guests = NULL;
if ((h = add_house(temp_house)) != NULL) {
set_house(h);
} else {
send_to_char(ch, "Unable to build a house right now...\r\n");
log("SYSERR: Unable to add a house in hcontrol_build_house");
free_house(temp_house);
return;
}
/* A new house is added to the list, so free memory used by temp_house */
free_house(temp_house);
send_to_char(ch, "House built. Mazel tov!\r\n");
House_save_control();
}
static void hcontrol_destroy_house(struct char_data *ch, char *arg)
{
struct house_control_data *h = NULL, *next_h = NULL;
room_rnum real_atrium, real_house;
if (!*arg) {
send_to_char(ch, "%s", HCONTROL_FORMAT);
return;
}
if ((h = find_house(atoi(arg))) == NULL) {
send_to_char(ch, "Unknown house.\r\n");
return;
}
if ((real_atrium = real_room(h->atrium)) == NOWHERE)
log("SYSERR: House %d had invalid atrium %d!", atoi(arg), h->atrium);
else
REMOVE_BIT_AR(ROOM_FLAGS(real_atrium), ROOM_ATRIUM);
if ((real_house = real_room(h->vnum)) == NOWHERE)
log("SYSERR: House %d had invalid vnum %d!", atoi(arg), h->vnum);
else {
REMOVE_BIT_AR(ROOM_FLAGS(real_house), ROOM_HOUSE);
REMOVE_BIT_AR(ROOM_FLAGS(real_house), ROOM_PRIVATE);
REMOVE_BIT_AR(ROOM_FLAGS(real_house), ROOM_HOUSE_CRASH);
}
House_delete_file(h->vnum);
delete_house_control(h);
send_to_char(ch, "House deleted.\r\n");
House_save_control();
/* Now, reset the ROOM_ATRIUM flag on all existing houses' atriums, just in
* case the house we just deleted shared an atrium with another house. -JE */
for (h = house_control; h; h = next_h) {
next_h = h->next;
if ((real_atrium = real_room(h->atrium)) != NOWHERE)
SET_BIT_AR(ROOM_FLAGS(real_atrium), ROOM_ATRIUM);
}
}
static void hcontrol_pay_house(struct char_data *ch, char *arg)
{
struct house_control_data *hse;
if (!*arg)
send_to_char(ch, "%s", HCONTROL_FORMAT);
else if ((hse = find_house(atoi(arg))) == NULL)
send_to_char(ch, "Unknown house.\r\n");
else if (HOUSE_FLAGGED(hse, HOUSE_FREE))
send_to_char(ch, "That is a FREE house. Payment cannot be taken.\r\n");
else {
mudlog(NRM, MAX(ADMLVL_IMMORT, GET_INVIS_LEV(ch)), TRUE, "Payment for house %s collected by %s.", arg, GET_NAME(ch));
hse->last_payment = time(0);
House_save_control();
send_to_char(ch, "Payment recorded.\r\n");
}
}
/* The hcontrol command itself, used by imms to create/destroy houses */
ACMD(do_hcontrol)
{
char arg1[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH];
half_chop(argument, arg1, arg2);
if (is_abbrev(arg1, "build"))
hcontrol_build_house(ch, arg2);
else if (is_abbrev(arg1, "destroy"))
hcontrol_destroy_house(ch, arg2);
else if (is_abbrev(arg1, "pay"))
hcontrol_pay_house(ch, arg2);
else if (is_abbrev(arg1, "show"))
hcontrol_list_houses(ch, arg2);
/* CONVERSION code starts here -- see comment below not in hcontrol_format. */
else if (!str_cmp(arg1, "asciiconvert"))
hcontrol_convert_houses(ch);
/* CONVERSION ends here -- read more below. */
else
send_to_char(ch, "%s", HCONTROL_FORMAT);
}
/* The house command, used by mortal house owners to assign guests */
ACMD(do_house)
{
struct house_control_data *hse = NULL;
char arg[MAX_INPUT_LENGTH];
long id;
one_argument(argument, arg);
if (!ROOM_FLAGGED(IN_ROOM(ch), ROOM_HOUSE))
send_to_char(ch, "You must be in your house to set guests.\r\n");
else if ((hse = find_house(GET_ROOM_VNUM(IN_ROOM(ch)))) == NULL)
send_to_char(ch, "Um.. this house seems to be screwed up.\r\n");
else if (HOUSE_FLAGGED(hse, HOUSE_NOGUESTS))
send_to_char(ch, "Sorry, this house can't have a guest list.\r\n");
else if (GET_IDNUM(ch) != hse->owner)
send_to_char(ch, "Only the primary owner can set guests.\r\n");
else if (!*arg)
House_list_guests(ch, hse, FALSE);
else if ((id = get_id_by_name(arg)) < 0)
send_to_char(ch, "No such player.\r\n");
else if (id == GET_IDNUM(ch))
send_to_char(ch, "It's your house!\r\n");
else {
if (is_house_guest(hse, id)) {
remove_house_guest(hse, id);
send_to_char(ch, "Guest deleted.\r\n");
} else {
if (count_house_guests(hse) == MAX_GUESTS) {
send_to_char(ch, "You have too many guests.\r\n");
return;
}
add_house_guest(hse, id);
send_to_char(ch, "Guest added.\r\n");
}
House_save_control();
}
}
/* Misc. administrative functions */
/* crash-save all the houses */
void House_save_all(void)
{
struct house_control_data *hse = NULL, *next_hse = NULL;
room_rnum real_house;
for (hse = house_control; hse; hse = next_hse) {
next_hse = hse->next;
if ((real_house = real_room(hse->vnum)) != NOWHERE)
if (ROOM_FLAGGED(real_house, ROOM_HOUSE_CRASH))
House_crashsave(hse->vnum);
}
}
/* note: arg passed must be house vnum, so there. */
int House_can_enter(struct char_data *ch, room_vnum house)
{
struct house_control_data *hse = NULL;
struct guest_data *g, *next_g = NULL;
/* Not a house? */
if ((hse = find_house(house)) == NULL)
return (1);
/* Even when admin-flagged able to enter all houses, there may be restrictions */
if (ADM_FLAGGED(ch, ADM_ALLHOUSES)) {
if (HOUSE_FLAGGED(hse, HOUSE_IMPONLY) && IS_ADMIN(ch, ADMLVL_IMPL))
return (1);
else if (IS_ADMIN(ch, ADMLVL_GOD))
return (1);
else if (!HOUSE_FLAGGED(hse, HOUSE_NOIMMS) && IS_ADMIN(ch, ADMLVL_IMMORT))
return (1);
}
if (GET_IDNUM(ch) == hse->owner)
return (1);
switch (hse->mode) {
case HOUSE_PRIVATE:
case HOUSE_SHOP:
for (g = hse->guests; g; g = next_g) {
next_g = g->next;
if (GET_IDNUM(ch) == g->id)
return (1);
}
break;
case HOUSE_GOD:
for (g = hse->guests; g; g = next_g) {
next_g = g->next;
if (GET_IDNUM(ch) == g->id) {
if (HOUSE_FLAGGED(hse, HOUSE_IMPONLY) && IS_ADMIN(ch, ADMLVL_IMPL))
return (1);
else if (IS_ADMIN(ch, ADMLVL_GOD))
return (1);
else if (!HOUSE_FLAGGED(hse, HOUSE_NOIMMS) && IS_ADMIN(ch, ADMLVL_IMMORT))
return (1);
}
}
break;
default:
log("SYSERR: Unhandled mode (%d) for house %d in House_can_enter", hse->mode, hse->vnum );
break;
}
return (0);
}
void House_list_guests(struct char_data *ch, struct house_control_data *h, int quiet)
{
struct guest_data *g, *next_g = NULL;
int num_printed;
char *temp;
if (count_house_guests(h) == 0) {
if (!quiet)
send_to_char(ch, " Guests: None\r\n");
return;
}
send_to_char(ch, " Guests: ");
for (num_printed = 0, g = h->guests; g; g = next_g) {
next_g = g->next;
/* Avoid <UNDEF>. -gg 6/21/98 */
if ((temp = get_name_by_id(g->id)) == NULL)
continue;
num_printed++;
send_to_char(ch, "%c%s ", UPPER(*temp), temp + 1);
}
if (num_printed == 0)
send_to_char(ch, "all dead");
send_to_char(ch, "\r\n");
}
/*************************************************************************
* All code below this point and the code above, marked "CONVERSION" *
* can be removed after you have converted your house rent files using *
* the command *
* hcontrol asciiconvert *
* *
* You can only use this command as implementor. *
* After you have converted your house files, I suggest a reboot, which *
* will let your house files load on the next bootup. -Welcor *
************************************************************************/
/* Code for conversion to ascii house rent files. */
static void hcontrol_convert_houses(struct char_data *ch)
{
struct house_control_data *h, *next_h = NULL;
if (!IS_ADMIN(ch, ADMLVL_IMPL))
{
send_to_char(ch, "Sorry, but you are not powerful enough to do that.\r\n");
return;
}
if (!house_control) {
send_to_char(ch, "No houses have been defined.\r\n");
return;
}
send_to_char(ch, "Converting houses:\r\n");
for (h = house_control; h; h = next_h) {
next_h = h->next;
send_to_char(ch, " %d", h->vnum);
if (!ascii_convert_house(ch, h->vnum))
{
/* Let ascii_convert_house() tell about the error. */
return;
}
else
{
send_to_char(ch, "...done\r\n");
}
}
send_to_char(ch, "All done.\r\n");
}
static int ascii_convert_house(struct char_data *ch, obj_vnum vnum)
{
FILE *in, *out;
char infile[MAX_INPUT_LENGTH], *outfile;
struct obj_data *tmp;
int i, j=0, k;
House_get_filename(vnum, infile, sizeof(infile));
CREATE(outfile, char, strlen(infile)+7);
sprintf(outfile, "%s.ascii", infile);
if (!(in = fopen(infile, "r+b"))) /* no file found */
{
send_to_char(ch, "...no object file found\r\n");
free(outfile);
return (0);
}
if (!(out = fopen(outfile, "w")))
{
send_to_char(ch, "...cannot open output file\r\n");
free(outfile);
fclose(in);
return (0);
}
while (!feof(in)) {
struct obj_file_elem object;
k = fread(&object, sizeof(struct obj_file_elem), 1, in);
if (ferror(in)) {
perror("SYSERR: Reading house file in House_load");
send_to_char(ch, "...read error in house rent file.\r\n");
free(outfile);
fclose(in);
fclose(out);
return (0);
}
if (!feof(in))
{
tmp = Obj_from_store(object, &i);
if (!objsave_save_obj_record(tmp, out, i))
{
send_to_char(ch, "...write error in house rent file.\r\n");
free(outfile);
fclose(in);
fclose(out);
return (0);
}
j++;
}
}
fprintf(out, "$~\n");
fclose(in);
fclose(out);
free(outfile);
send_to_char(ch, "...%d items", j);
return 1;
}
/* The circle 3.1 function for reading rent files. No longer used by the rent system. */
static struct obj_data *Obj_from_store(struct obj_file_elem object, int *location)
{
struct obj_data *obj;
obj_rnum itemnum;
int j, taeller;
*location = 0;
if ((itemnum = real_object(object.item_number)) == NOTHING)
return (NULL);
obj = read_object(itemnum, REAL);
#if USE_AUTOEQ
*location = object.location;
#endif
GET_OBJ_VAL(obj, 0) = object.value[0];
GET_OBJ_VAL(obj, 1) = object.value[1];
GET_OBJ_VAL(obj, 2) = object.value[2];
GET_OBJ_VAL(obj, 3) = object.value[3];
for(taeller = 0; taeller < EF_ARRAY_MAX; taeller++)
GET_OBJ_EXTRA(obj)[taeller] = object.extra_flags[taeller];
GET_OBJ_WEIGHT(obj) = object.weight;
GET_OBJ_TIMER(obj) = object.timer;
for(taeller = 0; taeller < AF_ARRAY_MAX; taeller++)
GET_OBJ_AFFECT(obj)[taeller] = object.bitvector[taeller];
for (j = 0; j < MAX_OBJ_AFFECT; j++)
obj->affected[j] = object.affected[j];
return (obj);
}
/* Standard House Receptionist (house guard mob) */
/* Mob Special Function */
/* Prevents non-guests from entering a house */
SPECIAL(house_receptionist)
{
struct house_control_data *h, *next_h;
struct char_data *guard = (struct char_data *) me;
if (!IS_MOVE(cmd) || IS_AFFECTED(guard, AFF_BLIND))
return FALSE;
if (ADM_FLAGGED(ch, ADM_ALLHOUSES))
return FALSE;
/* Go through house list */
for (h = house_control; h; h = next_h)
{
next_h = h->next;
/* Is this the correct House Number, and moving in the right direction*/
if ((world[(IN_ROOM(ch))].number == h->atrium) && IS_MOVE(cmd) && (cmd == rev_dir[(h->exit_num)]))
{
/* Always allow the house owner and guests */
if ( (GET_IDNUM(ch) == h->owner) || (is_house_guest(h, GET_IDNUM(ch))) )
{
return FALSE;
}
}
}
/* Not house owner or guest - refuse admission */
act("$N humiliates you, and blocks your way.", FALSE, ch, 0, guard, TO_CHAR);
act("$N humiliates $n, and blocks $s way.", FALSE, ch, 0, guard, TO_ROOM);
return TRUE;
}
/* Player owned shops - Created by Jamdog - 22nd February 2007 */
/* Mob Special Function */
/* 'Stock-room' must also be created and made into a player house */
/* so that only the shop owner can get the piles of gold left there */
SPECIAL(house_shopkeeper)
{
room_rnum private_room;
struct obj_data *i, *j;
int num=1, num_items=0;
struct house_control_data *hse = NULL, *next_hse = NULL;
char *temp, shop_owner[MAX_NAME_LENGTH + 1], buf[MAX_STRING_LENGTH];
bool found=FALSE;
if (!cmd)
return FALSE;
/* Gross. */
private_room = + 1;
/* Grab the name of the shop owner */
for (hse = house_control; hse && !found; hse = next_hse)
{
next_hse = hse->next;
if (hse->atrium == world[(IN_ROOM(ch))].number)
{
/* Avoid seeing <UNDEF> entries from self-deleted people. */
if ((temp = get_name_by_id(hse->owner)) == NULL)
{
sprintf(shop_owner, "Someone");
}
else
{
sprintf(shop_owner, "%s", CAP(get_name_by_id(hse->owner)) );
}
private_room = real_room(hse->vnum);
found=TRUE;
}
}
if (found==FALSE) {
log("SYSERR: player_owned_shop spec_proc on a mob that's not in a house! (atrium room %d)", world[IN_ROOM(ch)].number);
return FALSE;
}
if (private_room == NOWHERE) {
log("SYSERR: player_owned_shop has invalid private room! (atrium room %d)", world[IN_ROOM(ch)].number);
return FALSE;
}
if (CMD_IS("list"))
{
if (IS_NPC(ch))
{
send_to_char(ch, "Mobiles can't buy from a player-owned shop!\r\n");
return TRUE;
}
sprintf(buf, "Owner: @W%s@n", shop_owner);
send_to_char(ch, "Player-owned Shop %*s\r\n", count_color_chars(buf)+55, buf);
send_to_char(ch, " ## Available Item Cost\r\n");
send_to_char(ch, "-------------------------------------------------------------------------\r\n");
for (i = world[private_room].contents; i; i = i->next_content)
{
num_items = 0;
for (j = world[private_room].contents; j != i; j = j->next_content)
if (!strcmp(j->short_description, i->short_description))
break;
if (j != i)
continue;
for (j = i; j; j = j->next_content)
if (!strcmp(j->short_description, i->short_description))
num_items++;
if (CAN_SEE_OBJ(ch, i) && (*i->description != '.' || ADM_FLAGGED(ch, ADM_SEESECRET)) && !(GET_OBJ_TYPE(i) == ITEM_MONEY))
{
send_to_char(ch, "%3d) %5d %-*s %11d\r\n", num++, num_items, count_color_chars(i->short_description)+44, i->short_description, GET_OBJ_COST(i));
}
}
return (TRUE);
} else if (CMD_IS("buy")) {
skip_spaces(&argument);
i = get_obj_in_list_vis(ch, argument, NULL, world[private_room].contents);
if ((i == NULL) || (GET_OBJ_TYPE(i) == ITEM_MONEY))
{
send_to_char(ch, "There is no such item for sale!\r\n");
return (TRUE);
}
if (GET_GOLD(ch) < GET_OBJ_COST(i))
{
send_to_char(ch, "You don't have enough gold!\r\n");
return (TRUE);
}
/* Just to avoid crashes, if the object has no cost, then don't try to make a pile of no gold */
if (GET_OBJ_COST(i) > 0)
{
/* Take gold from player */
decrease_gold(ch, GET_OBJ_COST(i));
/* Put gold in stock-room */
j = create_money(GET_OBJ_COST(i));
obj_to_room(j, private_room);
}
/* Move item from stock-room to player's inventory */
obj_from_room(i);
obj_to_char(i, ch);
/* Let everyone know what's happening */
send_to_char(ch, "%s hands you %s, and takes your payment.\r\n", CAP(GET_NAME((struct char_data *)me)), i->short_description);
act("$n buys $p from $N.", FALSE, ch, i, (struct char_data *)me, TO_ROOM);
send_to_char(ch, "%s thanks you for your custom, please come again!\r\n", shop_owner);
return (TRUE);
}
return(FALSE);
}
View Git Blame Copy Permalink