static const char *prep_find_entity_vnum(struct char_data *ch, const char *argument, char *arg, const char *entity,
void (*help_entity_properties_fn)(struct char_data *ch),
void (*entity_empty_fn)(struct char_data *ch, const char *arg, struct buf_type *buffer))
{
if (ch == NULL || IS_NPC(ch))
return NULL;
if (argument[0] == '\0') {
char buf[200];
snprintf(buf, 200, "\n\r%s: Find what?\n\r", entity);
send_to_char(buf, ch);
return NULL;
}
argument = one_argument(argument, arg);
if (arg[0] == '?' || !str_prefix(arg, "help")) {
show_help(ch->desc, (char *)entity, NULL);
return NULL;
}
if (!str_prefix(arg, "list")) {
(*help_entity_properties_fn)(ch);
return NULL;
} else
if (!str_prefix(arg, "empty")) {
struct buf_type *buffer = new_buf();
argument = one_argument(argument, arg);
(*entity_empty_fn)(ch, arg, buffer);
page_to_char(buf_string(buffer), ch);
free_buf(buffer);
return NULL;
}
return argument;
}
void func_list_mail(USER_DATA *usr) {
MAIL_DATA *pMail;
char buf[STRING];
BUFFER *buffer;
int vnum = 0;
buffer = new_buf();
add_buf(buffer, " Num Date From Subject\n\r");
for (pMail = usr->pMailFirst; pMail; pMail = pMail->next) {
if (pMail) {
sprintf(buf, "%s %3d %s %-15s %s\n\r", pMail->marked ? "M"
: (pMail->stamp_time > pMail->read_time) ? "N" : " ", vnum
+ 1, time_str(pMail->stamp_time), pMail->from,
pMail->subject);
add_buf(buffer, buf);
vnum++;
}
}
if (vnum > 0) {
page_to_user(buf_string(buffer), usr);
free_buf(buffer);
return;
}
send_to_user("You don't have any mail.\n\r", usr);
free_buf(buffer);
return;
}
void func_rnew_mail(USER_DATA *usr) {
MAIL_DATA *pMail;
char buf[STRING];
BUFFER *buffer;
int vnum = 1;
buffer = new_buf();
for (pMail = usr->pMailFirst; pMail; pMail = pMail->next) {
if (pMail->stamp_time <= pMail->read_time)
break;
}
if (pMail) {
time_t *last_read = &pMail->read_time;
*last_read = UMAX(*last_read, pMail->stamp_time);
sprintf(buf, "Reading new message %d.\n\rDate: %s\n\rFrom: %s\n\r"
"Subject: %s\n\r\n\r", vnum, time_str(pMail->stamp_time),
pMail->from, pMail->subject);
add_buf(buffer, buf);
add_buf(buffer, pMail->message);
add_buf(buffer, "#x\n\r");
page_to_user(buf_string(buffer), usr);
free_buf(buffer);
save_mail(usr);
return;
}
send_to_user("No new messages.\n\r", usr);
return;
}
void do_replay (CHAR_DATA *ch, char *argument)
{
if (IS_NPC(ch))
{
send_to_char("You can't replay.\n\r",ch);
return;
}
if (buf_string(ch->pcdata->buffer)[0] == '\0')
{
send_to_char("You have no tells to replay.\n\r",ch);
return;
}
page_to_char(buf_string(ch->pcdata->buffer),ch);
clear_buf(ch->pcdata->buffer);
}
static void help_mvnum_properties(struct char_data *ch)
{
struct buf_type *buffer = new_buf();
char buf[MAX_INPUT_LENGTH];
int iter;
add_buf(buffer, "`#QUERY``: mvnum: searchable property list\n\r");
for (iter = 0; mob_idx_flags[iter].var[0] != '\0'; iter++) {
sprintf(buf, "%-18.17s", mob_idx_flags[iter].var);
add_buf(buffer, buf);
if ((iter % 2) == 1)
add_buf(buffer, "\n\r");
}
add_buf(buffer, "\n\r");
page_to_char(buf_string(buffer), ch);
free_buf(buffer);
}
void do_matlist(CHAR_DATA *ch, char *argument) {
MAT_TYPE *mat, *mat_next;
BUFFER *output = new_buf();
int col = 0;
for(mat = mat_list; mat; mat = mat_next) {
mat_next = mat->next;
add_buf(output, Format("%-15s", mat->name) );
if(++col == 5) {
col = 0;
add_buf(output, "\n\r");
}
}
page_to_char(buf_string(output), ch);
free_buf(output);
return;
}
void
do_mplist (CHAR_DATA * ch, char *argument)
{
int count;
MPROG_CODE *mprg;
char buf[MAX_STRING_LENGTH];
BUFFER *buffer;
buffer = new_buf ();
for (count = 1, mprg = mprog_list; mprg != NULL; mprg = mprg->next)
{
sprintf (buf, "[%3d] %5d\n\r", count, mprg->vnum);
add_buf (buffer, buf);
count++;
}
page_to_char (buf_string (buffer), ch);
free_buf (buffer);
return;
}
/*****************************************************************************
* Name: show_olc_cmds
* Purpose: Format up the commands from given table.
* Called by: show_commands(olc_act.c).
****************************************************************************/
static void show_olc_cmds(struct char_data *ch, const struct olc_cmd_type *olc_table)
{
struct buf_type *out;
char buf[MAX_STRING_LENGTH];
int cmd;
int col;
col = 0;
out = new_buf();
for (cmd = 0; olc_table[cmd].name != NULL; cmd++) {
sprintf(buf, "%-15.15s", olc_table[cmd].name);
add_buf(out, buf);
if (++col % 5 == 0)
add_buf(out, "\n\r");
}
if (col % 5 != 0)
add_buf(out, "\n\r");
send_to_char(buf_string(out), ch);
free_buf(out);
return;
}
void func_read_mail(USER_DATA *usr, char *argument) {
MAIL_DATA *pMail;
char buf[STRING];
BUFFER *buffer;
int vnum = 1;
int anum = 0;
if (argument[0] == '\0' || !is_number(argument)) {
syntax("[#Wre#x]ad <mail number>", usr);
return;
}
anum = atoi(argument);
buffer = new_buf();
for (pMail = usr->pMailFirst; pMail; pMail = pMail->next) {
if (pMail && (vnum++ == anum)) {
time_t *last_read = &pMail->read_time;
*last_read = UMAX(*last_read, pMail->stamp_time);
sprintf(buf, "Reading message %d.\n\rDate: %s\n\rFrom: %s\n\r"
"Subject: %s\n\r\n\r", vnum - 1, time_str(pMail->stamp_time),
pMail->from, pMail->subject);
add_buf(buffer, buf);
add_buf(buffer, pMail->message);
add_buf(buffer, "#x\n\r");
page_to_user(buf_string(buffer), usr);
free_buf(buffer);
save_mail(usr);
return;
}
}
send_to_user("There aren't that many mail.\n\r", usr);
return;
}
void replay(struct char_data *ch) {
page_to_char(buf_string(ch->pcdata->buffer), ch);
clear_buf(ch->pcdata->buffer);
return;
}
void do_play(CHAR_DATA *ch, char *argument)
{
OBJ_DATA *juke;
char *str,arg[MAX_INPUT_LENGTH];
int song,i;
bool global = FALSE;
str = one_argument(argument,arg);
for (juke = ch->in_room->contents; juke != NULL; juke = juke->next_content)
if (juke->item_type == ITEM_JUKEBOX && can_see_obj(ch,juke))
break;
if (argument[0] == '\0')
{
send_to_char("Play what?\n\r",ch);
return;
}
if (juke == NULL)
{
send_to_char("You see nothing to play.\n\r",ch);
return;
}
if (!str_cmp(arg,"list"))
{
BUFFER *buffer;
char buf[MSL]={'\0'};
int col = 0;
bool artist = FALSE, match = FALSE;
buffer = new_buf();
argument = str;
argument = one_argument(argument,arg);
if (!str_cmp(arg,"artist"))
artist = TRUE;
if (argument[0] != '\0')
match = TRUE;
sprintf(buf,"%s has the following songs available:\n\r",
juke->short_descr);
add_buf(buffer,capitalize(buf));
for (i = 0; i < MAX_SONGS; i++)
{
if (song_table[i].name == NULL)
break;
if (artist && (!match
|| !str_prefix(argument,song_table[i].group)))
sprintf(buf,"%-39s %-39s\n\r",
song_table[i].group,song_table[i].name);
else if (!artist && (!match
|| !str_prefix(argument,song_table[i].name)))
sprintf(buf,"%-35s ",song_table[i].name);
else
continue;
add_buf(buffer,buf);
if (!artist && ++col % 2 == 0)
add_buf(buffer,"\n\r");
}
if (!artist && col % 2 != 0)
add_buf(buffer,"\n\r");
page_to_char(buf_string(buffer),ch);
free_buf(buffer);
return;
}
if (!str_cmp(arg,"loud"))
{
argument = str;
global = TRUE;
}
if (argument[0] == '\0')
{
send_to_char("Play what?\n\r",ch);
return;
}
if ((global && channel_songs[MAX_GLOBAL] > -1)
|| (!global && juke->value[4] > -1))
{
send_to_char("The jukebox is full up right now.\n\r",ch);
return;
}
for (song = 0; song < MAX_SONGS; song++)
{
if (song_table[song].name == NULL)
{
send_to_char("That song isn't available.\n\r",ch);
return;
}
if (!str_prefix(argument,song_table[song].name))
break;
}
if (song >= MAX_SONGS)
{
send_to_char("That song isn't available.\n\r",ch);
return;
}
send_to_char("Coming right up.\n\r",ch);
if (global)
{
for (i = 1; i <= MAX_GLOBAL; i++)
if (channel_songs[i] < 0)
{
if (i == 1)
channel_songs[0] = -1;
channel_songs[i] = song;
return;
}
}
else
{
for (i = 1; i < 5; i++)
if (juke->value[i] < 0)
{
if (i == 1)
juke->value[0] = -1;
juke->value[i] = song;
return;
}
}
}
/*
* The main entry point for executing commands.
* Can be recursively called from 'at', 'order', 'force'.
*/
void interpret( CHAR_DATA *ch, const char *argument0 )
{
char command[MAX_INPUT_LENGTH];
char logline[MAX_INPUT_LENGTH];
int cmd;
int trust;
bool found;
// Added by SinaC 2001, true if it's a mob program command
bool found_mob;
char *argument = new char [MAX_INPUT_LENGTH];
strcpy(argument,argument0);
for( char *s = argument; *s; s++ )
*s = ( *s == '~' ? '-' : *s );
/*
* Strip leading spaces.
*/
while ( isspace(*argument) )
argument++;
if ( argument[0] == '\0' )
return;
// Added by SinaC 2001
if ( ch->in_room == NULL ) {
send_to_char("You're not in a room ... How did you do that ?", ch );
return;
}
/*
* No hiding.
*/
/* Oxtal> I still don't figure out what this does */
// when we're Hiding, if we do something, Hide disappears SinaC 2000
if (IS_SET(ch->bstat(affected_by),AFF_HIDE)) {
REMOVE_BIT( ch->bstat(affected_by), AFF_HIDE );
recompute(ch);
}
/*
* Implement freeze command.
*/
if ( !IS_NPC(ch) && IS_SET(ch->act, PLR_FREEZE) ) {
send_to_char( "You're totally frozen!\n\r", ch );
return;
}
/*
* Grab the command word.
* Special parsing so ' can be a command,
* also no spaces needed after punctuation.
*/
strcpy( logline, argument );
sprintf(last_command,"%s(%d) in room[%d]: %s.",
ch->name,
IS_NPC(ch)?ch->pIndexData->vnum:-1,
ch->in_room?ch->in_room->vnum:-1,
argument );
const char* argument2;
if ( !isalpha(argument[0]) && !isdigit(argument[0])) {
command[0] = argument[0];
command[1] = '\0';
argument++;
while ( isspace(*argument) )
argument++;
argument2 = argument;
}
else {
// Added by SinaC 2003, really crappy
if ( !str_prefix( "jog", argument ) || !str_prefix( "jo", argument ) ) // for jog command
argument2 = no_lower_one_argument( argument, command );
else
argument2 = one_argument( argument, command );
}
/*
* Look for command in command table.
*/
// Added by SinaC 2001
found_mob = FALSE;
found = FALSE;
trust = get_trust( ch );
//for ( cmd = 0; cmd_table[cmd].name[0] != '\0'; cmd++ ) {
for ( cmd = 0; cmd < MAX_COMMANDS; cmd++ ) {
if ( command[0] == cmd_table[cmd].name[0]
&& !str_prefix( command, cmd_table[cmd].name )
&& cmd_table[cmd].level <= trust ) {
found = TRUE;
break;
}
}
/*
* Log and snoop.
*/
if ( found && cmd_table[cmd].log == LOG_NEVER )
strcpy( logline, "" );
if ( found &&
( ( !IS_NPC(ch) && IS_SET(ch->act, PLR_LOG) )
|| fLogAll
|| cmd_table[cmd].log == LOG_ALWAYS ) ) {
// Modified by SinaC 2000
sprintf( log_buf, "Log %s: %s (%s)",
ch->name,
logline,
cmd_table[cmd].name
);
wiznet(log_buf,ch,NULL,WIZ_SECURE,0,get_trust(ch));
log_string( log_buf );
}
// Added by SinaC 2001, if player was afk, afk is removed.
if ( IS_SET(ch->comm,COMM_AFK)
// unless player is trying to remove afk with afk command
&& ( found && str_cmp(cmd_table[cmd].name,"afk") )
&& !IS_IMMORTAL(ch) ) {
send_to_char("{GAFK{x mode removed.\n\r",ch);
if (buf_string(ch->pcdata->buffer)[0] != '\0' )
send_to_char("{rYou have received tells: Type {Y'replay'{r to see them.{x\n\r",ch);
REMOVE_BIT(ch->comm,COMM_AFK);
}
if ( ch->desc != NULL && ch->desc->snoop_by != NULL ) {
write_to_buffer( ch->desc->snoop_by, "% ", 2 );
write_to_buffer( ch->desc->snoop_by, logline, 0 );
write_to_buffer( ch->desc->snoop_by, "\n\r", 2 );
}
if ( !found ) {
if( !check_social( ch, command, argument2 ) ) {
// Modified by SinaC 2000
// send_to_char( "Huh?\n\r", ch );
random_error( ch );
if ( SCRIPT_VERBOSE > 0 ) {
if ( IS_NPC(ch) ) // Added by SinaC 2003
log_stringf("%s (%d) tries to use command: %s %s",
NAME(ch), ch->pIndexData->vnum,
command, argument2 );
}
}
return;
}
else {
if ( check_disabled(&cmd_table[cmd]) ) {
send_to_char( "This command has been temporarily disabled.\n\r", ch );
return;
}
// Added by SinaC 2001 for player disabled commands
if ( check_disabled_plr( ch, &cmd_table[cmd] ) ) {
send_to_char( "The gods has removed your ability to use that command.\n\r", ch );
return;
}
}
/*
* Character not in position for command?
*/
if ( ch->position < cmd_table[cmd].position ) {
switch( ch->position ) {
case POS_DEAD:
send_to_char( "Lie still; you are DEAD.\n\r", ch );
break;
case POS_MORTAL:
case POS_INCAP:
send_to_char( "You are hurt far too bad for that.\n\r", ch );
break;
// Added by SinaC 2003
case POS_PARALYZED:
send_to_char( "You are paralyzed, you can't move.\n\r", ch);
break;
case POS_STUNNED:
send_to_char( "You are too stunned to do that.\n\r", ch );
break;
case POS_SLEEPING:
send_to_char( "In your dreams, or what?\n\r", ch );
break;
case POS_RESTING:
send_to_char( "Nah... You feel too relaxed...\n\r", ch);
break;
case POS_SITTING:
send_to_char( "Better stand up first.\n\r",ch);
break;
case POS_FIGHTING:
send_to_char( "No way! You are still fighting!\n\r", ch);
break;
}
return;
}
/*
* Dispatch the command.
*/
/* Oxtal -- Output the commands */
/* SinaC --- We don't need that for the moment
*if ( cmd_table[cmd].log != LOG_NEVER ) {
* char *strtime;
*
* strtime = ctime( ¤t_time );
* strtime[strlen(strtime)-1] = '\0';
* fprintf( stdout, "%s %15s [%5d] %s %s\n",
* strtime,
* ch->name,
* ch->in_room ? ch->in_room->vnum : 0,
* cmd_table[cmd].name,
* argument);
*}
*/ // removed by SinaC 2000
// Modified by SinaC 2001 to detect memory leak
char buf[MAX_STRING_LENGTH];
// Modified by SinaC 2001
if ( found )
(*cmd_table[cmd].do_fun) ( ch, argument2 );
return;
}
void parse_note( CHAR_DATA *ch, char *argument, int type )
{
BUFFER *buffer;
char buf[MAX_STRING_LENGTH], query[MSL];
char arg[MAX_INPUT_LENGTH];
MYSQL_RES *res;
MYSQL_ROW row;
char *list_name;
int vnum;
int anum;
switch(type)
{
default:
return;
case NOTE_NOTE:
list_name = "notes";
break;
case NOTE_IDEA:
list_name = "ideas";
break;
case NOTE_PENALTY:
list_name = "penalties";
break;
case NOTE_NEWS:
list_name = "news";
break;
case NOTE_CHANGES:
list_name = "changes";
break;
}
argument = one_argument( argument, arg );
smash_tilde( argument );
if ( arg[0] == '\0' || !str_prefix( arg, "read" ) )
{
bool fAll;
if ( !str_cmp( argument, "all" ) )
{
fAll = TRUE;
anum = 0;
}
else if ( argument[0] == '\0' || !str_prefix(argument, "next"))
/* read next unread note */
{
vnum = 0;
sprintf(query,"SELECT * FROM notes WHERE type=%d ORDER BY timestamp ASC",type);
res = one_query_res(query);
while((row=mysql_fetch_row(res)))
{
if (!hide_note(ch,row))
{
sprintf( buf, "[%3d] %s: %s\n\r%s\n\rTo: %s\n\r",
vnum, row[1], row[4], row[2], row[3]);
send_to_char( buf, ch );
page_to_char( row[5], ch );
update_read(ch,atol(row[6]),atoi(row[0]));
mysql_free_result(res);
return;
}
else if(is_note_to(ch,row[1],row[3]))
vnum++;
}
sprintf(buf,"You have no unread %s.\n\r",list_name);
send_to_char(buf,ch);
mysql_free_result(res);
return;
}
else if ( is_number( argument ) )
{
fAll = FALSE;
anum = atoi( argument );
}
else
{
send_to_char( "Read which number?\n\r", ch );
return;
}
vnum = 0;
sprintf(query,"SELECT * FROM notes WHERE type=%d ORDER BY timestamp ASC",type);
res = one_query_res(query);
while((row=mysql_fetch_row(res)))
{
if (is_note_to(ch,row[1],row[3]) && (vnum++ == anum))
{
sprintf( buf, "[%3d] %s: %s\n\r%s\n\rTo: %s\n\r",
anum, row[1], row[4], row[2], row[3]);
send_to_char( buf, ch );
page_to_char( row[5], ch );
update_read(ch,atol(row[6]),atoi(row[0]));
mysql_free_result(res);
return;
}
}
sprintf(buf,"There aren't that many %s.\n\r",list_name);
send_to_char(buf,ch);
mysql_free_result(res);
return;
}
if ( !str_prefix( arg, "list" ) )
{
vnum = 0;
sprintf(query,"SELECT * FROM notes WHERE type=%d ORDER BY timestamp ASC",type);
res = one_query_res(query);
while((row=mysql_fetch_row(res)))
{
if (is_note_to(ch,row[1],row[3]))
{
sprintf( buf, "[%3d%s] %s: %s\n\r",
vnum, hide_note(ch,row) ? " " : "N",
row[1], row[4]);
send_to_char( buf, ch );
vnum++;
}
}
if (!vnum)
{
switch(type)
{
case NOTE_NOTE:
send_to_char("There are no notes for you.\n\r",ch);
break;
case NOTE_IDEA:
send_to_char("There are no ideas for you.\n\r",ch);
break;
case NOTE_PENALTY:
send_to_char("There are no penalties for you.\n\r",ch);
break;
case NOTE_NEWS:
send_to_char("There is no news for you.\n\r",ch);
break;
case NOTE_CHANGES:
send_to_char("There are no changes for you.\n\r",ch);
break;
}
}
mysql_free_result(res);
return;
}
if ( !str_prefix( arg, "remove" ) )
{
if ( !is_number( argument ) )
return send_to_char( "Note remove which number?\n\r", ch );
anum = atoi( argument );
vnum = 0;
sprintf(query,"SELECT * FROM notes WHERE type=%d ORDER BY timestamp ASC",type);
res = one_query_res(query);
while((row=mysql_fetch_row(res)))
{
if (!str_cmp(ch->true_name, row[1]) && vnum++ == anum )
{
sprintf(query,"DELETE FROM notes WHERE timestamp=%s AND sender=\"%s\"", row[6], row[1]);
one_query(query);
send_to_char( "Ok.\n\r", ch );
mysql_free_result(res);
return;
}
}
send_to_char("You must provide the number of a note you have written to remove.\n\r",ch);
mysql_free_result(res);
return;
}
if ( !str_prefix( arg, "delete" ) && get_trust(ch) >= MAX_LEVEL - 2)
{
if ( !is_number( argument ) )
return send_to_char( "Note delete which number?\n\r", ch );
anum = atoi( argument );
vnum = 0;
sprintf(query,"SELECT * FROM notes WHERE type=%d ORDER BY timestamp ASC",type);
res = one_query_res(query);
while((row=mysql_fetch_row(res)))
{
if ( is_note_to( ch,row[1],row[3] ) && vnum++ == anum )
{
sprintf(query,"DELETE FROM notes WHERE timestamp=%s AND sender=\"%s\"", row[6], row[1]);
one_query(query);
send_to_char("Ok.\n\r",ch);
mysql_free_result(res);
return;
}
}
sprintf(buf,"There aren't that many %s.\n\r",list_name);
send_to_char(buf,ch);
mysql_free_result(res);
return;
}
/* below this point only certain people can edit notes */
if ((type == NOTE_NEWS && !IS_TRUSTED(ch,ANGEL))
|| (type == NOTE_CHANGES && !IS_TRUSTED(ch,CREATOR)))
{
sprintf(buf,"You aren't high enough level to write %s.",list_name);
send_to_char(buf,ch);
return;
}
if ( !str_cmp( arg, "+" ) )
{
note_attach( ch,type );
if (ch->pnote->type != type)
return send_to_char("You already have a different note in progress.\n\r",ch);
if (strlen(ch->pnote->text)+strlen(argument) >= 4096)
return send_to_char( "Note too long.\n\r", ch );
buffer = new_buf();
add_buf(buffer,ch->pnote->text);
add_buf(buffer,argument);
add_buf(buffer,"\n\r");
free_pstring( ch->pnote->text );
ch->pnote->text = palloc_string( buf_string(buffer) );
free_buf(buffer);
send_to_char( "Ok.\n\r", ch );
return;
}
if (!str_cmp(arg,"-"))
{
int len;
bool found = FALSE;
note_attach(ch,type);
if (ch->pnote->type != type)
return send_to_char("You already have a different note in progress.\n\r",ch);
if (ch->pnote->text == NULL || ch->pnote->text[0] == '\0')
return send_to_char("No lines left to remove.\n\r",ch);
strcpy(buf,ch->pnote->text);
for (len = strlen(buf); len > 0; len--)
{
if (buf[len] == '\r')
{
if (!found) /* back it up */
{
if (len > 0)
len--;
found = TRUE;
}
else /* found the second one */
{
buf[len + 1] = '\0';
free_pstring(ch->pnote->text);
ch->pnote->text = palloc_string(buf);
return;
}
}
}
buf[0] = '\0';
free_pstring(ch->pnote->text);
ch->pnote->text = palloc_string(buf);
return;
}
if ( !str_prefix( arg, "subject" ) )
{
note_attach( ch,type );
if (ch->pnote->type != type)
return send_to_char("You already have a different note in progress.\n\r",ch);
free_pstring( ch->pnote->subject );
ch->pnote->subject = palloc_string( argument );
send_to_char( "Ok.\n\r", ch );
return;
}
if ( !str_prefix( arg, "to" ) )
{
note_attach( ch,type );
if (ch->pnote->type != type)
return send_to_char("You already have a different note in progress.\n\r",ch);
if (is_name("all", argument)
&& !IS_IMMORTAL(ch)
&& !IS_HEROIMM(ch)
&& !(ch->pcdata->induct == CABAL_LEADER))
return send_to_char("Sorry, you can't do that!\n\r",ch);
if (is_number(argument) && !IS_IMMORTAL(ch))
return send_to_char("You can't do that.\n\r",ch);
free_pstring( ch->pnote->to_list );
ch->pnote->to_list = palloc_string( argument );
send_to_char( "Ok.\n\r", ch );
return;
}
if ( !str_prefix( arg, "clear" ) )
{
if ( ch->pnote != NULL )
{
free_note(ch->pnote);
ch->pnote = NULL;
}
send_to_char( "Ok.\n\r", ch );
return;
}
if ( !str_prefix( arg, "show" ) )
{
if ( ch->pnote == NULL )
return send_to_char( "You have no note in progress.\n\r", ch );
if (ch->pnote->type != type)
return send_to_char("You aren't working on that kind of note.\n\r",ch);
sprintf( buf, "%s: %s\n\rTo: %s\n\r",
ch->pnote->sender,
ch->pnote->subject,
ch->pnote->to_list
);
send_to_char( buf, ch );
send_to_char( ch->pnote->text, ch );
return;
}
if ( !str_prefix( arg, "post" ) || !str_prefix(arg, "send"))
{
char *strtime;
if ( ch->pnote == NULL )
return send_to_char( "You have no note in progress.\n\r", ch );
if (ch->pnote->type != type)
return send_to_char("You aren't working on that kind of note.\n\r",ch);
if (!str_cmp(ch->pnote->to_list,""))
return send_to_char("You need to provide a recipient (name, all, or immortal).\n\r", ch);
if (!str_cmp(ch->pnote->subject,""))
return send_to_char("You need to provide a subject.\n\r",ch);
if (is_affected_prof(ch, "note_written") && !IS_IMMORTAL(ch))
return send_to_char("You have written a note too recently.\n\r",ch);
ch->pnote->next = NULL;
strtime = ctime( ¤t_time );
strtime[strlen(strtime)-1] = '\0';
ch->pnote->date = palloc_string( strtime );
ch->pnote->date_stamp = current_time;
append_note(ch->pnote);
ch->pnote = NULL;
send_to_char("Note sent.\n\r",ch);
add_prof_affect(ch, "note_written", 4, TRUE);
return;
}
send_to_char( "You can't do that.\n\r", ch );
return;
}
void parse_sign( CHAR_DATA *ch, char *argument, int type )
{
BUFFER *buffer;
char buf[MAX_STRING_LENGTH];
char arg[MAX_INPUT_LENGTH];
OBJ_INDEX_DATA *pObjIndex;
OBJ_DATA *obj;
if ( IS_NPC(ch) )
return;
argument = one_argument( argument, arg );
smash_tilde( argument );
if ( arg[0] == '\0' )
{
return;
}
if ( !str_cmp( arg, "+" ) )
{
sign_attach( ch,type );
if (ch->pnote->type != type)
{
send_to_char(
"You already have a different note in progress.\n\r",ch);
return;
}
if (strlen(ch->pnote->text)+strlen(argument) >= 4096)
{
send_to_char( "Sign too long.\n\r", ch );
return;
}
buffer = new_buf();
add_buf(buffer,ch->pnote->text);
add_buf(buffer,argument);
add_buf(buffer,"\n\r");
free_string( ch->pnote->text );
ch->pnote->text = str_dup( buf_string(buffer) );
free_buf(buffer);
send_to_char( "Ok.\n\r", ch );
return;
}
if (!str_cmp(arg,"-"))
{
int len;
bool found = FALSE;
sign_attach(ch,type);
if (ch->pnote->type != type)
{
send_to_char(
"You already have a different note in progress.\n\r",ch);
return;
}
if (ch->pnote->text == NULL || ch->pnote->text[0] == '\0')
{
send_to_char("No lines left to remove.\n\r",ch);
return;
}
strcpy(buf,ch->pnote->text);
for (len = strlen(buf); len > 0; len--)
{
if (buf[len] == '\r')
{
if (!found) /* back it up */
{
if (len > 0)
len--;
found = TRUE;
}
else /* found the second one */
{
buf[len + 1] = '\0';
free_string(ch->pnote->text);
ch->pnote->text = str_dup(buf);
return;
}
}
}
buf[0] = '\0';
free_string(ch->pnote->text);
ch->pnote->text = str_dup(buf);
return;
}
if ( !str_prefix( arg, "make" ) )
{
sign_attach( ch,type );
if (ch->pnote->type != type)
{
send_to_char(
"You already have a different note in progress.\n\r",ch);
return;
}
free_string( ch->pnote->to_list );
free_string( ch->pnote->subject );
send_to_char( "Ok.\n\r", ch );
return;
}
if ( !str_prefix( arg, "clear" ) )
{
if ( ch->pnote != NULL )
{
free_note(ch->pnote);
ch->pnote = NULL;
}
send_to_char( "Ok.\n\r", ch );
return;
}
if ( !str_prefix( arg, "show" ) )
{
if ( ch->pnote == NULL )
{
send_to_char( "You have no sign in progress.\n\r", ch );
return;
}
if (ch->pnote->type != type)
{
send_to_char("You aren't working on that kind of note.\n\r",ch);
return;
}
send_to_char( ch->pnote->text, ch );
return;
}
if ( !str_prefix( arg, "post" ) || !str_prefix(arg, "send")
|| !str_prefix(arg, "save"))
{
EXTRA_DESCR_DATA *ed;
if ( ch->pnote == NULL )
{
send_to_char( "You have no sign in progress.\n\r", ch );
return;
}
if (ch->pnote->type != type)
{
send_to_char("You aren't working on that kind of note.\n\r",ch);
return;
}
pObjIndex = get_obj_index(OBJ_VNUM_QUEST_SIGN);
obj = create_object( pObjIndex, ch->level );
obj_to_room( obj, ch->in_room );
ed = new_extra_descr();
ed->keyword = str_dup( "sign" );
buffer = new_buf();
add_buf(buffer,ch->pnote->text);
ed->description = str_dup(buf_string(buffer));
ed->next = NULL;
obj->extra_descr = ed;
ch->pnote = NULL;
send_to_char( "A sign now floats before you.\n\r", ch );
return;
}
send_to_char( "You can't do that.\n\r", ch );
return;
}
/** mwhere <var> <value> */
void do_mwhere(struct char_data *ch, const char *argument)
{
struct buf_type *buffer;
CHAR_CMP_FN *cmp_fn;
char buf[MAX_INPUT_LENGTH];
char arg[MAX_INPUT_LENGTH];
int iter;
if (ch == NULL || IS_NPC(ch))
return;
if (argument[0] == '\0') {
send_to_char("\n\rFind what?\n\r", ch);
return;
}
if (argument[0] == '?' || !str_prefix(argument, "help")) {
show_help(ch->desc, "mwhere", NULL);
return;
}
buffer = new_buf();
if (!str_prefix(argument, "list")) {
add_buf(buffer, "mwhere: searchable property list\n\r");
for (iter = 0; char_flags[iter].var[0] != '\0'; iter++) {
sprintf(buf, "%-18.17s", char_flags[iter].var);
add_buf(buffer, buf);
if ((iter % 2) == 1)
add_buf(buffer, "\n\r");
}
add_buf(buffer, "\n\r");
page_to_char(buf_string(buffer), ch);
return;
}
sprintf(buf, "`#QUERY``: mwhere %s\n\r\n\r", argument);
add_buf(buffer, buf);
if (argument[0] == '\0') {
cmp_fn = char_cmp_name;
} else {
cmp_fn = NULL;
one_argument(argument, arg);
for (iter = 0; char_flags[iter].var[0] != '\0'; iter++) {
if (!str_prefix(arg, char_flags[iter].var)) {
cmp_fn = (CHAR_CMP_FN *)char_flags[iter].fn;
argument = one_argument(argument, arg);
break;
}
}
if (cmp_fn == NULL)
cmp_fn = char_cmp_name;
}
if (argument[0] == '?' || argument[0] == '\0') {
clear_buf(buffer);
sprintf(buf, "`#SYNTAX``:\n\r"
" mwhere %s <value>:\n\r\n\r", arg);
add_buf(buffer, buf);
(*cmp_fn)(char_list, argument, buffer);
page_to_char(buf_string(buffer), ch);
} else {
struct char_data *vch;
char *clr1;
char *clr2;
int number;
number = 0;
for (vch = char_list; vch != NULL; vch = vch->next) {
if (can_see(ch, vch)
&& vch->in_room != NULL
&& (*cmp_fn)(vch, argument, NULL)) {
number++;
if (number == 1) {
sprintf(buf, "# vnum name where room\n\r");
add_buf(buffer, buf);
sprintf(buf, "=== ====== =========================== ========================== =====\n\r");
add_buf(buffer, buf);
}
clr1 = uncolor_str(IS_NPC(vch) ? vch->short_descr : vch->name);
clr2 = uncolor_str(vch->in_room->name);
sprintf(buf, "%-3d %-7ld %-26.26s %-25.25s %-7ld\n\r",
number,
IS_NPC(vch) ? vch->mob_idx->vnum : 0,
clr1,
clr2,
vch->in_room->vnum);
free_string(clr1);
free_string(clr2);
buf[0] = UPPER(buf[0]);
add_buf(buffer, buf);
if (number >= MAX_RETURN)
break;
}
}
if (number == 0)
send_to_char("Nothing like that in heaven or earth.\n\r", ch);
else
page_to_char(buf_string(buffer), ch);
}
free_buf(buffer);
}
void do_spells(CHAR_DATA *ch, char *argument)
{
BUFFER *buffer;
char arg[MAX_INPUT_LENGTH];
char spell_list[LEVEL_HERO + 1][MAX_STRING_LENGTH];
char spell_columns[LEVEL_HERO + 1];
int sn, level, min_lev = 1, max_lev = LEVEL_HERO, mana;
bool fAll = FALSE, found = FALSE;
char buf[MAX_STRING_LENGTH];
if (IS_NPC(ch))
return;
if(ch->Class()->ctype!=CLASS_CASTER)
{
send_to_char("Your class knows no spells.\n\r",ch);
return;
}
if (argument[0] != '\0')
{
fAll = TRUE;
if (str_prefix(argument,"all"))
{
argument = one_argument(argument,arg);
if (!is_number(arg))
{
send_to_char("Arguments must be numerical or all.\n\r",ch);
return;
}
max_lev = atoi(arg);
if (max_lev < 1 || max_lev > LEVEL_HERO)
{
sprintf(buf,"Levels must be between 1 and %d.\n\r",LEVEL_HERO);
send_to_char(buf,ch);
return;
}
if (argument[0] != '\0')
{
argument = one_argument(argument,arg);
if (!is_number(arg))
{
send_to_char("Arguments must be numerical or all.\n\r",ch);
return;
}
min_lev = max_lev;
max_lev = atoi(arg);
if (max_lev < 1 || max_lev > LEVEL_HERO)
{
sprintf(buf,
"Levels must be between 1 and %d.\n\r",LEVEL_HERO);
send_to_char(buf,ch);
return;
}
if (min_lev > max_lev)
{
send_to_char("That would be silly.\n\r",ch);
return;
}
}
}
}
/* initialize data */
for (level = 0; level < LEVEL_HERO + 1; level++)
{
spell_columns[level] = 0;
spell_list[level][0] = '\0';
}
for (sn = 0; sn < MAX_SKILL; sn++)
{
if (skill_table[sn].name == NULL )
break;
if ((level = skill_table[sn].skill_level[ch->Class()->GetIndex()]) < LEVEL_HERO + 1
&& level >= min_lev && level <= max_lev
&& skill_table[sn].spell_fun != spell_null
&& ch->pcdata->learned[sn] > 0
&& (skill_table[sn].ctype==CMD_SPELL || skill_table[sn].ctype==CMD_BOTH))
{
found = TRUE;
level = skill_table[sn].skill_level[ch->Class()->GetIndex()];
if (ch->level < level)
sprintf(buf,"%-18s n/a ", skill_table[sn].name);
else
{
mana = UMAX(skill_table[sn].min_mana,
100/(2 + ch->level - level));
sprintf(buf,"%-18s %3d mana ",skill_table[sn].name,mana);
}
if (spell_list[level][0] == '\0')
sprintf(spell_list[level],"\n\rLevel %2d: %s",level,buf);
else /* append */
{
if ( ++spell_columns[level] % 2 == 0)
strcat(spell_list[level],"\n\r ");
strcat(spell_list[level],buf);
}
}
}
/* return results */
if (!found)
{
send_to_char("No spells found.\n\r",ch);
return;
}
buffer = new_buf();
for (level = 0; level < LEVEL_HERO + 1; level++)
if (spell_list[level][0] != '\0')
add_buf(buffer,spell_list[level]);
add_buf(buffer,"\n\r");
page_to_char(buf_string(buffer),ch);
free_buf(buffer);
}
wiz_last->next = pwiz;
wiz_last = pwiz;
}
}
void do_wizlist(CHAR_DATA *ch, char *argument)
{
char arg1[MAX_INPUT_LENGTH];
char arg2[MAX_INPUT_LENGTH];
char arg3[MAX_INPUT_LENGTH];
char buf[MAX_STRING_LENGTH];
char title[MAX_STRING_LENGTH];
BUFFER *buffer;
int level;
WIZ_DATA *pwiz;
int lngth;
int amt;
bool found;
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
argument = one_argument( argument, arg3 );
/*
* Uncomment the following to use the old method of having
* a fixed wizlist in the rot.are file.
*/
/*
do_help(ch,"wizlist");
return;
*/
if ((arg1[0] != '\0') && (ch->level == MAX_LEVEL))
{
if ( !str_prefix( arg1, "add" ) )
{
if ( !is_number( arg2 ) || ( arg3[0] == '\0' ) )
{
send_to_char( "Syntax: wizlist add <level> <name>\n\r", ch );
return;
}
level = atoi(arg2);
change_wizlist( ch, TRUE, level, arg3 );
return;
}
if ( !str_prefix( arg1, "delete" ) )
{
if ( arg2[0] == '\0' )
{
send_to_char( "Syntax: wizlist delete <name>\n\r", ch );
return;
}
change_wizlist( ch, FALSE, 0, arg2 );
return;
}
send_to_char( "Syntax:\n\r", ch );
send_to_char( " wizlist delete <name>\n\r", ch );
send_to_char( " wizlist add <level> <name>\n\r", ch );
return;
}
if (wiz_list == NULL)
{
send_to_char("No immortals listed at this time.\n\r",ch);
return;
}
buffer = new_buf();
sprintf(title,"The Gods of Realms of Thoth");
sprintf(buf,"{x ___________________________________________________________________________\n\r");
add_buf(buffer,buf);
sprintf(buf,"{x /\\_\\%70s\\_\\\n\r", " ");
add_buf(buffer,buf);
lngth = (70 - strlen(title))/2;
for( ; lngth >= 0; lngth--)
{
strcat(title, " ");
}
sprintf(buf,"|/\\\\_\\{W%70s{x\\_\\\n\r", title);
add_buf(buffer,buf);
sprintf(buf,"{x\\_/_|_|%69s|_|\n\r", " ");
add_buf(buffer,buf);
for (level = IMPLEMENTOR; level > HERO; level--)
{
found = FALSE;
amt = 0;
for (pwiz = wiz_list;pwiz != NULL;pwiz = pwiz->next)
{
if (pwiz->level == level)
{
amt++;
found = TRUE;
}
}
if (!found)
{
if (level == HERO+1)
{
sprintf(buf,"{x ___|_|%69s|_|\n\r", " ");
add_buf(buffer,buf);
}
continue;
}
sprintf(buf,"{x |_|{R%37s {B[%d]{x%26s|_|\n\r",
wiz_titles[IMPLEMENTOR-level], level, " ");
add_buf(buffer,buf);
sprintf(buf,"{x |_|{Y%25s******************{x%26s|_|\n\r",
" ", " ");
add_buf(buffer,buf);
lngth = 0;
for (pwiz = wiz_list;pwiz != NULL;pwiz = pwiz->next)
{
if (pwiz->level == level)
{
if (lngth == 0)
{
if (amt > 2)
{
sprintf(buf, "{x |_|{%s%12s%-17s ",
level >= DEMI ? "G" : "C", " ",
pwiz->name);
add_buf(buffer, buf);
lngth = 1;
} else if (amt > 1)
{
sprintf(buf, "{x |_|{%s%21s%-17s ",
level >= DEMI ? "G" : "C", " ",
pwiz->name);
add_buf(buffer, buf);
lngth = 1;
} else
{
sprintf(buf, "{x |_|{%s%30s%-39s{x|_|\n\r",
level >= DEMI ? "G" : "C", " ",
pwiz->name);
add_buf(buffer, buf);
lngth = 0;
}
} else if (lngth == 1)
{
if (amt > 2)
{
sprintf(buf, "%-17s ",
pwiz->name);
add_buf(buffer, buf);
lngth = 2;
} else
{
sprintf(buf, "%-30s{x|_|\n\r",
pwiz->name);
add_buf(buffer, buf);
lngth = 0;
}
} else
{
sprintf(buf, "%-21s{x|_|\n\r",
pwiz->name);
add_buf(buffer, buf);
lngth = 0;
amt -= 3;
}
}
}
if (level == HERO+1)
{
sprintf(buf,"{x ___|_|%69s|_|\n\r", " ");
} else
{
sprintf(buf,"{x |_|%69s|_|\n\r", " ");
}
add_buf(buffer,buf);
}
sprintf(buf,"{x/ \\ |_|%69s|_|\n\r", " ");
add_buf(buffer,buf);
sprintf(buf,"{x|\\//_/%70s/_/\n\r", " ");
add_buf(buffer,buf);
sprintf(buf,"{x \\/_/______________________________________________________________________/_/\n\r");
add_buf(buffer,buf);
page_to_char( buf_string(buffer), ch );
free_buf(buffer);
return;
}
/**
* owhere <var> <value>
*/
void do_owhere(struct char_data *ch, const char *argument)
{
struct buf_type *buffer;
OBJ_CMP_FN *cmp_fn;
char buf[MAX_INPUT_LENGTH];
char arg[MAX_INPUT_LENGTH];
int iter;
if (ch == NULL || IS_NPC(ch))
return;
if (argument[0] == '\0') {
send_to_char("\n\rFind what?\n\r", ch);
return;
}
cmp_fn = NULL;
one_argument(argument, arg);
if (argument[0] == '?' || !str_prefix(argument, "help")) {
show_help(ch->desc, "owhere", NULL);
return;
}
buffer = new_buf();
if (!str_prefix(argument, "list")) {
add_buf(buffer, "owhere: searchable property list\n\r");
for (iter = 0; obj_flags[iter].var[0] != '\0'; iter++) {
sprintf(buf, "%-18.17s", obj_flags[iter].var);
add_buf(buffer, buf);
if ((iter % 2) == 1)
add_buf(buffer, "\n\r");
}
add_buf(buffer, "\n\r");
page_to_char(buf_string(buffer), ch);
return;
}
sprintf(buf, "`#QUERY``: owhere %s\n\r\n\r", argument);
add_buf(buffer, buf);
for (iter = 0; obj_flags[iter].var[0] != '\0'; iter++) {
if (!str_prefix(arg, obj_flags[iter].var)) {
cmp_fn = (OBJ_CMP_FN *)obj_flags[iter].fn;
argument = one_argument(argument, arg);
break;
}
}
if (cmp_fn == NULL)
cmp_fn = obj_cmp_name;
if (argument[0] == '?' || argument[0] == '\0') {
clear_buf(buffer);
sprintf(buf, "`#SYNTAX``:\n\r owhere %s <value>:\n\r\n\r", arg);
add_buf(buffer, buf);
(*cmp_fn)(object_iterator_start(&object_empty_filter), argument, buffer);
page_to_char(buf_string(buffer), ch);
} else {
struct gameobject *obj, *opending;
struct gameobject *in_obj;
char *clr1;
char *clr2;
int number;
number = 0;
opending = object_iterator_start(&object_empty_filter);
while ((obj = opending) != NULL) {
opending = object_iterator(obj, &object_empty_filter);
if (can_see_obj(ch, obj)
&& (*cmp_fn)(obj, argument, NULL)) {
number++;
if (number == 1) {
sprintf(buf, "# vnum name where room\n\r");
add_buf(buffer, buf);
sprintf(buf, "=== ====== =========================== ========================== =====\n\r");
add_buf(buffer, buf);
}
for (in_obj = obj; in_obj->in_obj != NULL; in_obj = in_obj->in_obj)
continue;
if (in_obj->carried_by != NULL
&& can_see(ch, in_obj->carried_by)
&& in_obj->carried_by->in_room != NULL) {
clr1 = uncolor_str(obj->short_descr);
clr2 = uncolor_str(PERS(in_obj->carried_by, ch));
sprintf(buf, "%-3d %-7ld %-26.26s %-25.25s %-7ld\n\r",
number,
obj->objprototype->vnum,
clr1,
clr2,
in_obj->carried_by->in_room->vnum);
free_string(clr1);
free_string(clr2);
} else if (in_obj->in_room != NULL && can_see_room(ch, in_obj->in_room)) {
clr1 = uncolor_str(obj->short_descr);
clr2 = uncolor_str(in_obj->in_room->name);
sprintf(buf, "%-3d %-7ld %-26.26s %-25.25s %-7ld\n\r",
number,
obj->objprototype->vnum,
clr1,
clr2,
in_obj->in_room->vnum);
free_string(clr1);
free_string(clr2);
} else {
clr1 = uncolor_str(obj->short_descr);
sprintf(buf, "%-3d %-7ld %-26.26s\n\r",
number,
obj->objprototype->vnum,
clr1);
free_string(clr1);
}
buf[0] = UPPER(buf[0]);
add_buf(buffer, buf);
if (number >= MAX_RETURN)
break;
}
}
if (number == 0)
send_to_char("Nothing like that in heaven or earth.\n\r", ch);
else
page_to_char(buf_string(buffer), ch);
}
free_buf(buffer);
}
void do_ban(CHAR_DATA *ch, char *argument)
{
char buf[MSL];
char arg1[MSL], arg2[MSL], arg3[MSL], arg4[MSL], date[MSL];
BUFFER *buffer;
int ban_type=0,host_type=0,res,duration=0;
CRow row;
argument = one_argument(argument,arg1);
argument = one_argument(argument,arg2);
argument = one_argument(argument,arg3);
argument = one_argument(argument,arg4);
if (arg1[0] != '\0' && !str_prefix(arg1,"show"))
{
res = RS.SQL.Select("bans.*,DATE_FORMAT(date,\'%%m/%%d/%%Y\') FROM bans ORDER BY duration DESC");
if(res)
{
buffer = new_buf();
sprintf(buf,"%-25s\t%-10s\t%-10s\t%-10s\t%-10s\t%-10s\n\r", "Site", "By", "Type", "Date", "Duration", "Reason");
add_buf(buffer,buf);
while(!RS.SQL.End())
{
row = RS.SQL.GetRow();
sprintf(buf,"%-25s\t%-10s\t%-10s\t%-10s\t%-10s\t%-10s\n\r",row[0],row[1],(atoi(row[5]) > 0) ? "Newbie" : "All",row[7],row[4],row[2]);
add_buf(buffer,buf);
}
page_to_char( buf_string(buffer), ch );
free_buf(buffer);
}
else
send_to_char("There are no current bans placed.\n\r", ch);
return;
}
if (arg1[0] == '\0' || arg2[0] == '\0' || arg3[0] == '\0' || arg4[0] == '\0')
{
do_ban(ch,"show");
send_to_char("Syntax: ban <site> <ip/host> <newbie/all> <duration> <reason> (-1 duration is permanent)\n\r"\
" unban <site>\n\r"\
" ban show\n\r",ch);
return;
}
if (!str_prefix(arg2,"ip"))
host_type = NBAN_IP;
else if (!str_prefix(arg2,"host"))
host_type = NBAN_HOST;
else
return do_ban(ch,"");
if (!str_prefix(arg3,"all"))
ban_type = NBAN_ALL;
else if (!str_prefix(arg3,"newbie"))
ban_type = NBAN_NEWBIE;
else
return do_ban(ch,"");
duration = atoi(arg4);
strftime(date, 200, "%Y-%m-%d", localtime(¤t_time));
res = RS.SQL.Insert("bans VALUES(\'%s\',\'%s\',\'%s\',\'%s\',%d,%d,%d)",
arg1,ch->true_name,argument,date,duration,ban_type,host_type);
if(res)
return send_to_char("Ban added.\n\r", ch);
else
return send_to_char("Ban failed, error..yell at Morglum.\n\r", ch);
}
/** ovnum <var> <value> */
void do_ovnum(struct char_data *ch, const char *argument)
{
const char *original_argument = argument;
static char arg[MAX_INPUT_LENGTH];
argument = prep_find_entity_vnum(ch, argument, arg, "ovnum", help_ovnum_properties, ovnum_find_empty);
if (argument != NULL) {
struct buf_type *buffer = new_buf();
OBJ_IDX_CMP_FN *cmp_fn = NULL;
long low_vnum, high_vnum;
char buf[MAX_INPUT_LENGTH];
long iter;
sprintf(buf, "`#QUERY``: ovnum %s\n\r\n\r", original_argument);
add_buf(buffer, buf);
for (iter = 0; objprototype_flags[iter].var[0] != '\0'; iter++) {
if (!str_prefix(arg, objprototype_flags[iter].var)) {
cmp_fn = (OBJ_IDX_CMP_FN *)objprototype_flags[iter].fn;
argument = one_argument(argument, arg);
break;
}
}
if (cmp_fn == NULL)
cmp_fn = objprototype_cmp_name;
argument = get_search_vnum_range(ch, argument, arg, buffer, &high_vnum, &low_vnum);
if (arg[0] == '?' || arg[0] == '\0') {
clear_buf(buffer);
sprintf(buf, "`#SYNTAX``:\n\r ovnum %s <value>:\n\r\n\r", arg);
add_buf(buffer, buf);
(*cmp_fn)(objectprototype_getbyvnum(OBJ_VNUM_MAP), arg, buffer);
page_to_char(buf_string(buffer), ch);
} else {
struct objectprototype *current;
struct objectprototype *pending;
char *clr1;
int number = 0;
long count = 0;
pending = objectprototype_iterator_start(&objectprototype_empty_filter);
while ((current = pending) != NULL) {
pending = objectprototype_iterator(current, &objectprototype_empty_filter);
count++;
if ((*cmp_fn)(current, arg, NULL)) {
number++;
if (number == 1) {
sprintf(buf, "# vnum name\n\r");
add_buf(buffer, buf);
sprintf(buf, "=== ====== =======================================\n\r");
add_buf(buffer, buf);
}
clr1 = uncolor_str(current->short_descr);
sprintf(buf, "%-3d %-7ld %-38.38s\n\r", number, current->vnum, clr1);
free_string(clr1);
add_buf(buffer, buf);
if (number >= MAX_RETURN)
break;
}
}
if (number == 0)
send_to_char("Nothing like that in heaven or earth.\n\r", ch);
else
page_to_char(buf_string(buffer), ch);
}
free_buf(buffer);
}
}
void parse_note ( Creature *ch, const char *argument, int type )
{
BUFFER *buffer;
char buf[MAX_STRING_LENGTH];
char arg[MAX_INPUT_LENGTH];
NOTE_DATA *pnote;
NOTE_DATA **list;
const char *list_name;
int vnum;
int anum;
if ( IS_NPC ( ch ) )
{ return; }
switch ( type ) {
default:
return;
case NOTE_NOTE:
list = ¬e_list;
list_name = "notes";
break;
case NOTE_IDEA:
list = &idea_list;
list_name = "ideas";
break;
case NOTE_PENALTY:
list = &penalty_list;
list_name = "penalties";
break;
case NOTE_NEWS:
list = &news_list;
list_name = "news";
break;
case NOTE_CHANGES:
list = &changes_list;
list_name = "changes";
break;
}
argument = ChopC ( argument, arg );
smash_tilde ( argument );
if ( arg[0] == '\0' || !str_prefix ( arg, "read" ) ) {
bool fAll;
if ( SameString ( argument, "all" ) ) {
fAll = TRUE;
anum = 0;
}
else if ( argument[0] == '\0' || !str_prefix ( argument, "next" ) )
/* read next unread note */
{
vnum = 0;
for ( pnote = *list; pnote != NULL; pnote = pnote->next ) {
if ( !hide_note ( ch, pnote ) ) {
sprintf ( buf, "[%3d] %s: %s\n\r%s\n\rTo: %s\n\r",
vnum,
pnote->sender,
pnote->subject,
pnote->date,
pnote->to_list );
writeBuffer ( buf, ch );
writePage ( pnote->text, ch );
update_read ( ch, pnote );
return;
} else if ( is_note_to ( ch, pnote ) )
{ vnum++; }
}
snprintf ( buf, sizeof ( buf ), "You have no unread %s.\n\r", list_name );
writeBuffer ( buf, ch );
return;
}
else if ( is_number ( argument ) ) {
fAll = FALSE;
anum = atoi ( argument );
} else {
writeBuffer ( "Read which number?\n\r", ch );
return;
}
vnum = 0;
for ( pnote = *list; pnote != NULL; pnote = pnote->next ) {
if ( is_note_to ( ch, pnote ) && ( vnum++ == anum || fAll ) ) {
sprintf ( buf, "[%3d] %s: %s\n\r%s\n\rTo: %s\n\r",
vnum - 1,
pnote->sender,
pnote->subject,
pnote->date,
pnote->to_list
);
writeBuffer ( buf, ch );
writePage ( pnote->text, ch );
update_read ( ch, pnote );
return;
}
}
snprintf ( buf, sizeof ( buf ), "There aren't that many %s.\n\r", list_name );
writeBuffer ( buf, ch );
return;
}
if ( !str_prefix ( arg, "list" ) ) {
vnum = 0;
for ( pnote = *list; pnote != NULL; pnote = pnote->next ) {
if ( is_note_to ( ch, pnote ) ) {
sprintf ( buf, "[%3d%s] %s: %s\n\r",
vnum, hide_note ( ch, pnote ) ? " " : "N",
pnote->sender, pnote->subject );
writeBuffer ( buf, ch );
vnum++;
}
}
if ( !vnum ) {
switch ( type ) {
case NOTE_NOTE:
writeBuffer ( "There are no notes for you.\n\r", ch );
break;
case NOTE_IDEA:
writeBuffer ( "There are no ideas for you.\n\r", ch );
break;
case NOTE_PENALTY:
writeBuffer ( "There are no penalties for you.\n\r", ch );
break;
case NOTE_NEWS:
writeBuffer ( "There is no news for you.\n\r", ch );
break;
case NOTE_CHANGES:
writeBuffer ( "There are no changes for you.\n\r", ch );
break;
}
}
return;
}
if ( !str_prefix ( arg, "remove" ) ) {
if ( !is_number ( argument ) ) {
writeBuffer ( "Note remove which number?\n\r", ch );
return;
}
anum = atoi ( argument );
vnum = 0;
for ( pnote = *list; pnote != NULL; pnote = pnote->next ) {
if ( is_note_to ( ch, pnote ) && vnum++ == anum ) {
note_remove ( ch, pnote, FALSE );
writeBuffer ( "Ok.\n\r", ch );
return;
}
}
snprintf ( buf, sizeof ( buf ), "There aren't that many %s.", list_name );
writeBuffer ( buf, ch );
return;
}
if ( !str_prefix ( arg, "delete" ) && get_trust ( ch ) >= MAX_LEVEL - 1 ) {
if ( !is_number ( argument ) ) {
writeBuffer ( "Note delete which number?\n\r", ch );
return;
}
anum = atoi ( argument );
vnum = 0;
for ( pnote = *list; pnote != NULL; pnote = pnote->next ) {
if ( is_note_to ( ch, pnote ) && vnum++ == anum ) {
note_remove ( ch, pnote, TRUE );
writeBuffer ( "Ok.\n\r", ch );
return;
}
}
snprintf ( buf, sizeof ( buf ), "There aren't that many %s.", list_name );
writeBuffer ( buf, ch );
return;
}
if ( !str_prefix ( arg, "catchup" ) ) {
switch ( type ) {
case NOTE_NOTE:
ch->pcdata->last_note = current_time;
break;
case NOTE_IDEA:
ch->pcdata->last_idea = current_time;
break;
case NOTE_PENALTY:
ch->pcdata->last_penalty = current_time;
break;
case NOTE_NEWS:
ch->pcdata->last_news = current_time;
break;
case NOTE_CHANGES:
ch->pcdata->last_changes = current_time;
break;
}
return;
}
/* below this point only certain people can edit notes */
if ( ( type == NOTE_NEWS && !IS_TRUSTED ( ch, ANGEL ) )
|| ( type == NOTE_CHANGES && !IS_TRUSTED ( ch, CREATOR ) ) ) {
snprintf ( buf, sizeof ( buf ), "You aren't high enough level to write %s.", list_name );
writeBuffer ( buf, ch );
return;
}
if ( SameString ( arg, "+" ) ) {
note_attach ( ch, type );
if ( ch->pnote->type != type ) {
writeBuffer (
"You already have a different note in progress.\n\r", ch );
return;
}
if ( strlen ( ch->pnote->text ) + strlen ( argument ) >= 4096 ) {
writeBuffer ( "Note too long.\n\r", ch );
return;
}
buffer = new_buf();
add_buf ( buffer, ch->pnote->text );
add_buf ( buffer, argument );
add_buf ( buffer, "\n\r" );
PURGE_DATA ( ch->pnote->text );
ch->pnote->text = assign_string ( buf_string ( buffer ) );
recycle_buf ( buffer );
writeBuffer ( "Ok.\n\r", ch );
return;
}
if ( SameString ( arg, "-" ) ) {
int len;
bool found = FALSE;
note_attach ( ch, type );
if ( ch->pnote->type != type ) {
writeBuffer (
"You already have a different note in progress.\n\r", ch );
return;
}
if ( ch->pnote->text == NULL || ch->pnote->text[0] == '\0' ) {
writeBuffer ( "No lines left to remove.\n\r", ch );
return;
}
strcpy ( buf, ch->pnote->text );
for ( len = strlen ( buf ); len > 0; len-- ) {
if ( buf[len] == '\r' ) {
if ( !found ) { /* back it up */
if ( len > 0 )
{ len--; }
found = TRUE;
} else { /* found the second one */
buf[len + 1] = '\0';
PURGE_DATA ( ch->pnote->text );
ch->pnote->text = assign_string ( buf );
return;
}
}
}
buf[0] = '\0';
PURGE_DATA ( ch->pnote->text );
ch->pnote->text = assign_string ( buf );
return;
}
if ( !str_prefix ( arg, "subject" ) ) {
note_attach ( ch, type );
if ( ch->pnote->type != type ) {
writeBuffer (
"You already have a different note in progress.\n\r", ch );
return;
}
PURGE_DATA ( ch->pnote->subject );
ch->pnote->subject = assign_string ( argument );
writeBuffer ( "Ok.\n\r", ch );
return;
}
if ( !str_prefix ( arg, "to" ) ) {
note_attach ( ch, type );
if ( ch->pnote->type != type ) {
writeBuffer (
"You already have a different note in progress.\n\r", ch );
return;
}
PURGE_DATA ( ch->pnote->to_list );
ch->pnote->to_list = assign_string ( argument );
writeBuffer ( "Ok.\n\r", ch );
return;
}
if ( !str_prefix ( arg, "clear" ) ) {
if ( ch->pnote != NULL ) {
recycle_note ( ch->pnote );
ch->pnote = NULL;
}
writeBuffer ( "Ok.\n\r", ch );
return;
}
if ( !str_prefix ( arg, "show" ) ) {
if ( ch->pnote == NULL ) {
writeBuffer ( "You have no note in progress.\n\r", ch );
return;
}
if ( ch->pnote->type != type ) {
writeBuffer ( "You aren't working on that kind of note.\n\r", ch );
return;
}
sprintf ( buf, "%s: %s\n\rTo: %s\n\r",
ch->pnote->sender,
ch->pnote->subject,
ch->pnote->to_list
);
writeBuffer ( buf, ch );
writeBuffer ( ch->pnote->text, ch );
return;
}
if ( !str_prefix ( arg, "post" ) || !str_prefix ( arg, "send" ) ) {
char *strtime;
if ( ch->pnote == NULL ) {
writeBuffer ( "You have no note in progress.\n\r", ch );
return;
}
if ( ch->pnote->type != type ) {
writeBuffer ( "You aren't working on that kind of note.\n\r", ch );
return;
}
if ( SameString ( ch->pnote->to_list, "" ) ) {
writeBuffer (
"You need to provide a recipient (name, all, or immortal).\n\r",
ch );
return;
}
if ( SameString ( ch->pnote->subject, "" ) ) {
writeBuffer ( "You need to provide a subject.\n\r", ch );
return;
}
ch->pnote->next = NULL;
strtime = ctime ( ¤t_time );
strtime[strlen ( strtime ) - 1] = '\0';
ch->pnote->date = assign_string ( strtime );
ch->pnote->date_stamp = current_time;
append_note ( ch->pnote );
ch->pnote = NULL;
return;
}
writeBuffer ( "You can't do that.\n\r", ch );
return;
}
void friend_list( CHAR_DATA *ch, char *argument )
{
FRIEND_LIST *wsk;
char buf[ MAX_STRING_LENGTH ];
BUFFER *output;
output = new_buf();
char *name;
char *opis;
time_t czas;
bool introduced;
if ( !ch || IS_NPC( ch ) ) return;
name = strdup( " " );
opis = strdup( "#!#" );
if ( !ch ) return;
if ( argument[0] != '\0' )
{
if ( friend_exist( ch, argument, name, opis, &czas, &introduced ) )
{
print_char( ch, "%s, to imiê brzmi jako¶ znajomo.\n\r", name );
if ( strcmp( opis, "#!#" ) )
{
print_char( ch, "Z tym imieniem kojarzy ci siê: %s.\n\r", opis );
}
//current_time - czas ) / 360 => czas znajomosci w godzinach
// TIME_TO_FORGET_FRIEND * 24 => czas do zapomnienia w godzinach bo TIME_TO... jest w dniach
if ( ( ( current_time - czas ) / 3600 ) > ( ( TIME_TO_FORGET_FRIEND * 24 ) * 2 ) / 3 )
{
print_char( ch, "Zaczynasz powoli zapominaæ t± osobê.\n\r");
}
} else {
print_char( ch, "Nie mo¿esz sobie przypomnieæ %s.\n\r", argument );
}
return;
}
send_to_char( "\n\r{gOsoby, które znasz\n\r--------------------------\n\r{x", ch );
for( wsk = ch->pcdata->friends; wsk; wsk = wsk->next )
{
//current_time - czas ) / 360 => czas znajomosci w godzinach
// TIME_TO_FORGET_FRIEND * 24 => czas do zapomnienia w godzinach bo TIME_TO... jest w dniach
if ( ( ( current_time - wsk->czas ) / 3600 ) > ( ( TIME_TO_FORGET_FRIEND * 24 ) * 2 ) / 3)
{
sprintf( buf, "{s*{x" );
add_buf( output, buf );
}
sprintf( buf, "{g%s{x", wsk->name );
add_buf( output, buf );
sprintf( buf, " %c ", wsk->introduced? 'v':'x' );
add_buf( output, buf );
sprintf( buf, "{G%s{x\n\r", wsk->opis );
add_buf( output, buf );
}
page_to_char( buf_string( output ), ch );
send_to_char( "{g--------------------------\n\r{x", ch );
free_buf( output );
return;
}
void ban_site(CHAR_DATA *ch, char *argument, bool fPerm)
{
char buf[MAX_STRING_LENGTH],buf2[MAX_STRING_LENGTH];
char arg1[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH];
char *name;
BUFFER *buffer;
BAN_DATA *pban, *prev;
bool prefix = FALSE,suffix = FALSE;
int type;
argument = one_argument(argument,arg1);
argument = one_argument(argument,arg2);
if ( arg1[0] == '\0' )
{
if (ban_list == NULL)
{
send_to_char("No sites banned at this time.\n\r",ch);
return;
}
buffer = new_buf();
add_buf(buffer,"Banned sites level type status\n\r");
for (pban = ban_list;pban != NULL;pban = pban->next)
{
sprintf(buf2,"%s%s%s",
IS_SET(pban->ban_flags,BAN_PREFIX) ? "*" : "",
pban->name,
IS_SET(pban->ban_flags,BAN_SUFFIX) ? "*" : "");
sprintf(buf,"%-12s %-3d %-7s %s\n\r",
buf2, pban->level,
IS_SET(pban->ban_flags,BAN_NEWBIES) ? "newbies" :
IS_SET(pban->ban_flags,BAN_MULTI) ? "multi" :
IS_SET(pban->ban_flags,BAN_PERMIT) ? "permit" :
IS_SET(pban->ban_flags,BAN_ALL) ? "all" : "",
IS_SET(pban->ban_flags,BAN_PERMANENT) ? "perm" : "temp");
add_buf(buffer,buf);
}
page_to_char( buf_string(buffer), ch );
free_buf(buffer);
return;
}
/* find out what type of ban */
if (arg2[0] == '\0' || !str_prefix(arg2,"all"))
type = BAN_ALL;
else if (!str_prefix(arg2,"newbies"))
type = BAN_NEWBIES;
else if (!str_prefix(arg2,"multi"))
type = BAN_MULTI;
else if (!str_prefix(arg2,"permit"))
type = BAN_PERMIT;
else
{
send_to_char("Acceptable ban types are all, newbies, and permit, and multi.\n\r",
ch);
return;
}
name = arg1;
if (name[0] == '*')
{
prefix = TRUE;
name++;
}
if (name[strlen(name) - 1] == '*')
{
suffix = TRUE;
name[strlen(name) - 1] = '\0';
}
if (strlen(name) == 0)
{
send_to_char("You have to ban SOMETHING.\n\r",ch);
return;
}
prev = NULL;
for ( pban = ban_list; pban != NULL; prev = pban, pban = pban->next )
{
if (!str_cmp(name,pban->name))
{
if (pban->level > get_trust(ch))
{
send_to_char( "That ban was set by a higher power.\n\r", ch );
return;
}
else
{
if (prev == NULL)
ban_list = pban->next;
else
prev->next = pban->next;
free_ban(pban);
}
}
}
pban = new_ban();
pban->name = str_dup(name);
pban->level = get_trust(ch);
/* set ban type */
pban->ban_flags = type;
if (prefix)
SET_BIT(pban->ban_flags,BAN_PREFIX);
if (suffix)
SET_BIT(pban->ban_flags,BAN_SUFFIX);
if (fPerm)
SET_BIT(pban->ban_flags,BAN_PERMANENT);
pban->next = ban_list;
ban_list = pban;
save_bans();
sprintf(buf,"%s has been banned.\n\r",pban->name);
send_to_char( buf, ch );
return;
}
void do_skills(CHAR_DATA *ch, char *argument)
{
BUFFER *buffer;
char arg[MAX_INPUT_LENGTH];
char skill_list[LEVEL_HERO + 1][MAX_STRING_LENGTH];
char skill_columns[LEVEL_HERO + 1];
int sn, level, min_lev = 1, max_lev = LEVEL_HERO,p,gn,style_skill;
bool fAll = FALSE, found = FALSE, hide_skill=FALSE;
char buf[MAX_STRING_LENGTH];
if (IS_NPC(ch))
return;
if (argument[0] != '\0')
{
fAll = TRUE;
argument = one_argument(argument,arg);
if (is_number(arg))
{
if (!is_number(arg))
{
send_to_char("Arguments must be numerical or name of skill.\n\r",ch);
return;
}
max_lev = atoi(arg);
if (max_lev < 1 || max_lev > LEVEL_HERO)
{
sprintf(buf,"Levels must be between 1 and %d.\n\r",LEVEL_HERO);
send_to_char(buf,ch);
return;
}
if (argument[0] != '\0')
{
argument = one_argument(argument,arg);
if (!is_number(arg))
{
send_to_char("Arguments must be numerical or name of skill.\n\r",ch);
return;
}
min_lev = max_lev;
max_lev = atoi(arg);
if (max_lev < 1 || max_lev > LEVEL_HERO)
{
sprintf(buf,
"Levels must be between 1 and %d.\n\r",LEVEL_HERO);
send_to_char(buf,ch);
return;
}
if (min_lev > max_lev)
{
send_to_char("That would be silly.\n\r",ch);
return;
}
}
} else {
if ((sn = skill_lookup(arg)) < 0)
return send_to_char("No such skill or spell.\n\r", ch);
if (ch->pcdata->learned[sn] == 0 ||
(ch->level < skill_table[sn].skill_level[ch->Class()->GetIndex()]) ||
((sn == gsn_gladiator_skill ||
sn == gsn_barbarian_skill ||
sn == gsn_duelist_skill ||
sn == gsn_skirmisher_skill ||
sn == gsn_dragoon_skill ||
sn == gsn_tactician_skill) && ch->level < AVATAR)) {
send_to_char("You are not learned in that.\n\r",ch);
}
else
{
sprintf(buf, "Your skill in '%s' is %d%%.\n\r",
skill_table[sn].name, ch->pcdata->learned[sn]);
send_to_char(buf, ch);
}
return;
}
}
/* initialize data */
for (level = 0; level < LEVEL_HERO + 1; level++)
{
skill_columns[level] = 0;
skill_list[level][0] = '\0';
}
for (sn = 0; sn < MAX_SKILL; sn++)
{
if (skill_table[sn].name == NULL )
break;
hide_skill=FALSE;
/*if ((level = skill_table[sn].skill_level[ch->Class()->GetIndex()]) < LEVEL_HERO + 1
&& (fAll || level <= ch->level)
&& level >= min_lev && level <= max_lev
&& skill_table[sn].spell_fun == spell_null
&& ch->pcdata->learned[sn] > 0)*/
if ((level = skill_table[sn].skill_level[ch->Class()->GetIndex()]) < LEVEL_HERO + 1
&& level >= min_lev && level <= max_lev
&& skill_table[sn].spell_fun == spell_null
&& ch->pcdata->learned[sn] > 0)
{
for(p=0; p<MAX_STYLE_SKILL; p++)
{
if(!str_prefix(style_percent[p].name, skill_table[sn].name))
{
gn = gn_skill_lookup(sn);
if(gn > 1)
{
style_skill = skill_lookup( group_table[gn].name );
if(ch->pcdata->learned[style_skill] < style_percent[p].percent)
hide_skill=TRUE;
if(hide_skill) break;
}
}
}
if ( sn == gsn_gladiator_skill || sn == gsn_duelist_skill ||
sn == gsn_barbarian_skill || sn == gsn_dragoon_skill ||
sn == gsn_skirmisher_skill || sn == gsn_tactician_skill)
hide_skill=TRUE;
found = TRUE;
level = skill_table[sn].skill_level[ch->Class()->GetIndex()];
if(!hide_skill)
{
if (ch->level < level)
sprintf(buf,"%-18s n/a ", skill_table[sn].name);
else
sprintf(buf,"%-18s %3d%% ",skill_table[sn].name,
ch->pcdata->learned[sn]);
if (skill_list[level][0] == '\0')
sprintf(skill_list[level],"\n\rLevel %2d: %s",level,buf);
else /* append */
{
if ( ++skill_columns[level] % 2 == 0)
strcat(skill_list[level],"\n\r ");
strcat(skill_list[level],buf);
}
}
}
}
/* return results */
if (!found)
{
send_to_char("No skills found.\n\r",ch);
return;
}
buffer = new_buf();
for (level = 0; level < LEVEL_HERO + 1; level++)
if (skill_list[level][0] != '\0')
add_buf(buffer,skill_list[level]);
add_buf(buffer,"\n\r");
page_to_char(buf_string(buffer),ch);
free_buf(buffer);
}
void ban_site( CHAR_DATA *ch, char *argument )
{
char date[ 50 ];
struct tm *btime;
char buf[ MAX_STRING_LENGTH ], buf2[ MAX_STRING_LENGTH ], buf3[ MAX_STRING_LENGTH ];
char arg1[ MAX_INPUT_LENGTH ], arg2[ MAX_INPUT_LENGTH ], arg3[ MAX_INPUT_LENGTH ];
char *name;
BUFFER *buffer;
BAN_DATA *pban, *prev;
bool prefix = FALSE, suffix = FALSE;
int type;
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
argument = one_argument( argument, arg3 );
if ( arg1[ 0 ] == '\0' )
{
if ( ban_list == NULL )
{
send_to_char( "Nie ma ¿adnych banów.\n\r", ch );
return ;
}
buffer = new_buf();
add_buf( buffer, "{CAdres Kto Typ{x\n\r" );
for ( pban = ban_list;pban != NULL;pban = pban->next )
{
sprintf( buf2, "%s%s%s",
IS_SET( pban->ban_flags, BAN_PREFIX ) ? "*" : "",
pban->site,
IS_SET( pban->ban_flags, BAN_SUFFIX ) ? "*" : "" );
btime = localtime( &pban->date_stamp );
strftime( date, 20, "%d-%m-%Y %H:%M:%S", btime );
if ( pban->period <= 0 )
sprintf( buf3, "od %s na sta³e", date );
else if ( pban->period == 1 )
sprintf( buf3, "od %s na 1 dzieñ", date );
else
sprintf( buf3, "od %s na %d dni", date, pban->period );
sprintf( buf, "{Y%-40s{x %-10s %-7s\n\r{CCzas{x: %s\n\r{CPowód{x: %s\n\r",
buf2, pban->person,
IS_SET( pban->ban_flags, BAN_NEWBIES ) ? "newbies" :
IS_SET( pban->ban_flags, BAN_PERMIT ) ? "permit" :
IS_SET( pban->ban_flags, BAN_ALL ) ? "all" : "",
buf3,
IS_NULLSTR(pban->reason) ? "nie podano" : pban->reason );
add_buf( buffer, buf );
if ( pban->next )
add_buf( buffer, "\n\r" );
}
add_buf( buffer, "\n\rDodanie nowego bana:\n\r" );
add_buf( buffer, "permban [*]<adres>[*] all|newbies|permit <ile dni> [<powod>]\n\r" );
add_buf( buffer, "- podanie 0 przy liczbie dni oznacza ban na sta³e\n\r" );
page_to_char( buf_string( buffer ), ch );
free_buf( buffer );
return ;
}
/* find out what type of ban */
if ( !str_prefix( arg2, "permit" ) )
type = BAN_PERMIT;
else if ( !str_prefix( arg2, "newbies" ) )
type = BAN_NEWBIES;
else if ( !str_prefix( arg2, "all" ) )
type = BAN_ALL;
else
{
send_to_char( "Dopuszczalne typy bana to: all, newbies, permit.\n\r", ch );
return ;
}
name = arg1;
if ( name[ 0 ] == '*' )
{
prefix = TRUE;
name++;
}
if ( name[ strlen( name ) - 1 ] == '*' )
{
suffix = TRUE;
name[ strlen( name ) - 1 ] = '\0';
}
if ( strlen( name ) == 0 )
{
send_to_char( "Nie poda³e¶ adresu do zbanowania.\n\r", ch );
return ;
}
if ( arg3[0] == '\0' || !is_number( arg3 ) )
{
send_to_char( "Podaj liczbê dni przez jak± ma trwaæ ban (0 - ca³y czas).\n\r", ch );
return;
}
prev = NULL;
for ( pban = ban_list; pban != NULL; prev = pban, pban = pban->next )
{
if ( !str_cmp( name, pban->site ) )
{
if ( prev == NULL )
ban_list = pban->next;
else
prev->next = pban->next;
free_ban( pban );
}
}
pban = new_ban();
pban->site = str_dup( name );
pban->person = str_dup( ch->name );
pban->date_stamp = current_time;
pban->period = UMAX( 0, atoi( arg3 ) );
pban->reason = str_dup( argument );
/* set ban type */
pban->ban_flags = type;
if ( prefix )
SET_BIT( pban->ban_flags, BAN_PREFIX );
if ( suffix )
SET_BIT( pban->ban_flags, BAN_SUFFIX );
pban->next = ban_list;
ban_list = pban;
save_bans();
sprintf( buf, "Adres %s zosta³ dodany do listy banów.\n\r", pban->site );
send_to_char( buf, ch );
return ;
}
struct dt_dentry * dtread_readfile(FILE *file, unsigned int *maxid, char *md5buf)
{
int c;
char ch;
struct buf_str *bs;
struct cuckoo_ctx *cu;
struct umd5_ctx md5;
struct dtread_data *dr;
struct dt_dentry *root = NULL;
LOG_ASSERT(file != NULL, "Bad arguments\n");
if ((bs = buf_alloc()) == NULL)
return NULL;
if ((cu = cuckoo_alloc(0)) == NULL)
goto clear_bs;
umd5_init(&md5);
while ((c = fgetc(file)) != EOF) {
if (c == '\n') {
if (buf_error(bs))
goto clear_cu;
umd5_update(&md5, buf_string(bs), buf_strlen(bs));
umd5_update(&md5, "\n", 1);
if (!dtread_readline(buf_string(bs), cu, maxid))
goto clear_cu;
buf_clear(bs);
} else {
ch = c;
buf_appendn(bs, &ch, 1);
}
}
if (cuckoo_items(cu) != 1) {
LOG_ERR("Some directories are left in cockoo tables\n");
goto clear_cu;
}
if ((dr = cuckoo_lookup(cu, 1)) == NULL) {
LOG_ERR("No root node in cuckoo table\n");
goto clear_cu;
}
root = dr->de;
cuckoo_delete(cu, 1);
free(dr);
umd5_finish(&md5);
umd5_value(&md5, md5buf);
clear_cu:
cuckoo_rfree(cu, dtread_data_free);
clear_bs:
buf_free(bs);
return root;
}
void do_skills(CHAR_DATA *ch, char *argument)
{
BUFFER *buffer;
char arg[MIL]={'\0'};
char skill_list[LEVEL_HERO + 1][MSL];
char skill_columns[LEVEL_HERO + 1];
int sn, level, min_lev = 1, max_lev = LEVEL_HERO;
bool fAll = FALSE, found = FALSE;
char buf[MSL]={'\0'};
if (IS_NPC(ch))
return;
if (argument[0] != '\0')
{
fAll = TRUE;
if (str_prefix(argument,"all"))
{
argument = one_argument(argument,arg);
if (!is_number(arg))
{
send_to_char("Arguments must be numerical or all.\n\r",ch);
return;
}
max_lev = atoi(arg);
if (max_lev < 1 || max_lev > LEVEL_HERO)
{
send_to_char( Format("Levels must be between 1 and %d.\n\r",LEVEL_HERO), ch);
return;
}
if (argument[0] != '\0')
{
argument = one_argument(argument,arg);
if (!is_number(arg))
{
send_to_char("Arguments must be numerical or all.\n\r",ch);
return;
}
min_lev = max_lev;
max_lev = atoi(arg);
if (max_lev < 1 || max_lev > LEVEL_HERO)
{
send_to_char( Format("Levels must be between 1 and %d.\n\r",LEVEL_HERO), ch);
return;
}
if (min_lev > max_lev)
{
send_to_char("That would be silly.\n\r",ch);
return;
}
}
}
}
/* initialize data */
for (level = 0; level < LEVEL_HERO + 1; level++)
{
skill_columns[level] = 0;
skill_list[level][0] = '\0';
}
for (sn = 0; sn < MAX_SKILL; sn++)
{
if (skill_table[sn].name == NULL )
break;
if ((level = skill_table[sn].skill_level[ch->iclass]) < LEVEL_HERO + 1
&& (fAll || level <= ch->level)
&& level >= min_lev && level <= max_lev
&& skill_table[sn].spell_fun == spell_null
&& ch->pcdata->learned[sn] > 0)
{
found = TRUE;
level = skill_table[sn].skill_level[ch->iclass];
if (ch->level < level)
sprintf(buf,"%-18s n/a ", skill_table[sn].name);
else
sprintf(buf,"%-18s %3d%% ",skill_table[sn].name,
ch->pcdata->learned[sn]);
if (skill_list[level][0] == '\0')
sprintf(skill_list[level],"\n\rLevel %2d: %s",level,buf);
else /* append */
{
if ( ++skill_columns[level] % 2 == 0)
strcat(skill_list[level],"\n\r ");
strcat(skill_list[level],buf);
}
}
}
/* return results */
if (!found)
{
send_to_char("No skills found.\n\r",ch);
return;
}
buffer = new_buf();
for (level = 0; level < LEVEL_HERO + 1; level++)
if (skill_list[level][0] != '\0')
add_buf(buffer,skill_list[level]);
add_buf(buffer,"\n\r");
page_to_char(buf_string(buffer),ch);
free_buf(buffer);
}
void do_wizlist(CHAR_DATA *ch, char *argument)
{
char arg1[MAX_INPUT_LENGTH];
char arg2[MAX_INPUT_LENGTH];
char arg3[MAX_INPUT_LENGTH];
char buf[MAX_STRING_LENGTH];
char title[MAX_STRING_LENGTH];
BUFFER *buffer;
int level;
WIZ_DATA *pwiz;
int lngth;
int amt;
bool found;
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
argument = one_argument( argument, arg3 );
/*
* Uncomment the following to use the old method of having
* a fixed wizlist in the rot.are file.
*/
/*
do_help(ch,"wizlist");
return;
*/
if ((arg1[0] != '\0') && (ch->level == MAX_LEVEL))
{
if ( !str_prefix( arg1, "add" ) )
{
if ( !is_number( arg2 ) || ( arg3[0] == '\0' ) )
{
send_to_char( "Syntax: wizlist add <level> <name>\n\r", ch );
return;
}
level = atoi(arg2);
change_wizlist( ch, TRUE, level, arg3 );
return;
}
if ( !str_prefix( arg1, "delete" ) )
{
if ( arg2[0] == '\0' )
{
send_to_char( "Syntax: wizlist delete <name>\n\r", ch );
return;
}
change_wizlist( ch, FALSE, 0, arg2 );
return;
}
send_to_char( "Syntax:\n\r", ch );
send_to_char( " wizlist delete <name>\n\r", ch );
send_to_char( " wizlist add <level> <name>\n\r", ch );
return;
}
if (wiz_list == NULL)
{
send_to_char("No immortals listed at this time.\n\r",ch);
return;
}
buffer = new_buf();
xprintf(title," #WThe Gods of Mindcloud#0");
xprintf(buf,"#0 ___________________________________________________________________________\n\r");
add_buf(buffer,buf);
xprintf(buf," /\\_\\%70s\\_\\\n\r", " ");
add_buf(buffer,buf);
lngth = (70 - strlen(title))/2;
for( ; lngth >= 0; lngth--)
{
strcat(title, " ");
}
xprintf(buf,"|/\\\\_\\ %70s \\_\\\n\r", title);
add_buf(buffer,buf);
xprintf(buf,"#0\\_/_|_|%69s#0|_|#0\n\r", " ");
add_buf(buffer,buf);
for (level = 12; level > 5; level--)
{
found = FALSE;
amt = 0;
for (pwiz = wiz_list;pwiz != NULL;pwiz = pwiz->next)
{
if (pwiz->level == level)
{
amt++;
found = TRUE;
}
}
if (!found)
{
if (level == 6)
{
xprintf(buf,"#0 ___|_|%69s|_|\n\r", " ");
add_buf(buffer,buf);
}
continue;
}
xprintf(buf,"#0 |_|#R%40s #w%28s#0|_|#0\n\r",
wiz_titles[12-level], " ");
add_buf(buffer,buf);
xprintf(buf,"#0 |_|#W%25s******************#w%26s#0|_|#0\n\r",
" ", " ");
add_buf(buffer,buf);
lngth = 0;
for (pwiz = wiz_list;pwiz != NULL;pwiz = pwiz->next)
{
if (pwiz->level == level)
{
if (lngth == 0)
{
if (amt > 2)
{
xprintf(buf, "#0 |_|#B%12s%-17s #B",
" ", pwiz->name);
add_buf(buffer, buf);
lngth = 1;
} else if (amt > 1)
{
xprintf(buf, "#0 |_|#B%21s%-17s #B",
" ", pwiz->name);
add_buf(buffer, buf);
lngth = 1;
} else
{
xprintf(buf, "#0 |_|#B%30s%-39s#0|_|\n\r",
" ", pwiz->name);
add_buf(buffer, buf);
lngth = 0;
}
} else if (lngth == 1)
{
if (amt > 2)
{
xprintf(buf, "%-17s ",
pwiz->name);
add_buf(buffer, buf);
lngth = 2;
} else
{
xprintf(buf, "%-30s#0|_|\n\r",
pwiz->name);
add_buf(buffer, buf);
lngth = 0;
}
} else
{
xprintf(buf, "%-21s#0|_|\n\r",
pwiz->name);
add_buf(buffer, buf);
lngth = 0;
amt -= 3;
}
}
}
if (level == 6)
{
xprintf(buf,"#0 ___|_|%69s#0|_|\n\r", " ");
} else
{
xprintf(buf,"#0 |_|%69s#0|_|\n\r", " ");
}
add_buf(buffer,buf);
}
xprintf(buf,"#0/ \\ |_|%69s#0|_|\n\r", " ");
add_buf(buffer,buf);
xprintf(buf,"#0|\\//_/%70s#0/_/\n\r", " ");
add_buf(buffer,buf);
xprintf(buf,"#0 \\/_/______________________________________________________________________/_/#n\n\r");
add_buf(buffer,buf);
send_to_char( buf_string(buffer), ch );
free_buf(buffer);
return;
}
void do_omni( CHAR_DATA *ch, char *argument )
{
char buf[MAX_STRING_LENGTH];
char buf2[MAX_STRING_LENGTH];
BUFFER *output;
DESCRIPTOR_DATA *d;
int immmatch;
int mortmatch;
int hptemp;
/*
* Initalize Variables.
*/
immmatch = 0;
mortmatch = 0;
buf[0] = '\0';
output = new_buf();
/*
* Count and output */
sprintf(buf,"\n\r{B---{WI{wm{Wm{wo{Wr{wt{Wa{wl{Ws{B----{x\n\r");
add_buf(output,buf);
sprintf( buf, "{WN{wa{Wm{we {WL{we{Wv{we{Wl {WW{wi{Wz {WI{wn{Wc{wo{Wg {WG{wh{Wo{ws{Wt {W[{wV{Wn{wu{Wm{W]{x\n\r");
add_buf(output,buf);
for ( d = descriptor_list; d != NULL; d = d->next )
{
CHAR_DATA *wch;
if ( d->connected != CON_PLAYING || !can_see( ch, d->character ) )
continue;
wch = ( d->original != NULL ) ? d->original : d->character;
if (!can_see(ch,wch) || wch->level < 102)
continue;
immmatch++;
sprintf( buf, "{R%-14s %-3d %-3d %-3d %-3d [%-3d]{x\n\r",
wch->name,
wch->level,
wch->invis_level,
wch->incog_level,
wch->ghost_level,
wch->in_room->vnum);
add_buf(output,buf);
}
/*
* Count and output the Morts.
*/
sprintf( buf, " \n\r {B----{YM{yo{Yr{yt{Ya{yl{Ys{B----{x\n\r");
add_buf(output,buf);
sprintf( buf, "{WN{wa{Wm{we {WG{wo{Wd {WR{wa{Wc{we{W/{wC{Wl{wa{Ws{ws {WP{wo{Ws{wi{Wt{wi{Wo{wn {WL{we{Wv {w%%{Wh{wp{Ws {w[{WV{wn{Wu{wm{W]{x\n\r");
add_buf(output,buf);
hptemp = 0;
for ( d = descriptor_list; d != NULL; d = d->next )
{
CHAR_DATA *wch;
char const *class;
if ( d->connected != CON_PLAYING || !can_see( ch, d->character ) )
continue;
wch = ( d->original != NULL ) ? d->original : d->character;
if (!can_see(ch,wch) || wch->level > ch->level || wch->level > 101)
continue;
mortmatch++;
if ((wch->max_hit != wch->hit) && (wch->hit > 0))
hptemp = (wch->hit*100)/wch->max_hit;
else if (wch->max_hit == wch->hit)
hptemp = 100;
else if (wch->hit < 0)
hptemp = 0;
class = class_table[wch->class].who_name;
sprintf( buf, "{G%-14s %-7s %6.6s/%3.3s %-10s %-3d %-3d%% [%-3d]{x\n\r",
wch->name,
IS_GOOD(wch)? "Good" : IS_EVIL(wch) ? "Evil" : "Neutral",
wch->race < MAX_PC_RACE ? pc_race_table[wch->race].who_name : " ",
class,
capitalize( position_table[wch->position].name) ,
wch->level,
hptemp,
wch->in_room->vnum);
add_buf(output,buf);
}
/*
* Tally the counts and send the whole list out.
*/
sprintf( buf2, "\n\r{CIMMs found: {w%d{x\n\r", immmatch );
add_buf(output,buf2);
sprintf( buf2, "{CMorts found: {y%d{x\n\r", mortmatch );
add_buf(output,buf2);
page_to_char( buf_string(output), ch );
free_buf(output);
return;
}
/** mvnum <var> <value> */
void do_mvnum(struct char_data *ch, const char *argument)
{
static char arg[MAX_INPUT_LENGTH];
const char *original_argument = argument;
argument = prep_find_entity_vnum(ch, argument, arg, "mvnum", &help_mvnum_properties, &mvnum_find_empty);
if (argument != NULL) {
{
struct buf_type *buffer;
MOB_IDX_CMP_FN *cmp_fn = NULL;
char buf[MAX_INPUT_LENGTH];
long low_vnum, high_vnum;
long iter;
buffer = new_buf();
sprintf(buf, "`#QUERY``: mvnum %s\n\r\n\r", original_argument);
add_buf(buffer, buf);
for (iter = 0; mob_idx_flags[iter].var[0] != '\0'; iter++) {
if (!str_prefix(arg, mob_idx_flags[iter].var)) {
cmp_fn = (MOB_IDX_CMP_FN *)mob_idx_flags[iter].fn;
argument = one_argument(argument, arg);
break;
}
}
if (cmp_fn == NULL)
cmp_fn = mob_idx_cmp_name;
argument = get_search_vnum_range(ch, argument, arg, buffer, &high_vnum, &low_vnum);
if (arg[0] == '?' || arg[0] == '\0') {
clear_buf(buffer);
sprintf(buf, "`#SYNTAX``:\n\r mvnum %s <value>:\n\r\n\r", arg);
add_buf(buffer, buf);
(*cmp_fn)(get_mob_index(MOB_VNUM_PIG), argument, buffer);
page_to_char(buf_string(buffer), ch);
} else {
struct mob_index_data *mob;
char *clr1;
int number = 0;
long count = 0;
for (iter = low_vnum; iter <= high_vnum && count < top_mob_index; iter++) {
if ((mob = get_mob_index(iter)) != NULL) {
count++;
if ((*cmp_fn)(mob, arg, NULL)) {
number++;
if (number == 1) {
add_buf(buffer, "# vnum name\n\r");
add_buf(buffer, "=== ====== =======================================\n\r");
}
clr1 = uncolor_str(mob->short_descr);
sprintf(buf, "%-3d %-7ld %-38.38s\n\r",
number,
mob->vnum,
clr1);
free_string(clr1);
add_buf(buffer, buf);
if (number >= MAX_RETURN)
break;
}
}
}
if (number == 0)
send_to_char("Nothing like that in heaven or earth.\n\r", ch);
else
page_to_char(buf_string(buffer), ch);
}
free_buf(buffer);
}
}
}
