/*~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
~ Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer, ~
~ Michael Seifert, Hans Henrik St{rfeldt, Tom Madsen, and Katja Nyboe. ~
~ ~
~ Merc Diku Mud improvments copyright (C) 1992, 1993 by Michael ~
~ Chastain, Michael Quan, and Mitchell Tse. ~
~ ~
~ Ack 2.2 improvements copyright (C) 1994 by Stephen Dooley ~
~ ACK!MUD is modified Merc2.0/2.1/2.2 code (c)Stephen Zepp 1998 Ver: 4.3 ~
~ ~
~ In order to use any part of this PA Diku Mud, you must comply with ~
~ both the original Diku license in 'license.doc' as well the Merc ~
~ license in 'license.txt', and the Ack!Mud license in 'ack_license.txt'.~
~ In particular, you may not remove any of these copyright notices. ~
~ ~
~ _______ _____ ~
~ / __ /\ / ___ \ 222222 PA_MUD by Amnon Kruvi ~
~ /______/ / / /___\ \ 2 PA_MUD is modified ~
~ / _______/ / _______ \ 2 Ack!Mud, v4.3 ~
~ /_/ /_/ \_\ 2 ~
~ 2 ~
~ 2222222 ~
~ ~
~ ~
~ Years of work have been invested to create DIKU, Merc, Ack and PA. ~
~ Please show your respect by following the licenses, and issuing ~
~ credits where due. ~
~ ~
~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-*/
/* This file deals with adding/deleting and manipulating areas
as a whole, also checking on permissions and deals with area bank. */
#if defined(macintosh)
#include <types.h>
#else
#include <sys/types.h>
#endif
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "ack.h"
/* Variables declared in db.c, which we need */
extern OBJ_INDEX_DATA * obj_index_hash [MAX_KEY_HASH];
extern ROOM_INDEX_DATA * room_index_hash [MAX_KEY_HASH];
extern char * string_hash [MAX_KEY_HASH];
extern char * string_space;
extern char * top_string;
extern char str_empty [1];
extern AREA_DATA * area_used[MAX_AREAS];
extern int top_ed;
extern int top_help;
extern int top_obj_index;
extern int top_room;
#define MAX_STRING 1048576
#define MAX_PERM_BLOCK 131072
extern int nAllocString;
extern int sAllocString;
extern int nAllocPerm;
extern int sAllocPerm;
extern int fBootDb;
/* Some build.c functions : */
void build_strdup(char * * dest,char * src,bool freesrc,CHAR_DATA * ch);
char * build_simpstrdup(char *);
ROOM_INDEX_DATA * new_room( AREA_DATA * pArea, sh_int vnum, sh_int sector );
int build_canread(AREA_DATA * Area,CHAR_DATA * ch,int showerror)
{
if (get_trust(ch) >= MAX_LEVEL)
return 1;
if (Area->can_read != NULL)
if ( is_name("all", Area->can_read)
|| is_name(ch->name, Area->can_read)
|| (is_name("gods", Area->can_read) && IS_IMMORTAL(ch))
)
return 1;
if (showerror==AREA_SHOWERROR)
send_to_char("You are not allowed to use this area.\n\r",ch);
return 0;
}
int build_canwrite(AREA_DATA * Area,CHAR_DATA * ch,int showerror)
{
if (get_trust(ch) >= MAX_LEVEL)
return 1;
if (Area->can_write != NULL)
if ( is_name("all", Area->can_write)
|| is_name(ch->name, Area->can_write)
|| (is_name("gods", Area->can_write) && IS_IMMORTAL(ch))
)
return 1;
if (showerror==AREA_SHOWERROR)
send_to_char("You are not allowed to edit this area.\n\r",ch);
return 0;
}
void build_save_area_list(void)
{
AREA_DATA * pArea;
FILE * fpArea;
fpArea=fopen("area.lst.new","w");
if (fpArea==NULL)
{
bug("Could not open area.lst.new for saving.",0);
return;
}
for (pArea=first_area; pArea != NULL; pArea = pArea->next)
{
fprintf(fpArea,"%s\n\r",pArea->filename);
}
fprintf(fpArea,"$\n\r");
fclose(fpArea);
/* Save backup */
rename("area.lst","area.lst.old");
rename("area.lst.new","area.lst");
}
void build_save_area_gold(void)
{
AREA_DATA * pArea;
FILE * fpArea;
fpArea=fopen("area.gld.new","w");
if (fpArea==NULL)
{
bug("Could not open area.gld.new for saving.",0);
return;
}
for (pArea=first_area; pArea != NULL; pArea = pArea->next)
{
fprintf(fpArea,"%i\n\r",pArea->area_num);
}
fprintf(fpArea,"-1\n\r");
fclose(fpArea);
/* Save backup */
rename("area.gld","area.gld.old");
rename("area.gld.new","area.gld");
}
void build_setarea( CHAR_DATA *ch, char * argument)
{
char arg1 [MAX_INPUT_LENGTH];
char arg2 [MAX_INPUT_LENGTH];
char name [MAX_INPUT_LENGTH];
char buffer[MAX_INPUT_LENGTH];
char buf2 [MAX_STRING_LENGTH];
char * argn,* oldperm;
AREA_DATA * pArea;
int num;
smash_tilde( argument );
argument = one_argument( argument, arg1 );
if ( ( str_cmp(arg1,"title") ) )
argument = one_argument( argument, arg2 );
else
strcpy(arg2,argument);
if ( arg1[0] == '\0' || arg2[0] == '\0')
{
send_to_char( "Syntax: setarea <arguments> \n\r", ch );
send_to_char( "\n\r", ch );
send_to_char( "Arguments being one of:\n\r", ch );
send_to_char( " owner <name> \n\r", ch );
send_to_char( " read [-]<name> \n\r", ch );
send_to_char( " write [-]<name> \n\r", ch );
send_to_char( " title <string>\n\r", ch );
send_to_char( " keyword <keyword> \n\r", ch);
send_to_char( " offset <vnum>\n\r", ch );
return;
}
pArea=ch->in_room->area;
area_modified(pArea);
/*
* Set something.
*/
if ( !str_cmp( arg1, "read" ) )
{
num=1;
argn=arg2;
if ( argn[0]=='-' )
{
num=0;
argn++;
}
if (num==1)
{
if ( pArea->can_read==NULL)
{
pArea->can_read=str_dup(argn);
return;
}
if (! is_name(argn, pArea->can_read))
{
sprintf(buffer,"%s %s",pArea->can_read,argn);
free_string(pArea->can_read);
pArea->can_read=str_dup(buffer);
}
}
else
{
if (is_name(argn, pArea->can_read))
{
buffer[0]='\0';
strcpy(buf2,pArea->can_read);
oldperm=buf2;
oldperm=one_argument(oldperm,name);
while (name[0]!='\0')
{
if ( str_cmp(name,argn) ) /* i.e. not the same */
{
safe_strcat( MSL, buffer,name);
safe_strcat( MSL, buffer," ");
}
oldperm=one_argument(oldperm,name);
}
free_string(pArea->can_read);
pArea->can_read=str_dup(buffer);
}
}
return;
}
if ( !str_cmp( arg1, "write" ) )
{
num=1;
argn=arg2;
if ( argn[0]=='-' )
{
num=0;
argn++;
}
if (num==1)
{
if ( pArea->can_write==NULL)
{
pArea->can_write=str_dup(argn);
return;
}
if (! is_name(argn, pArea->can_write))
{
sprintf(buffer,"%s %s",pArea->can_write,argn);
free_string(pArea->can_write);
pArea->can_write=str_dup(buffer);
}
}
else
if (is_name(argn, pArea->can_write))
{
buffer[0]='\0';
strcpy(buf2,pArea->can_write);
oldperm=buf2;
oldperm=one_argument(oldperm,name);
while (name[0]!='\0')
{
if ( str_cmp(name,argn) ) /* i.e. not the same */
{
safe_strcat( MSL, buffer,name);
safe_strcat( MSL, buffer," ");
}
oldperm=one_argument(oldperm,name);
}
free_string(pArea->can_write);
pArea->can_write=str_dup(buffer);
}
return;
}
if ( !str_cmp( arg1, "owner" ) )
{
build_strdup(&pArea->owner, arg2, TRUE, ch);
pArea->can_read = str_dup(arg2);
pArea->can_write = str_dup(arg2);
return;
}
if ( !str_cmp( arg1, "title"))
{
build_strdup(&pArea->name,argument,TRUE,ch);
return;
}
if ( !str_cmp( arg1, "keyword"))
{
build_strdup(&pArea->keyword,arg2,TRUE,ch);
return;
}
if ( !str_cmp( arg1, "offset"))
{
if ( is_number(arg2))
{
pArea->offset=atoi(arg2);
return;
}
return;
}
/*
* Generate usage message.
*/
build_setarea( ch, "" );
return;
}
void build_findarea( CHAR_DATA *ch, char * argument)
{
/* extern int top_room_index; Unused Var */
char buf[MAX_STRING_LENGTH];
char buf1[MAX_STRING_LENGTH];
char arg[MAX_INPUT_LENGTH];
AREA_DATA * pArea;
ROOM_INDEX_DATA * pRoomIndex = NULL;
int nMatch;
bool fAll;
bool found;
one_argument( argument, arg );
if ( arg[0] == '\0' )
{
send_to_char( "Find what area?\n\r", ch );
return;
}
buf1[0] = '\0';
fAll = !str_cmp( arg, "all" );
found = FALSE;
nMatch = 0;
for ( pArea=first_area; pArea != NULL; pArea=pArea->next )
{
nMatch++;
if ( ( fAll || is_name( arg, pArea->name ) )
&& build_canread(pArea,ch,0) )
{
found = TRUE;
if (pArea->first_area_room != NULL)
pRoomIndex=pArea->first_area_room->data;
sprintf( buf, "[%5d] %s\n\r",
pArea->first_area_room !=NULL ? pRoomIndex->vnum : 0,
pArea->name );
safe_strcat( MSL, buf1, buf );
}
}
if ( !found )
{
send_to_char( "No area like that.\n\r", ch );
return;
}
send_to_char( buf1, ch );
return;
}
void build_showarea( CHAR_DATA *ch, char * argument)
{
AREA_DATA * pArea;
char buf[MAX_STRING_LENGTH];
char buffer[MAX_INPUT_LENGTH];
pArea=ch->in_room->area;
if (! build_canread(pArea,ch,1))
return;
buf[0]='\0';
sprintf(buffer,"\n\rTitle: %s\n\r",pArea->name);
safe_strcat( MSL, buf,buffer);
sprintf(buffer,"Keyword: %s\n\r",pArea->keyword);
safe_strcat( MSL, buf,buffer);
if (get_trust(ch) >= MAX_LEVEL-1)
{
sprintf(buffer,"filename: %s\n\r",pArea->filename);
safe_strcat( MSL, buf,buffer);
}
sprintf( buffer, "OFFSET: %d\n\r", pArea->offset );
safe_strcat( MSL, buf, buffer );
sprintf(buffer,"Owner: %s\n\rCan Read: %s\n\rCan Write: %s\n\r",
pArea->owner,
pArea->can_read,
pArea->can_write);
safe_strcat( MSL, buf,buffer);
sprintf(buffer,"Min Vnum: %5d Max Vnum: %5d\n\r",
pArea->min_vnum, pArea->max_vnum );
safe_strcat( MSL, buf,buffer);
send_to_char(buf,ch);
return;
}
void build_arealist( CHAR_DATA *ch, char *argument )
{
/* -S- : Show list of areas, vnum range and owners. */
char buf[MAX_STRING_LENGTH];
char msg[MAX_STRING_LENGTH];
AREA_DATA *pArea;
sh_int stop_counter = 0;
buf[0] = '\0';
sprintf( msg, "%s", "Areas of " mudnamecolor ":\n\r" );
for ( pArea = first_area; pArea != NULL; pArea = pArea->next )
{
sprintf( buf, "%12s [%5d to %5d] %s [%s]\n\r", capitalize( pArea->owner ),
pArea->min_vnum, pArea->max_vnum, pArea->name, pArea->filename );
stop_counter++;
if (stop_counter > 40 )
{
safe_strcat( MSL, msg, buf );
stop_counter = 0;
send_to_char( msg, ch );
msg[0] = '\0';
}
else
{
safe_strcat( MAX_STRING_LENGTH, msg, buf );
}
}
send_to_char( msg, ch );
return;
}