Exemplo n.º 1
0
void do_note( CHAR_DATA *ch, char *argument )
{
    char buf[MAX_STRING_LENGTH];
    char arg[MAX_INPUT_LENGTH];
    NOTE_DATA *pnote;
    int vnum;
    int anum;

    if ( IS_NPC(ch) )
	return;

    argument = one_argument( argument, arg );
    smash_tilde( argument );

    if ( !str_cmp( arg, "list" ) )
    {
	vnum = 0;
	for ( pnote = note_list; pnote != NULL; pnote = pnote->next )
	{
	    if ( is_note_to( ch, pnote ) )
	    {
		sprintf( buf, "[%3d] %s: %s\n\r",
		    vnum, pnote->sender, pnote->subject );
		send_to_char( buf, ch );
		vnum++;
	    }
	}
	return;
    }

    if ( !str_cmp( arg, "read" ) )
    {
	bool fAll;

	if ( !str_cmp( argument, "all" ) )
	{
	    fAll = TRUE;
	    anum = 0;
	}
	else if ( is_number( argument ) )
	{
	    fAll = FALSE;
	    anum = atoi( argument );
	}
	else
	{
	    send_to_char( "Note read which number?\n\r", ch );
	    return;
	}

	vnum = 0;
	for ( pnote = note_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
		    );
		send_to_char( buf, ch );
		send_to_char( pnote->text, ch );
		return;
	    }
	}

	send_to_char( "No such note.\n\r", ch );
	return;
    }

    if ( !str_cmp( arg, "+" ) )
    {
	note_attach( ch );
	strcpy( buf, ch->pnote->text );
	if ( strlen(buf) + strlen(argument) >= MAX_STRING_LENGTH - 4 )
	{
	    send_to_char( "Note too long.\n\r", ch );
	    return;
	}

	strcat( buf, argument );
	strcat( buf, "\n\r" );
	free_string( ch->pnote->text );
	ch->pnote->text = str_dup( buf );
	send_to_char( "Ok.\n\r", ch );
	return;
    }

    if ( !str_cmp( arg, "subject" ) )
    {
	note_attach( ch );
	free_string( ch->pnote->subject );
	ch->pnote->subject = str_dup( argument );
	send_to_char( "Ok.\n\r", ch );
	return;
    }

    if ( !str_cmp( arg, "to" ) )
    {
	note_attach( ch );
	free_string( ch->pnote->to_list );
	ch->pnote->to_list = str_dup( argument );
	send_to_char( "Ok.\n\r", ch );
	return;
    }

    if ( !str_cmp( arg, "clear" ) )
    {
	if ( ch->pnote != NULL )
	{
	    free_string( ch->pnote->text );
	    free_string( ch->pnote->subject );
	    free_string( ch->pnote->to_list );
	    free_string( ch->pnote->date );
	    free_string( ch->pnote->sender );
	    ch->pnote->next	= note_free;
	    note_free		= ch->pnote;
	    ch->pnote		= NULL;
	}

	send_to_char( "Ok.\n\r", ch );
	return;
    }

    if ( !str_cmp( arg, "show" ) )
    {
	if ( ch->pnote == NULL )
	{
	    send_to_char( "You have no note in progress.\n\r", ch );
	    return;
	}

	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_cmp( arg, "post" ) )
    {
	FILE *fp;
	char *strtime;

	if ( ch->pnote == NULL )
	{
	    send_to_char( "You have no note in progress.\n\r", ch );
	    return;
	}

	ch->pnote->next			= NULL;
	strtime				= ctime( &current_time );
	strtime[strlen(strtime)-1]	= '\0';
	ch->pnote->date			= str_dup( strtime );

	if ( note_list == NULL )
	{
	    note_list	= ch->pnote;
	}
	else
	{
	    for ( pnote = note_list; pnote->next != NULL; pnote = pnote->next )
		;
	    pnote->next	= ch->pnote;
	}
	pnote		= ch->pnote;
	ch->pnote	= NULL;

	fclose( fpReserve );
	if ( ( fp = fopen( NOTE_FILE, "a" ) ) == NULL )
	{
	    perror( NOTE_FILE );
	}
	else
	{
	    fprintf( fp, "Sender  %s~\nDate    %s~\nTo      %s~\nSubject %s~\nText\n%s~\n\n",
		pnote->sender,
		pnote->date,
		pnote->to_list,
		pnote->subject,
		pnote->text
		);
	    fclose( fp );
	}
	fpReserve = fopen( NULL_FILE, "r" );

	send_to_char( "Ok.\n\r", ch );
	return;
    }

    if ( !str_cmp( arg, "remove" ) )
    {
	if ( !is_number( argument ) )
	{
	    send_to_char( "Note remove which number?\n\r", ch );
	    return;
	}

	anum = atoi( argument );
	vnum = 0;
	for ( pnote = note_list; pnote != NULL; pnote = pnote->next )
	{
	    if ( is_note_to( ch, pnote ) && vnum++ == anum )
	    {
		note_remove( ch, pnote );
		send_to_char( "Ok.\n\r", ch );
		return;
	    }
	}

	send_to_char( "No such note.\n\r", ch );
	return;
    }

    send_to_char( "Huh?  Type 'help note' for usage.\n\r", ch );
    return;
}
Exemplo n.º 2
0
void do_mptransfer( CHAR_DATA *ch, char *argument )
{
    char             arg1[ MAX_INPUT_LENGTH ];
    char             arg2[ MAX_INPUT_LENGTH ];
    int			room = 0;
    ROOM_INDEX_DATA *location;
    DESCRIPTOR_DATA *d;
    CHAR_DATA       *victim;

    if ( !IS_NPC( ch ) )
    {
	typo_message( ch );
	return;
    }

    if ( IS_SET( ch->act , ACT_PET ) || IS_AFFECTED( ch, AFF_CHARM ) )
      return;

    argument = one_argument( argument, arg1 );
    argument = one_argument( argument, arg2 );

    if ( arg1[0] == '\0' )
    {
        sprintf( log_buf, "Mptransfer - Bad syntax: vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
	return;
    }

    if ( !str_cmp( arg1, "all" ) )
    {
	for ( d = descriptor_list; d != NULL; d = d->next )
	{
	    if ( d->connected == CON_PLAYING
	    &&   d->character != ch
	    &&   d->character->in_room != NULL
	    &&   can_see( ch, d->character ) )
	    {
		char buf[MAX_STRING_LENGTH];
		sprintf( buf, "%s %s", d->character->name, arg2 );
		do_transfer( ch, buf );
	    }
	}
	return;
    }

    if ( !str_cmp( arg1, "room" ) )
    {
        for ( d = descriptor_list; d != NULL; d = d->next )
        {
            if ( d->connected == CON_PLAYING
            &&   d->character != ch
            &&   d->character->in_room != NULL
            &&   can_see( ch, d->character ) 
	    &&   d->character->in_room == ch->in_room )
            {
                char buf[MAX_STRING_LENGTH];
                sprintf( buf, "%s %s", d->character->name, arg2 );
                do_transfer( ch, buf );
            }
        }
        return;
    }
 
    /*
     * Thanks to Grodyn for the optional location parameter.
     */
    if ( arg2[0] == '\0' )
    {
	location = ch->in_room;
    }
    else
    {

     while ( is_number( arg2 ) )
     {
      if ( atoi( arg2 ) < -1 )
       return;

      if ( atoi( arg2 ) == -1 )
      {
       room = randroom();
       break;
      }

      if ( get_room_index( atoi( arg2 ) ) == NULL )
       return;

      break;
     }
     

     if ( room == 0 )
     {
	if ( ( location = find_location( ch, arg2 ) ) == NULL )
	{
            sprintf( log_buf, "Mptransfer - No such location: vnum %d name %s short %s.",
                     ch->pIndexData->vnum, ch->name, ch->short_descr );
            bug( log_buf, -1 );
	    return;
	}
     }
     else
      location = get_room_index( room );

	if ( room_is_private( location ) )
	{
            sprintf( log_buf, "Mptransfer - Private room: vnum %d name %s short %s.",
                     ch->pIndexData->vnum, ch->name, ch->short_descr );
            bug( log_buf, -1 );
	    return;
	}
    }

    if ( ( victim = get_char_world( ch, arg1 ) ) == NULL )
    {
        sprintf( log_buf, "Mptransfer - No such person: vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
	return;
    }

    if ( victim->in_room == NULL )
    {
        sprintf( log_buf, "Mptransfer - Victim in Limbo: vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
	return;
    }

    if ( victim->in_room == location )
      return;

    if ( victim->fighting != NULL )
	stop_fighting( victim, TRUE );

    char_from_room( victim );
    char_to_room( victim, location );

    return;
}
Exemplo n.º 3
0
Arquivo: marry.c Projeto: Firehed/RotK
void do_divorce( CHAR_DATA *ch, char *argument)
{

    char arg1[MAX_INPUT_LENGTH],arg2[MAX_INPUT_LENGTH];
    CHAR_DATA *husband;
    CHAR_DATA *wife;
    char buf[MAX_STRING_LENGTH];
    
    argument = one_argument( argument, arg1 );
    argument = one_argument( argument, arg2 );

   if (ch->level >= LEVEL_IMMORTAL)
   { 
    if ( arg1[0] == '\0' || arg2[0] == '\0' )
    {
        send_to_char( "Syntax: divorce <char1> <char2>\n\r",ch);
        return;
    }
    if ( ( husband = get_char_world( ch, arg1 ) ) == NULL )
    {
        send_to_char( "The first person mentioned isn't playing.\n\r", ch );
        return;
    }
    
    if ( ( wife = get_char_world( ch, arg2 ) ) == NULL )
    {
	send_to_char( "The second person mentioned isn't playing.\n\r", ch);
	return;
    }
    
    if ( IS_NPC(husband) || IS_NPC(wife))
    {
     send_to_char("I don't think they're Married to the Mob...\n\r", ch);
     return;
    }
            
    if (!IS_SET(husband->act, PLR_CONSENT) || !IS_SET(wife->act, PLR_CONSENT))
    {
     send_to_char( "They do not give consent.\n\r", ch);
     return;
    }
    
        sprintf(buf, "%s", wife->name);
    if (husband->spouse != buf)
    {
     send_to_char( "They aren't even married!!\n\r",ch);
     return;
    }
       
    send_to_char( "You hand them their papers.\n\r", ch);
    send_to_char( "Your divorce is final.\n\r", husband);
    send_to_char( "Your divorce is final.\n\r", wife);
    husband->spouse = NULL;
    wife->spouse = NULL;
    return;

   } 
   else
   {
    send_to_char( "You do not have divorcing power.\n\r", ch);
    return;
   }
}
Exemplo n.º 4
0
/*
 * Allows rooms, objs and mobs to apply tattoos
 * This code is hairy because it uses a mob's tattoo
 * settings, so there must be a mob that isn't loaded.
 * Also, it derives its description from the text
 * entered after the mobs vnum, so make sure this prog
 * is perfect syntax. -Flux
 */
void do_mptattoo( CHAR_DATA *ch, char *argument )
{
    TATTOO_ARTIST_DATA	*pTattoo;
    TATTOO_DATA		*tattoo;
    MOB_INDEX_DATA	*artist;
    CHAR_DATA		*victim;
    char        	arg1[ MAX_INPUT_LENGTH ];
    char		arg2[ MAX_INPUT_LENGTH ];
    int         	mobvnum;

    if ( !IS_NPC( ch ) )
    {
     typo_message( ch );
     return;
    }

    if ( IS_SET( ch->act , ACT_PET ) || IS_AFFECTED( ch, AFF_CHARM ) )
      return;

    argument = one_argument( argument, arg1 );
    argument = one_argument( argument, arg2 );

    if ( arg1[0] == '\0' )
    {
        sprintf( log_buf, "MpTattoo - no argument1: vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
     return;
    }

    if ( ( victim = get_char_room( ch, arg1 ) ) == NULL )
    {
        sprintf( log_buf, "MpTattoo - Victim not in room: vnum %d name %s short %s .",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
	return;
    }

    if ( victim == ch )
    {
        sprintf( log_buf, "MpTattoo - Bad victim to attack: vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
	return;
    }

    if ( IS_NPC(victim) )
     return;

    if ( arg2[0] == '\0' )
    {
        sprintf( log_buf, "MpTattoo - no argument2: vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
     return;
    }

    if ( !is_number(arg2) )
    {
     sprintf( log_buf, "MpTattoo - arg2 not a number: vnum %d name %s short %s.",
      ch->pIndexData->vnum, ch->name, ch->short_descr );
     bug( log_buf, -1 );
     return;
    }

    mobvnum = atoi(arg2);

    if ( !(artist = get_mob_index(mobvnum )) )
    {
     sprintf( log_buf, "MpTattoo - arg2 mob doesn't exist: vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
     return;
    }

    if ( !(pTattoo = artist->pTattoo) )
    {
     sprintf( log_buf, "MpTattoo - arg2 mob isn't an artist: vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
     return;
    }

    if ( get_tattoo_char( victim, pTattoo->wear_loc ) != NULL )
     return;

    if ( argument[0] == '\0' )
    {
        sprintf( log_buf, "MpTattoo - no argument3: vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
     return;
    }

    if ( longstring( ch, argument ) )
    {
     sprintf( log_buf, "MpTattoo - arg3 is too long: vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
     return;
    }

    tattoo = new_tattoo();
    tattoo->wear_loc = pTattoo->wear_loc;    
    tattoo->magic_boost = pTattoo->magic_boost;

    free_string( tattoo->short_descr );
    tattoo->short_descr = str_dup( argument );

    tattoo->affected = pTattoo->affected;

    tattoo_to_char( tattoo, victim, FALSE );
 return;
}
Exemplo n.º 5
0
/* lets the mobile purge all objects and other npcs in the room,
   or purge a specified object or mob in the room.  It can purge
   itself, but this had best be the last command in the MOBprogram
   otherwise ugly stuff will happen */
void do_mppurge( CHAR_DATA *ch, char *argument )
{
    char       arg[ MAX_INPUT_LENGTH ];
    CHAR_DATA *victim;
    OBJ_DATA  *obj;

    if ( !IS_NPC( ch ) )
    {
	typo_message( ch );
	return;
    }

    if ( IS_SET( ch->act , ACT_PET ) || IS_AFFECTED( ch, AFF_CHARM ) )
      return;

    one_argument( argument, arg );

    if ( arg[0] == '\0' )
    {
        /* 'purge' */
/*        CHAR_DATA *vnext;
        OBJ_DATA  *obj_next;

	for ( victim = ch->in_room->people; victim != NULL; victim = vnext )
	{
	  vnext = victim->next_in_room;
	  if ( IS_NPC( victim ) && victim != ch )
	    extract_char( victim, TRUE );
	}

	for ( obj = ch->in_room->contents; obj != NULL; obj = obj_next )
	{
	  obj_next = obj->next_content;
	  extract_obj( obj );
	}*/

	return;
    }

    if ( ( obj = get_obj_here( ch, arg ) ) == NULL  )
    {
	if ( ( victim = get_char_room( ch, arg ) ) )
	{
       if ( !IS_NPC( victim ) )
       {
        sprintf( log_buf, "Mppurge - Purging a PC: vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
        return;
       }
	 extract_char( victim, TRUE );
	}
	else
	{
            sprintf( log_buf, "Mppurge - Bad argument: vnum %d name %s short %s.",
                     ch->pIndexData->vnum, ch->name, ch->short_descr );
            bug( log_buf, -1 );
	}
	return;
    }

  extract_obj( obj );
  return;
}
Exemplo n.º 6
0
void do_recite( char_data* ch, char* argument )
{
  char            arg  [ MAX_STRING_LENGTH ];
  cast_data*     cast;
  obj_data*    scroll;
  int           level;
  int        duration;
  int           spell;

  if( not_player( ch ) )
    return;

  if( is_set( &ch->status, STAT_BERSERK ) ) {
    send( ch, "Your mind is on killing, not reading scrolls.\n\r" );
    return;
    }

  argument = one_argument( argument, arg );

  if( ( scroll = one_object( ch, arg, "recite", &ch->contents ) ) == NULL )
    return;

  if( scroll->pIndexData->item_type != ITEM_SCROLL ) {
    send( ch, "%s isn't a scroll.\n\r", scroll );
    return;
    }

  if( !is_set( ch->pcdata->pfile->flags, PLR_HOLYLIGHT )
    && ( is_set( ch->affected_by, AFF_BLIND )
    || ch->in_room->is_dark( ) ) ) {
    send( ch, "It is too dark for you read any writing.\n\r" );
    return;
    }

  if( ( spell = scroll->pIndexData->value[0] ) < 0
    || spell >= MAX_SPELL ) {
    send( ch, "That scroll contains a non-existent spell.\n\r" );
    bug( "Recite: Scroll spell out of range." );
    bug( "-- Scroll = %s", scroll->Seen_Name( NULL ) );
    return;
    }

  cast        = new cast_data;
  cast->spell = spell;

  if( !get_target( ch, cast, argument ) ) {
    delete cast;
    return;
    }

  thing_data*  target  = cast->target;
  char_data*   victim  = character( target );

  delete cast;

  if( spell_table[ spell ].type == STYPE_OFFENSIVE ) {
    check_killer( ch, victim );
    ch->fighting = victim;
    react_attack( ch, victim );
    }

  if( spell == SPELL_RECALL-SPELL_FIRST 
    && is_set( &ch->in_room->room_flags, RFLAG_NO_RECALL ) ) {
    send( ch, "You attempt to pronounce the words on the scroll but\
 absolutely nothing\n\rhappens.\n\r" );
    return;
    }
Exemplo n.º 7
0
/* Allows supermob to do damage without killing it -Flux */
void do_mpdamage( CHAR_DATA *ch, char *argument )
{
    char	arg[ MAX_INPUT_LENGTH ];
    char	arg2[ MAX_INPUT_LENGTH ];
    char	arg3[ MAX_INPUT_LENGTH ];
    CHAR_DATA	*victim;
    int		dam = 0;
    int		damtype = 0;
    int		dammes = TYPE_HIT;

    if ( !IS_NPC( ch ) )
    {
	typo_message( ch );
	return;
    }

    if ( IS_SET( ch->act , ACT_PET ) || IS_AFFECTED( ch, AFF_CHARM ) )
      return;

    argument = one_argument( argument, arg );
    argument = one_argument( argument, arg2 );
    argument = one_argument( argument, arg3 );

    if ( arg[0] == '\0' || arg2[0] == '\0' ||
         arg3[0] == '\0' )
    {
        sprintf( log_buf, "MpDamage - no argument: vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
    }

    if ( ( victim = get_char_room( ch, arg ) ) == NULL )
    {
        sprintf( log_buf, "MpDamage - Victim not in room: vnum %d name %s short %s .",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
	return;
    }

    if ( victim == ch )
    {
        sprintf( log_buf, "MpDamage - Bad victim to attack: vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
	return;
    }

    if ( IS_AFFECTED( ch, AFF_CHARM ) && ch->master == victim )
    {
        sprintf( log_buf, "MpDamage - Charmed mob attacking master: vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
	return;
    }

    if ( !is_number( arg2 ) )
    {
        sprintf( log_buf, "MpDamage - Arg2 not a # vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
	return;
    }
    
    dam = atoi( arg2 );

    damtype = ( flag_value( damage_flags, arg3 ) );

    if ( damtype <= DAM_NONE || damtype > DAM_INTERNAL )
    {
        sprintf( log_buf, "MpDamage - Invalid damage type vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
	return;
    }

    if ( damtype == DAM_SLASH )
     dammes = DAMNOUN_SLASH;
    else if ( damtype == DAM_PIERCE )
     dammes = DAMNOUN_PIERCE;
    else if ( damtype == DAM_SCRATCH )
     dammes = DAMNOUN_TEAR;
    else if ( damtype == DAM_BASH )
     dammes = DAMNOUN_STRIKE;
    else if ( damtype == DAM_INTERNAL )
     dammes = gsn_wrack;
    else
     dammes = damtype + 913;

    damage( victim, victim, dam, dammes, damtype, TRUE );
  return;
}
Exemplo n.º 8
0
void do_allow( CHAR_DATA *ch, char *argument )                        
{
    char arg[MAX_INPUT_LENGTH];
    char buf[MAX_STRING_LENGTH];
    BAN_DATA *prev;
    BAN_DATA *curr;
    char *name, *user, *host;

    one_argument( argument, arg );

    if ( arg[0] == '\0' )
    {
        send_to_char( "Remove which site from the ban list?\n\r", ch );
        return;
    }

    name = arg;

    user = &str_empty[0];
    for ( host = name; *name != '\0'; )
    {
	if ( *name == '@' )
	{
	    user	= host;
	    *name	= '\0';
	    host	= name+1;
	    break;
	}
	name++;
    }

    prev = NULL;
    for ( curr = ban_list; curr != NULL; prev = curr, curr = curr->next )
    {
	if ( IS_SET(curr->ban_flags, BAN_USER)
	&&   str_cmp(curr->user, user) )
	    continue;

        if ( !str_cmp( host, curr->host ) )
        {
	    if (curr->level > get_trust(ch))
	    {
		send_to_char(
		   "You are not powerful enough to lift that ban.\n\r",ch);
		return;
	    }
            if ( prev == NULL )
                ban_list   = ban_list->next;
            else
                prev->next = curr->next;

	    if ( IS_SET(curr->ban_flags, BAN_USER) )
		sprintf( buf, "Ban on %s@%s lifted.\r\n",
		    curr->user, curr->host );
	    else
		sprintf( buf, "Ban on %s lifted.\r\n",
		    curr->host );
            free_ban(curr);
            send_to_char( buf, ch );
	    save_bans();
            return;
        }
    }

    send_to_char( "Site is not banned.\n\r", ch );
    return;
}
Exemplo n.º 9
0
void do_chaosgate(CHAR_DATA *ch, char *argument)
{
    char arg[MAX_INPUT_LENGTH];
    ROOM_INDEX_DATA *location;
    CHAR_DATA *victim;
    int random_room;

    one_argument (argument, arg);

    if (IS_NPC(ch)) return;
    if (!IS_CLASS(ch, CLASS_TANARRI))
    {
        send_to_char("Huh?\n\r",ch);
        return;
    }
    if (!IS_SET(ch->pcdata->powers[TANARRI_POWER], TANARRI_CHAOSGATE))
    {
        send_to_char("You don't have that power yet.\n\r",ch);
        return;
    }
    if ((victim = get_char_world(ch, arg)) == NULL)
    {
        send_to_char("Chaosgate to whom?\n\r", ch );
        return;
    }
    if (IS_SET(victim->in_room->room_flags, ROOM_ASTRAL))
    {
        stc( "You can't find it's room.\n\r",ch);
        return;
    }
    if (IS_IMMUNE(victim, IMM_TRAVEL) && !IS_NPC(victim))
    {
        send_to_char("I don't think they want you to do that.\n\r",ch);
        return;
    }
    if (IS_SET(victim->act, ACT_NOTRAVEL))
    {
        send_to_char("No Can Do.\n\r", ch);
        return;
    }
    if (IS_SET(ch->in_room->room_flags, ROOM_ASTRAL))
    {
        stc( "Your room is not connected to the astral plane.\n\r",ch);
        return;
    }
    if (ch->move < 1000)
    {
        send_to_char("You don't have the move to open a chaosgate.\n\r", ch );
        return;
    }
    if (number_range(1,15)!=1) location = victim->in_room;
    else
    {
        send_to_char("Something went wrong.\n\r",ch);
        for ( ; ; )
        {
            random_room = number_range(1000, 65535);
            location = get_room_index(random_room);
            if (location != NULL)
                if (!IS_SET(location->room_flags, ROOM_PRIVATE) && !IS_SET(location->room_flags, ROOM_SOLITARY)
                        &&  !IS_SET(location->room_flags, ROOM_NO_TELEPORT)) break;
        }
    }
    act("You open a gate made from pure chaos and steps into it.", ch, NULL, NULL, TO_CHAR);
    act("$n opens a gate of pure chaos and steps into it.", ch, NULL, NULL, TO_ROOM);
    ch->move -= 1000;
    char_from_room(ch);
    char_to_room(ch, location);
    do_look(ch, "auto");
    act("You step out of the gate.", ch, NULL, NULL, TO_CHAR);
    act("A gate appears from out of nowhere and $n steps out of it.", ch, NULL, NULL, TO_ROOM);
    return;
}
Exemplo n.º 10
0
void do_mpforce( CHAR_DATA *ch, char *argument )
{
    char arg[ MAX_INPUT_LENGTH ];

    if ( !IS_NPC( ch ) )
    {
	send_to_char( C_DEFAULT, "Huh?\n\r", ch );
	return;
    }

    if ( IS_AFFECTED( ch, AFF_CHARM ) )
    {
        return;
    }

    argument = one_argument( argument, arg );

    if ( arg[0] == '\0' || argument[0] == '\0' )
    {
	bug( "Mpforce - Bad syntax: vnum %d.", ch->pIndexData->vnum );
	return;
    }

    if ( !str_cmp( arg, "all" ) )
    {
        CHAR_DATA *vch;
        CHAR_DATA *vch_next;

	for ( vch = char_list; vch != NULL; vch = vch_next )
	{
	    vch_next = vch->next;

	    if ( vch->in_room == ch->in_room
		&& (get_trust( vch ) < get_trust( ch ) || ch->level <
L_DEI || IS_NPC(ch)) 
		&& can_see( ch, vch ) )
	    {
		interpret( vch, argument );
	    }
	}
    }
    else
    {
	CHAR_DATA *victim;

	if ( ( victim = get_char_room( ch, arg ) ) == NULL )
	{
	    bug( "Mpforce - No such victim: vnum %d.",
	  	ch->pIndexData->vnum );
	    return;
	}

	if ( victim == ch )
    	{
	    bug( "Mpforce - Forcing oneself: vnum %d.",
	    	ch->pIndexData->vnum );
	    return;
	}
        if ((get_trust( victim ) < L_DEI) || IS_NPC(victim)  )
	interpret( victim, argument );
        
    }

    return;
}
Exemplo n.º 11
0
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, *user, *host;
    BAN_DATA *pban, *prev;
    bool prefix = FALSE,suffix = FALSE, fUser = FALSE;
    int type;
    BUFFER *buffer;

    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%s%s",
		pban->user,
		IS_SET(pban->ban_flags,BAN_USER) ? "@" : "",
		IS_SET(pban->ban_flags,BAN_PREFIX) ? "*" : "",
		pban->host,
		IS_SET(pban->ban_flags,BAN_SUFFIX) ? "*" : "");
	    sprintf(buf,"%-18s    %-3d  %-7s  %s\n\r",
		buf2, pban->level,
		IS_SET(pban->ban_flags,BAN_NEWBIES) ? "newbies" :
		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,"permit"))
	type = BAN_PERMIT;
    else
    {
	send_to_char("Acceptable ban types are all, newbies, and permit.\n\r",
	    ch); 
	return;
    }

    name = arg1;

    user = &str_empty[0];
    for ( host = name; *name != '\0'; )
    {
	if ( *name == '@' )
	{
	    fUser	= TRUE;
	    user	= host;
	    *name	= '\0';
	    host	= name+1;
	    break;
	}
	name++;
    }

    if (host[0] == '*')
    {
	prefix = TRUE;
	host++;
    }

    if (host[strlen(host) - 1] == '*')
    {
	suffix = TRUE;
	host[strlen(host) - 1] = '\0';
    }

    if (strlen(host) == 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 ( IS_SET(pban->ban_flags, BAN_USER)
	&&   str_cmp(pban->user, user) )
	    continue;

        if (!str_cmp(host,pban->host))
        {
	    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->user = str_dup(user);
    pban->host = str_dup(host);
    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);
    if ( fUser )
	SET_BIT(pban->ban_flags,BAN_USER);

    pban->next  = ban_list;
    ban_list    = pban;
    save_bans();
    sprintf(buf,"%s%s%s has been banned.\n\r",
	pban->user,
	IS_SET(pban->ban_flags, BAN_USER) ? "@" : "",
	pban->host );
    send_to_char( buf, ch );
    return;
}
Exemplo n.º 12
0
void do_mptransfer( CHAR_DATA *ch, char *argument )
{
    char             arg1[ MAX_INPUT_LENGTH ];
    char             arg2[ MAX_INPUT_LENGTH ];
    ROOM_INDEX_DATA *location;
    DESCRIPTOR_DATA *d;
    CHAR_DATA       *victim;

    if ( !IS_NPC( ch ) )
    {
	send_to_char( C_DEFAULT, "Huh?\n\r", ch );
	return;
    }

    if ( IS_AFFECTED( ch, AFF_CHARM ) )
    {
        return;
    }

    argument = one_argument( argument, arg1 );
    argument = one_argument( argument, arg2 );

    if ( arg1[0] == '\0' )
    {
	bug( "Mptransfer - Bad syntax: vnum %d.", ch->pIndexData->vnum );
	return;
    }

    if ( !str_cmp( arg1, "all" ) )
    {
	for ( d = descriptor_list; d != NULL; d = d->next )
	{
	    if ( d->connected == CON_PLAYING
	    &&   d->character != ch
	    &&   d->character->in_room != NULL
	    &&   can_see( ch, d->character ) )
	    {
		char buf[MAX_STRING_LENGTH];
		sprintf( buf, "%s %s", d->character->name, arg2 );
		do_transfer( ch, buf );
	    }
	}
	return;
    }

    /*
     * Thanks to Grodyn for the optional location parameter.
     */
    if ( arg2[0] == '\0' )
    {
	location = ch->in_room;
    }
    else
    {
	if ( ( location = find_location( ch, arg2 ) ) == NULL )
	{
	    bug( "Mptransfer - No such location: vnum %d.",
	        ch->pIndexData->vnum );
	    return;
	}

	if ( room_is_private( location ) )
	{
	    bug( "Mptransfer - Private room: vnum %d.",
		ch->pIndexData->vnum );
	    return;
	}
    }

    if ( ( victim = get_char_world( ch, arg1 ) ) == NULL )
    {
	bug( "Mptransfer - No such person: vnum %d.",
	    ch->pIndexData->vnum );
	return;
    }

    if ( victim->in_room == NULL )
    {
	bug( "Mptransfer - Victim in Limbo: vnum %d.",
	    ch->pIndexData->vnum );
	return;
    }

    if ( victim->in_room == location )
      return;

/* Changing this, if victim is fighting, DON'T WORK */
/*
    if ( victim->fighting != NULL )
	stop_fighting( victim, TRUE );
*/
    if ( victim->fighting != NULL )
    {
	bug( "Mptransfer - Victim fighting: vnum %d",
	    ch->pIndexData->vnum );
	return;
    }

    char_from_room( victim );
    char_to_room( victim, location );

    return;
}
Exemplo n.º 13
0
void do_mppurge( CHAR_DATA *ch, char *argument )
{
    char       arg[ MAX_INPUT_LENGTH ];
    CHAR_DATA *victim;
    OBJ_DATA  *obj;

    if ( !IS_NPC( ch ) )
    {
        send_to_char( C_DEFAULT, "Huh?\n\r", ch );
	return;
    }

    if ( IS_AFFECTED( ch, AFF_CHARM ) )
    {
        return;
    }

    one_argument( argument, arg );

    if ( arg[0] == '\0' )
    {
        /* 'purge' */
        CHAR_DATA *vnext;
        OBJ_DATA  *obj_next;

	for ( victim = ch->in_room->people; victim != NULL; victim = vnext )
	{
	  vnext = victim->next_in_room;
	  if ( IS_NPC( victim ) && victim != ch )
	    extract_char( victim, TRUE );
	}

	for ( obj = ch->in_room->contents; obj != NULL; obj = obj_next )
	{
	  obj_next = obj->next_content;
	  extract_obj( obj );
	}

	return;
    }

    if ( ( victim = get_char_room( ch, arg ) ) == NULL )
    {
	if ( ( obj = get_obj_here( ch, arg ) ) )
	{
	    extract_obj( obj );
	}
	else
	{
	    bug( "Mppurge - Bad argument: vnum %d.", ch->pIndexData->vnum );
	}
	return;
    }

    if ( !IS_NPC( victim ) )
    {
	bug( "Mppurge - Purging a PC: vnum %d.", ch->pIndexData->vnum );
	return;
    }

    extract_char( victim, TRUE );
    return;
}
Exemplo n.º 14
0
void do_mpoload( CHAR_DATA *ch, char *argument )
{
    char arg1[ MAX_INPUT_LENGTH ];
    char arg2[ MAX_INPUT_LENGTH ];
    OBJ_INDEX_DATA *pObjIndex;
    OBJ_DATA       *obj;
    int             level;

    if ( !IS_NPC( ch ) )
    {
        send_to_char( C_DEFAULT, "Huh?\n\r", ch );
	return;
    }

    if ( IS_AFFECTED( ch, AFF_CHARM ) )
    {
        return;
    }

    if ( IS_AFFECTED( ch, AFF_CHARM ) )
    {
	return;
    }

    argument = one_argument( argument, arg1 );
    argument = one_argument( argument, arg2 );
 
    if ( arg1[0] == '\0' || !is_number( arg1 ) )
    {
        bug( "Mpoload - Bad syntax: vnum %d.",
	    ch->pIndexData->vnum );
        return;
    }
 
    if ( arg2[0] == '\0' )
    {
	level = get_trust( ch );
    }
    else
    {
	/*
	 * New feature from Alander.
	 */
        if ( !is_number( arg2 ) )
        {
	    bug( "Mpoload - Bad syntax: vnum %d.", ch->pIndexData->vnum );
	    return;
        }
	level = atoi( arg2 );
	if ( level < 0 || level > get_trust( ch ) )
	{
	    bug( "Mpoload - Bad level: vnum %d.", ch->pIndexData->vnum );
	    return;
	}
    }

    if ( ( pObjIndex = get_obj_index( atoi( arg1 ) ) ) == NULL )
    {
	bug( "Mpoload - Bad vnum arg: vnum %d.", ch->pIndexData->vnum );
	return;
    }

    obj = create_object( pObjIndex, level );
    if ( CAN_WEAR(obj, ITEM_TAKE) )
    {
	obj_to_char( obj, ch );
    }
    else
    {
	obj_to_room( obj, ch->in_room );
    }

    return;
}
Exemplo n.º 15
0
void command_interpret(Character *ch, const char *argument)
{
    char arg[500];
    bool found;
    const Command *cmd;
    /*
     * Strip leading spaces.
     */

    while (isspace((int)*argument)) {
        argument++;
    }

    if (argument[0] == '\0') {
        return;
    }
    argument = one_argument(argument, arg);
    /*
     * Look for command in command table.
     */
    found = false;

    for (cmd = cmd_table; cmd->name != 0; cmd++)
    {

        if (UPPER(arg[0]) == UPPER(cmd->name[0])
                && !str_prefix(arg, cmd->name) && cmd->level <= ch->level)
        {
            found = true;
            break;
        }
    }

    if (!found)
    {

        if (interpret_social(ch, arg, argument)) {
            return;
        }
        const char *const message[] =
        {
            "Huh?",
            "Pardon?",
            "Excuse me?",
            "What?",
            "Say again.",
            "Eh?",
            "Can you repeat that?",
            "You want what?",
            "Ummm...",
            "Syntax Error",
            "Come again?",
            "Bad command or file name.",
            "I do not understand..."
        };
        xwriteln(ch,
                 message[number_range
                         (0,
                          (sizeof(message) / sizeof(message[0])) - 1)]);
        return;
    }

    if (cmd->position < ch->position)
    {
        xwritelnf(ch, "You can't do that while you are %s.",
                  position_table[ch->position].name);
        return;
    }
    (*cmd->dofun) (cmd->name, ch, argument);
}
Exemplo n.º 16
0
void write_interpret( CHAR_DATA * ch, char *argument )
{

    BUF_DATA_STRUCT *buf_data;
    char *buf;
    int curlen;


    for ( buf_data = first_buf; buf_data != NULL; buf_data = buf_data->next )
    {
        if ( buf_data->ch == ch )
            break;
    }

    if ( buf_data == NULL )
    {
        bugf( "Call to write_interpret when not writing (char=%s)\r\n", ch->name.c_str() );
        ch->position = POS_STANDING;
        return;
    }

    buf = buf_data->buf;


    /*
     * Check to see if text was a command or simply addition
     */
    if ( argument[0] != '.' )
    {
        curlen = strlen( buf );
        if ( curlen > MAX_STRING_LENGTH - 240 )
        {
            send_to_char( "String to long, cannot add new line.\r\n", ch );
            return;
        }
        for ( buf = buf + curlen; *argument != '\0'; )
            *( buf++ ) = *( argument++ );
        *( buf++ ) = '\n';
        *( buf++ ) = '\r';
        *buf = '\0';
        return;
    }

    /*
     * We have a command.
     */
    /*
     * Commands are .help .save .preview .- .clear .lines
     */
    argument++;
    if ( argument[0] == '\0' || !str_prefix(argument, "save") || !str_prefix(argument, "quit") )
    {
        bool save;
        char **dest;

        if ( !str_prefix(argument, "quit") )
            save = false;
        else
            save = true;

        dest = buf_data->dest;
        ch = buf_data->ch;

        /*
         * Save routine.
         */

        if ( save )
        {
            /*
             * Check that dest still points to buf (to check for corruption)
             */
            if ( *dest != buf )
            {
                bug( "write_interpret: Original destination has been overwritten.", 0 );
                send_to_char( "Cannot save, string pointer been modified.\r\n", ch );
            }
            else
            {
                FILE *fp = NULL;
                if ( ch->pcdata->header != &str_empty[0] ) /* File passed from helpedit */
                {
                    if ( (fp = file_open(ch->pcdata->header, "w")) == NULL )
                    {
                        send_to_char("Something is broken in write_interpret saving to file.\r\n", ch);
                        file_close(fp);
                        return;
                    }
                }
                *dest = str_dup( buf );
                if ( ( buf_data->returnfunc ) != NULL )
                    ( *buf_data->returnfunc ) ( buf_data->returnparm, dest, ch, TRUE );
                if ( ch->pcdata->header != &str_empty[0] ) /* File passed from helpedit */
                {
                    fprintf(fp, "%s", buf);
                    file_close(fp);
                }
            }
        }
        else
        {
            *dest = &str_empty[0];
            if ( ( buf_data->returnfunc ) != NULL )
                ( *buf_data->returnfunc ) ( buf_data->returnparm, dest, ch, FALSE );
        }

        /*
         * Re-use memory.
         */
        dispose( buf_data->buf, MAX_STRING_LENGTH );

        UNLINK( buf_data, first_buf, last_buf, next, prev );

        /*
         * Re-set char
         */
        ch->position = buf_data->old_char_pos;

        delete buf_data;

        return;
    }


    if ( !str_prefix(argument, "help") )
    {
        /*
         * Help
         */
        ch = buf_data->ch;

        send_to_char( "Normal type will be appended to the string, line by line.\r\n", ch );
        send_to_char( ".help     or .h :  displays this help.\r\n", ch );
        send_to_char( ".save     or .  :  saves and exits the editor.\r\n", ch );
        send_to_char( ".preview  or .p :  display a preview of the text.\r\n", ch );
        send_to_char( ".-[num]   or .- :  deletes [num] lines from the end, or just one line\r\n", ch );
        send_to_char( ".clear          :  deletes whole text.\r\n", ch );
        send_to_char( ".quit     or .q :  quits without saving.\r\n", ch );
        send_to_char( ".format   or .f :  formats text for 80 chars.\r\n", ch );
        send_to_char( ".replace  or .r :  replaces word with string.\r\n", ch );
        send_to_char( "	       (usage) :  .r <word> <string>.  If no string, arg1 deleted.\r\n", ch );
        return;
    }

    if ( !str_prefix(argument, "replace") )
    {
        /*
         * Mag:  I bet you take one look at this, and change it :) -S-
         */

        char arg1[MAX_STRING_LENGTH];
        char arg2[MAX_STRING_LENGTH];
        char word[MAX_STRING_LENGTH];
        char new_buf[MAX_STRING_LENGTH];
        char pBuf;
        int pos;
        int npos;
        int wpos;
        int buf_length;
        int foo;
        int i;
        char *src;

        argument = one_argument( argument + 1, arg1 );  /* Skip the R */
        strcpy( arg2, argument );

        if ( arg1[0] == '\0' )
        {
            send_to_char( "No arg1 supplied for replace command.\r\n", ch );
            return;
        }

        new_buf[0] = '\0';
        buf_length = strlen( buf );
        pos = 0;
        npos = 0;
        wpos = 0;
        word[0] = '\0';

        for ( ;; )
        {
            pBuf = buf[pos];

            if ( pBuf == '\0' || pos > buf_length )
                break;

            if ( pBuf == ' ' )
            {
                new_buf[npos] = ' ';
                pos++;
                npos++;
                continue;
            }

            if ( !isgraph( pBuf ) )
            {
                new_buf[npos] = pBuf;
                pos++;
                npos++;
                continue;
            }

            wpos = 0;
            for ( ;; )
            {
                if ( !isgraph( pBuf ) )
                    break;

                word[wpos] = pBuf;
                pos++;
                wpos++;
                pBuf = buf[pos];
            }
            word[wpos] = '\0';

            if ( !str_cmp( word, arg1 ) )
            {
                if ( arg2[0] != '\0' )
                    for ( foo = 0; arg2[foo] != '\0'; foo++ )
                    {
                        new_buf[npos] = arg2[foo];
                        npos++;
                    }
                else
                {
                    /*
                     * Do nothing (much).
                     */
                    if ( npos > 0 )
                        npos--;
                    send_to_char( "Arg1 deleted.\r\n", ch );
                }
            }
            else
            {
                for ( foo = 0; word[foo] != '\0'; foo++ )
                {
                    new_buf[npos] = word[foo];
                    npos++;
                }
            }
        }

        /*
         * -gulp-  Copy new_buf into message structure...
         */

        src = buf;
        for ( i = 0; i < npos; i++ )
            *( src++ ) = new_buf[i];
        *( src ) = '\0';


        return;
    }



    if ( !str_prefix(argument, "preview") )
    {
        send_to_char( buf, ch );
        return;
    }

    if ( argument[0] == '-' )
    {
        int num;
        int a;

        argument++;
        if ( argument[0] == '\0' )
            num = 2;
        else
            num = atoi( argument ) + 1;

        if ( num <= 0 )
            return;

        for ( a = strlen( buf ); a >= 0; a-- )
        {
            if ( buf[a] == '\n' )
            {
                num--;
                if ( num == 0 )
                    break;
            }
        }

        if ( a == 0 )
        {
            send_to_char( "Tried to delete too many lines.\r\n", buf_data->ch );
            return;
        }

        a++;
        if ( buf[a] == '\r' )
            a++;
        send_to_char( "Deleted:\r\n", buf_data->ch );
        send_to_char( buf + a, buf_data->ch );

        buf[a] = '\0';
        return;
    }

    if ( !str_prefix(argument, "format") )
    {
        char *src;
        char dest[MAX_STRING_LENGTH];
        int col;
        char *srcspc;
        int destspc;
        char c;
        int n, i;
        int lastcol;

        /*
         * Format text
         */
        /*
         * Go through line by line, doing word wrapping
         */

        lastcol = 79;

        col = 0;
        n = 0;
        srcspc = NULL;
        destspc = 0;

        for ( src = buf; *src != '\0'; )
        {
            c = *( src++ );
            switch ( c )
            {
                case '\n': /* Convert /n/r into one space */
                    if ( ( *src == '\r' ) && ( *( src + 1 ) == '\n' ) && ( *( src + 2 ) == '\r' ) )
                    {
                        /*
                         * Do not convert paragraph endings.
                         */
                        dest[n++] = c; /* \n */
                        dest[n++] = *( src++ ); /* \r */
                        dest[n++] = *( src++ ); /* \n */
                        dest[n++] = *( src++ ); /* \r */
                        col = 0;
                        srcspc = NULL;
                        destspc = 0;
                        break;
                    }

                    /*
                     * Also if there is a space on the next line, don't merge.
                     */
                    if ( ( *src == '\r' ) && ( *( src + 1 ) == ' ' ) )
                    {
                        dest[n++] = c; /* \n */
                        dest[n++] = *( src++ ); /* \r */
                        col = 0;
                        srcspc = NULL;
                        destspc = 0;
                        break;
                    }


                    /*
                     * Otherwise convert to a space
                     */
                    /*
                     * Get rid of spaces at end of a line.
                     */
                    if ( n > 0 )
                    {
                        while ( dest[--n] == ' ' );
                        n++;
                    }
                    dest[n++] = ' ';
                    col++;

                    srcspc = src - 1;
                    destspc = n - 1;
                    break;
                case '\r':
                    break;

                case '\t': /* Tab */
                    col += 7;
                case '.':  /* Punctuation */
                case ' ':
                case ',':
                case ';':
                case '?':
                case '!':
                case ')':
                    srcspc = src - 1;
                    destspc = n - 1;
                case '-':
                    if ( srcspc == NULL )
                    {
                        srcspc = src - 1; /* Only use a dash if necessary */
                        destspc = n - 1;
                    }
                case '@': /* Color */
                    dest[n++] = c;
                    break;
                default:
                    if ( dest[n - 1] == '@' ) /* We're a color code */
                    {
                        dest[n++] = c;
                        break;
                    }
                    dest[n++] = c;
                    col++;
                    break;
            }

            if ( col >= lastcol )
            {
                /*
                 * Need to do a line break
                 */
                if ( srcspc == NULL )
                {
                    /*
                     * there were no breakable characters on the line.
                     */
                    dest[n++] = '\n';
                    dest[n++] = '\r';
                }
                else
                {
                    n = destspc;   /* n now points to a breakable char. */
                    src = srcspc;
                    while ( dest[n] == ' ' || dest[n] == '\n' )
                    {
                        n--;
                    }

                    src++;
                    n++;
                    if ( *src == '\r' )
                        src++;
                    while ( *src == ' ' )
                        src++;
                    /*
                     * src now points to the new line to be put in dest.
                     */
                    dest[n++] = '\n';
                    dest[n++] = '\r';
                    col = 0;
                    srcspc = NULL;
                    destspc = 0;
                }
            }
        }

        /*
         * Get rid of spaces at end, and add a newline.
         */

        while ( dest[--n] == ' ' );
        n++;
        dest[n++] = '\n';
        dest[n++] = '\r';

        /*
         * Copy from dest back into buffer
         */

        src = buf;
        for ( i = 0; i < n; i++ )
            *( src++ ) = dest[i];
        *( src ) = '\0';

        return;
    }

    if ( !str_cmp( argument, "clear" ) )
    {
        buf[0] = '\0';
        send_to_char( "Done.\r\n", buf_data->ch );
        return;
    }

    send_to_char( "Command not known, type .help for help.\r\n", buf_data->ch );
    return;
}
Exemplo n.º 17
0
void do_heal(Character *ch, char *argument)
{
    Character *mob;
    char arg[MAX_INPUT_LENGTH];
    int cost,sn;
    SPELL_FUN *spell;
    char *words;	

    /* check for healer */
    for ( mob = ch->in_room->people; mob; mob = mob->next_in_room )
    {
        if ( IS_NPC(mob) && IS_SET(mob->act, ACT_IS_HEALER) )
            break;
    }
 
    if ( mob == NULL )
    {
        send_to_char( "You can't do that here.\n\r", ch );
        return;
    }

    one_argument(argument,arg);

    if (arg[0] == '\0')
    {
        /* display price list */
	act("$N says 'I offer the following spells:'",ch,NULL,mob,TO_CHAR);
	send_to_char("  light: cure light wounds      10 gold\n\r",ch);
	send_to_char("  serious: cure serious wounds  15 gold\n\r",ch);
	send_to_char("  critic: cure critical wounds  25 gold\n\r",ch);
	send_to_char("  heal: healing spell           50 gold\n\r",ch);
	send_to_char("  blind: cure blindness         20 gold\n\r",ch);
	send_to_char("  disease: cure disease         15 gold\n\r",ch);
	send_to_char("  poison:  cure poison          25 gold\n\r",ch); 
	send_to_char("  uncurse: remove curse         50 gold\n\r",ch);
	send_to_char("  refresh: restore movement      5 gold\n\r",ch);
	send_to_char("  mana:  restore mana           10 gold\n\r",ch);
	send_to_char(" Type heal <type> to be healed.\n\r",ch);
	return;
    }

    if (!str_prefix(arg,"light"))
    {
        spell = spell_cure_light;
	sn    = skill_lookup("cure light");
	words = (char*)"judicandus dies";
	 cost  = 1000;
    }

    else if (!str_prefix(arg,"serious"))
    {
	spell = spell_cure_serious;
	sn    = skill_lookup("cure serious");
	words = (char*)"judicandus gzfuajg";
	cost  = 1600;
    }

    else if (!str_prefix(arg,"critical"))
    {
	spell = spell_cure_critical;
	sn    = skill_lookup("cure critical");
	words = (char*)"judicandus qfuhuqar";
	cost  = 2500;
    }

    else if (!str_prefix(arg,"heal"))
    {
	spell = spell_heal;
	sn = skill_lookup("heal");
	words = (char*)"pzar";
	cost  = 5000;
    }

    else if (!str_prefix(arg,"blindness"))
    {
	spell = spell_cure_blindness;
	sn    = skill_lookup("cure blindness");
      	words = (char*)"judicandus noselacri";		
        cost  = 2000;
    }

    else if (!str_prefix(arg,"disease"))
    {
	spell = spell_cure_disease;
	sn    = skill_lookup("cure disease");
	words = (char*)"judicandus eugzagz";
	cost = 1500;
    }

    else if (!str_prefix(arg,"poison"))
    {
	spell = spell_cure_poison;
	sn    = skill_lookup("cure poison");
	words = (char*)"judicandus sausabru";
	cost  = 2500;
    }
	
    else if (!str_prefix(arg,"uncurse") || !str_prefix(arg,"curse"))
    {
	spell = spell_remove_curse; 
	sn    = skill_lookup("remove curse");
	words = (char*)"candussido judifgz";
	cost  = 5000;
    }

    else if (!str_prefix(arg,"mana") || !str_prefix(arg,"energize"))
    {
        spell = NULL;
        sn = -1;
        words = (char*)"energizer";
        cost = 1000;
    }

	
    else if (!str_prefix(arg,"refresh") || !str_prefix(arg,"moves"))
    {
	spell =  spell_refresh;
	sn    = skill_lookup("refresh");
	words = (char*)"candusima"; 
	cost  = 500;
    }

    else 
    {
	act("$N says 'Type 'heal' for a list of spells.'",
	    ch,NULL,mob,TO_CHAR);
	return;
    }

    if (cost > (ch->gold * 100 + ch->silver))
    {
	act("$N says 'You do not have enough gold for my services.'",
	    ch,NULL,mob,TO_CHAR);
	return;
    }

    WAIT_STATE(ch,PULSE_VIOLENCE);

    deduct_cost(ch,cost);
    mob->gold += cost;
    act("$n utters the words '$T'.",mob,NULL,words,TO_ROOM);
  
    if (spell == NULL)  /* restore mana trap...kinda hackish */
    {
	ch->mana += dice(2,8) + mob->level / 3;
	ch->mana = UMIN(ch->mana,ch->max_mana);
	send_to_char("A warm glow passes through you.\n\r",ch);
	return;
     }

     if (sn == -1)
	return;
    
     spell(sn,mob->level,mob,ch,TARGET_CHAR);
}
Exemplo n.º 18
0
void do_headbutt(CHAR_DATA * ch, char *argument)
{
	CHAR_DATA *victim;
	char arg[MAX_INPUT_LENGTH];
	int timer = 24;
	int mod;
	int dmg;
	if (ch->race != RACE_MINOTAUR) {
		send_to_char(AT_GREY,
			     "Wham!  Ouch!  You sure are no minotaur\n\r", ch);
		return;
	}
	if (ch->race_wait > 0)
		return;
	if (!ch->fighting) {
		send_to_char(C_DEFAULT, "You aren't fighting anyone.\n\r", ch);
		return;
	}

	one_argument(argument, arg);

	victim = ch->fighting;

	if (arg[0] != '\0')
		if (!(victim = get_char_room(ch, arg))) {
			send_to_char(C_DEFAULT, "They aren't here.\n\r", ch);
			return;
		}

	switch (prime_class(ch)) {
	case CLASS_MAGE:
	case CLASS_CLERIC:
		timer = 240;
		break;
	case CLASS_THIEF:
		timer = 180;
		break;
	case CLASS_WARRIOR:
		timer = 120;
		break;
	case CLASS_PSIONICIST:
	case CLASS_DRUID:
		timer = 240;
		break;
	case CLASS_RANGER:
	case CLASS_PALADIN:
	case CLASS_BARD:
	case CLASS_VAMPIRE:
		timer = 180;
		break;
	case CLASS_NECROMANCER:
		timer = 240;
		break;
	case CLASS_WEREWOLF:
		timer = 180;
		break;
	}
	mod = ch->level / 5;
	mod = UMAX(1, mod);
	timer = timer / mod;
	timer = (timer < 24) ? 24 : timer;
	ch->race_wait = timer;
	act(AT_YELLOW, "You slam your head into $N's!", ch, NULL, victim,
	    TO_CHAR);
	act(AT_YELLOW, "$n slams his head into yours!", ch, NULL, victim,
	    TO_VICT);
	act(AT_YELLOW, "$n slams his head into $N's!", ch, NULL, victim,
	    TO_NOTVICT);
	dmg = number_range(ch->level, ch->level * 5);
	damage(ch, victim, dmg, gsn_headbutt);
	STUN_CHAR(ch, 2, STUN_MAGIC);
	if (victim->position == POS_DEAD || ch->in_room != victim->in_room)
		return;
	if (number_percent() < 15 && victim->position != POS_STUNNED) {
		act(AT_WHITE, "$N reels from the blow...", ch, NULL, victim,
		    TO_CHAR);
		act(AT_WHITE, "$N reels from the blow...", ch, NULL, victim,
		    TO_NOTVICT);
		act(AT_WHITE, "You real from the blow and feel disoriented.",
		    ch, NULL, victim, TO_VICT);
		STUN_CHAR(victim, 2, STUN_TOTAL);
		victim->position = POS_STUNNED;
	}
	return;
}
Exemplo n.º 19
0
/* allows supermob to add affects like poisoned, diseased, etc.. -Flux */
void do_mpaffect( CHAR_DATA *ch, char *argument )
{
 CHAR_DATA	*victim;
 AFFECT_DATA	af;
 char		arg[MAX_INPUT_LENGTH];
 char		arg2[MAX_INPUT_LENGTH];
 long		affect;
 bool		affect2 = FALSE;

 if ( !IS_NPC( ch ) )
 {
  typo_message( ch );
  return;
 }

 if ( IS_SET( ch->act , ACT_PET ) || IS_AFFECTED( ch, AFF_CHARM ) )
      return;

    argument = one_argument( argument, arg );
    argument = one_argument( argument, arg2 );

    if ( arg[0] == '\0' || arg2[0] == '\0' )
    {
        sprintf( log_buf, "MpAffect - no argument: vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
    }

    if ( ( victim = get_char_room( ch, arg ) ) == NULL )
    {
        sprintf( log_buf, "Mpaffect - Victim not in room: vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
        return;
    }

    if ( victim == ch )
    {
        sprintf( log_buf, "Mpaffect - Bad victim to attack: vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
        return;
    }


    if ( IS_AFFECTED( ch, AFF_CHARM ) && ch->master == victim )
    {
        sprintf( log_buf, "Mpaffect - Charmed mob attacking master: vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
        return;
    }

    affect = flag_value( mpaffect_flags, arg2 );

    if ( affect == -99 || affect == -1 )
    {
     sprintf( log_buf, "Mpaffect - invalid affect type: vnum %d, name %s, short %s.",
	ch->pIndexData->vnum, ch->name, ch->short_descr );
     bug( log_buf, -1 );
     return;
    }            

   if ( !str_cmp( arg2, "poison" ) || !str_cmp( arg2, "insanity" ) )
   {
    if ( IS_AFFECTED( ch, affect ) )
     return;
    affect2 = FALSE;
   }
   else
   {
    if ( IS_AFFECTED2( ch, affect ) )
     return;
    affect2 = TRUE;
   }

       if ( affect == AFF_POISON && affect2 == FALSE )
        af.type      = gsn_poison;
       else if ( affect == AFF_DISEASED && affect2 == TRUE )
        af.type      = gsn_plague;
       else if ( affect == AFF_PLASMA && affect2 == TRUE )
        af.type      = gsn_plasma;
       else if ( affect == AFF_HALLUCINATING && affect2 == TRUE )
        af.type      = gsn_hallucinate;
       else if ( affect == AFF_INSANE && affect2 == FALSE )
        af.type      = gsn_insane;

        af.level     = victim->level;
        af.duration  = dice( 1, 25 );
        af.location  = APPLY_NONE;
        af.modifier  = 0;
        af.bitvector = affect;
       if ( !affect2 )
        affect_to_char( victim, &af );
       else
        affect_to_char2( victim, &af );

 return;
}
Exemplo n.º 20
0
void do_forge(CHAR_DATA * ch, char *argument)
{
	char arg[MAX_INPUT_LENGTH];
	char arg2[MAX_INPUT_LENGTH];
	char buf[MAX_INPUT_LENGTH];
	OBJ_DATA *obj, *hammer;
	int wear, lvl;
	long group1 =
	    ITEM_ANTI_HUMAN + ITEM_ANTI_DROW + ITEM_ANTI_ELF + ITEM_ANTI_ELDER;
	long group2 =
	    ITEM_ANTI_OGRE + ITEM_ANTI_TROLL + ITEM_ANTI_DEMON +
	    ITEM_ANTI_MINOTAUR;
	long group3 = ITEM_ANTI_DWARF + ITEM_ANTI_HALFLING + ITEM_ANTI_SHADOW;
	long group4 = ITEM_ANTI_ILLITHID + ITEM_ANTI_GHOUL;
	long group5 = ITEM_ANTI_PIXIE;
	long group6 = ITEM_ANTI_LIZARDMAN;
	long antirace = 0;
	wear = 0;
	if (ch->race != RACE_DWARF) {
		send_to_char(AT_GREY, "You aren't a dwarf!\n\r", ch);
		return;
	}
	if (argument[0] == '\0') {
		send_to_char(AT_WHITE, "Syntax: Forge <obj> <race> <lvl>\n\r",
			     ch);
		send_to_char(AT_WHITE, "  obj = ring necklace armor helm\n\r",
			     ch);
		send_to_char(AT_WHITE,
			     "        mask leggings boots gauntlets\n\r", ch);
		send_to_char(AT_WHITE, "        gauntlets armplates shield\n\r",
			     ch);
		send_to_char(AT_WHITE, "        belt bracer anklet weapon\n\r",
			     ch);
		send_to_char(AT_WHITE,
			     "  race= any valid race. HELP FORGE RACES\n\r",
			     ch);
		send_to_char(AT_WHITE, "        to see race groupings.\n\r",
			     ch);
		sprintf(buf, "  lvl = minimum 30, maximum %d.\n\r", ch->level);
		send_to_char(AT_WHITE, buf, ch);
		send_to_char(AT_WHITE,
			     "  BASE cost to make item is: 100 gold * lvl\n\r",
			     ch);
		return;
	}
	if (ch->in_room->vnum != ROOM_VNUM_SMITHY) {
		send_to_char(AT_GREY, "You cannot forge equipment here.\n\r",
			     ch);
		return;
	}
	for (hammer = ch->carrying; hammer; hammer = hammer->next) {
		if (hammer->pIndexData->vnum == OBJ_VNUM_SMITHY_HAMMER
		    && hammer->wear_loc == WEAR_HOLD)
			break;
	}
	if (!hammer) {
		send_to_char(AT_GREY,
			     "You must hold a smithy hammer to forge something.\n\r",
			     ch);
		return;
	}
	argument = one_argument(argument, arg);
	argument = one_argument(argument, arg2);
	if (!str_prefix(arg, "ring"))
		wear = ITEM_WEAR_FINGER;
	if (!str_prefix(arg, "necklace"))
		wear = ITEM_WEAR_NECK;
	if (!str_prefix(arg, "armor"))
		wear = ITEM_WEAR_BODY;
	if (!str_prefix(arg, "helm"))
		wear = ITEM_WEAR_HEAD;
	if (!str_prefix(arg, "mask"))
		wear = ITEM_WEAR_FACE;
	if (!str_prefix(arg, "leggings"))
		wear = ITEM_WEAR_LEGS;
	if (!str_prefix(arg, "boots"))
		wear = ITEM_WEAR_FEET;
	if (!str_prefix(arg, "gauntlets"))
		wear = ITEM_WEAR_HANDS;
	if (!str_prefix(arg, "armplates"))
		wear = ITEM_WEAR_ARMS;
	if (!str_prefix(arg, "shield"))
		wear = ITEM_WEAR_SHIELD;
	if (!str_prefix(arg, "belt"))
		wear = ITEM_WEAR_WAIST;
	if (!str_prefix(arg, "bracer"))
		wear = ITEM_WEAR_WRIST;
	if (!str_prefix(arg, "anklet"))
		wear = ITEM_WEAR_ANKLE;
	if (!str_prefix(arg, "weapon"))
		wear = ITEM_WIELD;
	if (!str_prefix(arg2, "elf")
	    || !str_prefix(arg2, "drow")
	    || !str_prefix(arg2, "elder")
	    || !str_prefix(arg2, "human"))
		antirace = group2 + group3 + group4 + group5 + group6;
	if (!str_prefix(arg2, "ogre")
	    || !str_prefix(arg2, "demon")
	    || !str_prefix(arg2, "troll")
	    || !str_prefix(arg2, "minotaur"))
		antirace = group1 + group3 + group4 + group5 + group6;
	if (!str_prefix(arg2, "dwarf")
	    || !str_prefix(arg2, "halfling")
	    || !str_prefix(arg2, "shadow"))
		antirace = group1 + group2 + group4 + group5 + group6;
	if (!str_prefix(arg2, "illithid")
	    || !str_prefix(arg2, "ghoul"))
		antirace = group1 + group2 + group3 + group5 + group6;
	if (!str_prefix(arg2, "pixie"))
		antirace = group1 + group2 + group3 + group4 + group6;
	if (!str_prefix(arg2, "lizardman"))
		antirace = group1 + group2 + group3 + group4 + group5;
	if (is_number(argument))
		lvl = atoi(argument);
	else
		lvl = 0;
	if (wear && antirace && (lvl < 30 || lvl > ch->level)) {
		sprintf(buf, "Illegal level.  Valid levels are 30 to %d.\n\r",
			ch->level);
		send_to_char(AT_GREY, buf, ch);
		return;
	}
	if (wear && antirace == 0) {
		send_to_char(AT_GREY,
			     "Illegal race.  Help RACE for valid race list.\n\r",
			     ch);
		return;
	}
	if (wear) {
#ifdef NEW_MONEY
		if ((ch->money.gold + (ch->money.silver / SILVER_PER_GOLD) +
		     (ch->money.copper / COPPER_PER_GOLD)) < (lvl * 100)) {
#else
		if (ch->gold < lvl * 10000) {
#endif
			send_to_char(AT_GREY,
				     "You do not have enough money to create the base item of this level.\n\r",
				     ch);
			return;
		} else if (wear == ITEM_WIELD)
			obj =
			    create_object(get_obj_index(OBJ_VNUM_TO_FORGE_W),
					  lvl);
		else
			obj =
			    create_object(get_obj_index(OBJ_VNUM_TO_FORGE_A),
					  lvl);
#ifdef NEW_MONEY
		obj->cost.silver = obj->cost.copper = 0;
		obj->cost.gold = lvl * 100;
#else
		obj->cost = lvl * 10000;
#endif
		obj->weight = lvl * 0.15;
		obj->level = lvl;
		obj->anti_race_flags = antirace;
		if (obj->level >= 101)
			obj->extra_flags += ITEM_NO_DAMAGE;
		obj->wear_flags += wear;
		forge_obj(ch, obj);
	} else
		do_forge(ch, "");
	return;
}

void do_spit(CHAR_DATA * ch, char *argument)
{
	AFFECT_DATA af;
	CHAR_DATA *victim;
	char arg[MAX_INPUT_LENGTH];
	int dam;
	if (ch->race != RACE_LIZARDMAN) {
		send_to_char(AT_GREY, "Huh?\n\r", ch);
		return;
	}
	if (ch->race_wait > 0)
		return;
	if (!ch->fighting) {
		send_to_char(C_DEFAULT, "You aren't fighting anyone.\n\r", ch);
		return;
	}
	one_argument(argument, arg);

	victim = ch->fighting;

	if (arg[0] != '\0')
		if (!(victim = get_char_room(ch, arg))) {
			send_to_char(C_DEFAULT, "They aren't here.\n\r", ch);
			return;
		}
	dam = ch->level + number_range(ch->level, ch->level * 4);
	damage(ch, victim, dam, gsn_spit);
	ch->race_wait = 36;

	if (!victim || victim->position == POS_DEAD || !victim->in_room
	    || victim->in_room != ch->in_room)
		return;

	if (number_percent() < 25) {
		int location = number_range(0, 1);
		switch (location) {
		case 0:
			if (victim->race != RACE_ILLITHID) {
				act(AT_DGREEN, "You spit right in $S eyes!", ch,
				    NULL, victim, TO_CHAR);
				act(AT_DGREEN, "$n spit into $N's eyes!", ch,
				    NULL, victim, TO_NOTVICT);
				act(AT_DGREEN, "$n spit into your eyes!", ch,
				    NULL, victim, TO_VICT);
				if (!IS_AFFECTED(victim, AFF_BLIND)) {
					send_to_char(AT_WHITE,
						     "You are blinded!",
						     victim);
					act(AT_WHITE, "$n is blinded!", victim,
					    NULL, NULL, TO_ROOM);
					af.type = gsn_spit;
					af.level = ch->level;
					af.duration = 0;
					af.location = APPLY_HITROLL;
					af.modifier = -10;
					af.bitvector = AFF_BLIND;
					affect_to_char(victim, &af);
					af.location = APPLY_AC;
					af.modifier = 50;
					affect_to_char(victim, &af);
				}
			}
			break;
		case 1:
			act(AT_DGREEN, "You spit right in $S mouth!", ch, NULL,
			    victim, TO_CHAR);
			act(AT_DGREEN, "$n spit into $N's mouth!  Gross!", ch,
			    NULL, victim, TO_NOTVICT);
			act(AT_DGREEN, "$n spit into your mouth!", ch, NULL,
			    victim, TO_VICT);
			send_to_char(AT_WHITE,
				     "The acidic spit burns your mouth and throat.\n\r",
				     victim);
			STUN_CHAR(victim, 2, STUN_MAGIC);
			break;

		}
	}
	if (!saves_spell(ch->level, victim) && victim->race != RACE_GHOUL) {
		af.type = gsn_poison;
		af.level = ch->level;
		af.duration = 2;
		af.location = APPLY_STR;
		af.modifier = -3;
		af.bitvector = 0;
		affect_join(victim, &af);
	}
	return;
}
Exemplo n.º 21
0
void do_mpjump( CHAR_DATA *ch, char *argument )
{
    char			arg[ MAX_INPUT_LENGTH ];
    char			arg2[ MAX_INPUT_LENGTH ];
    char			arg3[ MAX_INPUT_LENGTH ];
    char			thingbuf[MAX_STRING_LENGTH];
    CHAR_DATA		*victim;
    OBJ_INDEX_DATA	*pObjIndex;
    OBJ_DATA		*obj;
    int			level;

    if ( !IS_NPC( ch ) )
    {
	typo_message( ch );
	return;
    }

    argument = one_argument( argument, arg );
    argument = one_argument( argument, arg2 );
    argument = one_argument( argument, arg3 );

    if ( arg[0] == '\0' || arg2[0] == '\0' ||
         arg3[0] == '\0' )
    {
        sprintf( log_buf, "MpJump - no argument: vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
    }

    if ( !is_number( arg2 ) )
    {
        sprintf( log_buf, "Mpjump - Bad syntax: vnum %d name %s short %s.",
                ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
        return;
    }

    if ( ( victim = get_char_room( ch, arg ) ) == NULL )
    {
        sprintf( log_buf, "MpJump - Victim not in room: vnum %d name %s short %s .",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
	return;
    }

    if ( victim == ch )
    {
        sprintf( log_buf, "MpJump - Bad victim to attack: vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
	return;
    }

    if ( ( pObjIndex = get_obj_index( atoi( arg2 ) ) ) == NULL )
    {
        sprintf( log_buf, "Mpjump - Bad vnum arg: vnum %d name %s short %s.",
                ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
	return;
    }

 
    if ( arg3[0] == '\0' )
    {
    	level = pObjIndex->level;
    }
    else
    {
	/*
	 * New feature from Alander.
	 */
        if ( !is_number( arg3 ) )
        {
            sprintf( log_buf, "Mpjump - Bad syntax: vnum %d name %s short %s.",
                     ch->pIndexData->vnum, ch->name, ch->short_descr );
            bug( log_buf, -1 );
	    return;
        }
	level = atoi( arg3 );
	if ( level < 0 || level > get_trust( ch ) )
	{
            sprintf( log_buf, "Mpjump - Bad level: vnum %d name %s short %s.",
                     ch->pIndexData->vnum, ch->name, ch->short_descr );
            bug( log_buf, -1 );
	    return;
	}
    }

    obj = create_object( pObjIndex, level );
    if ( !CAN_WEAR(obj, ITEM_TAKE) )
    {
     sprintf( log_buf, "Mpjump - Bad level: vnum %d name %s short %s.",
              ch->pIndexData->vnum, ch->name, ch->short_descr );
     bug( log_buf, -1 );
     return;
    }
    else

    obj_to_char( obj, victim );
    one_argument( obj->name, thingbuf );
    do_wear( victim, thingbuf );
    return;
}
Exemplo n.º 22
0
Arquivo: org.c Projeto: verias/SRMud
void do_exalt(CHAR_DATA *ch, char *argument )
{	CHAR_DATA *victim;
	char arg[MSL];

	if(IS_NPC(ch) )
		return;

	if(!HAS_ORGANIZATION(ch) )
	{	send_to_char("You aren't organized.\n\r",ch);
		return;
	}
	if( ch->pcdata->rank < RANK_PRIEST )
	{	send_to_char("You cannot exalt people!\n\r",ch );
		return;
	}
	one_argument(argument, arg );

	if(arg[0] == '\0' )
	{	send_to_char("Syntax: Exalt <person>\n\r",ch);
		return;
	}
	if(!IS_IMMORTAL(ch) )
	{	if( ( victim = get_char_room(ch, NULL, arg) )  == NULL )
		{	send_to_char("They aren't here.\n\r",ch);
			return;
		}
	}
	else
	{	if( ( victim = get_char_world(ch, arg) ) == NULL )
		{	send_to_char("They aren't here.\n\r",ch);
			return;
		}
	}
	if(IS_NPC(victim) )
	{	send_to_char("Not on NPC's.\n\r",ch);
		return;
	}
	if(!HAS_ORGANIZATION(victim) )
	{	send_to_char("They aren't organized.\n\r",ch);
		return;
	}

    if(!IS_SAME_ORGANIZATION(ch, victim) && ch->pcdata->rank != RANK_GOD  )
	{	send_to_char("They aren't in your organization!\n\r",ch); 
		return; 
	}

	if( ch->pcdata->rank <= victim->pcdata->rank )
	{	send_to_char("You cannot exalt them.\n\r", ch );
		return;
	}

	if(!IS_IMMORTAL(ch) && ch->pcdata->rank <= RANK_PRIEST && victim->pcdata->rank >= RANK_BISHOP )
	{	send_to_char("You cannot exalt them.\n\r",ch);
		return;
	}

	if(victim->pcdata->rank == RANK_DEITY && ch->pcdata->rank != RANK_GOD )
	{	send_to_char("You cannot exalt to God Rank.\n\r",ch);
		return;
	}
	if(victim->pcdata->rank == RANK_GOD )
	{	send_to_char("They cannot get any higher!\n\r",ch);
		return;
	}

	victim->pcdata->rank++;
	printf_to_char(ch, "%s has been exalted to %s.\n\r", victim->name, orgrank_table[victim->pcdata->rank].name );
	act_new(victim->pcdata->organization->pmt_msg, victim, NULL, NULL, TO_CHAR, POS_SLEEPING);
	return;
}
Exemplo n.º 23
0
void do_mpoload( CHAR_DATA *ch, char *argument )
{
    char arg1[ MAX_INPUT_LENGTH ];
    char arg2[ MAX_INPUT_LENGTH ];
    OBJ_INDEX_DATA *pObjIndex;
    OBJ_DATA       *obj;
    int             level;

    if ( !IS_NPC( ch ) )
    {
	typo_message( ch );
	return;
    }

    if ( IS_SET( ch->act , ACT_PET ) || IS_AFFECTED( ch, AFF_CHARM ) )
      return;

    argument = one_argument( argument, arg1 );
    argument = one_argument( argument, arg2 );
 
    if ( arg1[0] == '\0' || !is_number( arg1 ) )
    {
        sprintf( log_buf, "Mpoload - Bad syntax: vnum %d name %s short %s.",
                ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
        return;
    }

    if ( ( pObjIndex = get_obj_index( atoi( arg1 ) ) ) == NULL )
    {
        sprintf( log_buf, "Mpoload - Bad vnum arg: vnum %d name %s short %s.",
                ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
	return;
    }

 
    if ( arg2[0] == '\0' )
    {
    	level = pObjIndex->level;
    }
    else
    {
	/*
	 * New feature from Alander.
	 */
        if ( !is_number( arg2 ) )
        {
            sprintf( log_buf, "Mpoload - Bad syntax: vnum %d name %s short %s.",
                     ch->pIndexData->vnum, ch->name, ch->short_descr );
            bug( log_buf, -1 );
	    return;
        }
	level = atoi( arg2 );
	if ( level < 0 || level > get_trust( ch ) )
	{
            sprintf( log_buf, "Mpoload - Bad level: vnum %d name %s short %s.",
                     ch->pIndexData->vnum, ch->name, ch->short_descr );
            bug( log_buf, -1 );
	    return;
	}
    }

    obj = create_object( pObjIndex, level );
    if ( CAN_WEAR(obj, ITEM_TAKE) )
    {
	obj_to_char( obj, ch );
    }
    else
    {
	obj_to_room( obj, ch->in_room );
    }

    return;
}
Exemplo n.º 24
0
Arquivo: org.c Projeto: verias/SRMud
void do_rescind(CHAR_DATA *ch, char *argument )
{	CHAR_DATA *victim;

	char arg[MSL];

	if(IS_NPC(ch) )
		return;
	if(!HAS_ORGANIZATION(ch) )
	{	send_to_char("You aren't organized.\n\r",ch);
		return;
	}
	if( ch->pcdata->rank < RANK_PRIEST )
	{	send_to_char("You cannot rescind peoples ranks!\n\r",ch );
		return;
	}
	one_argument(argument, arg );

	if(arg[0] == '\0' )
	{	send_to_char("Syntax: rescind <person>\n\r",ch);
		return;
	}
	if(!IS_IMMORTAL(ch) )
	{	if( ( victim = get_char_room(ch, NULL, arg) )  == NULL )
		{	send_to_char("They aren't here.\n\r",ch);
			return;
		}
	}
	else
	{	if( ( victim = get_char_world(ch, arg) ) == NULL )
		{	send_to_char("They aren't here.\n\r",ch);
			return;
		}
		
	}
	if(IS_NPC(victim) )
	{	send_to_char("Not on NPC's.\n\r",ch);
		return;
	}
	if(!HAS_ORGANIZATION(victim) )
	{	send_to_char("They aren't organized.\n\r",ch);
		return;
	}
	if(!IS_SAME_ORGANIZATION(ch, victim) && ch->pcdata->rank != RANK_GOD  )
	{	send_to_char("They aren't in your organization!\n\r",ch); 
		return; 
	}

	if( ch->pcdata->rank <= victim->pcdata->rank )
	{	send_to_char("You cannot rescind their rank!\n\r", ch );
		return;
	}

	if(!IS_IMMORTAL(ch) && ch->pcdata->rank <= RANK_PRIEST && victim->pcdata->rank >= RANK_BISHOP )
	{	send_to_char("You cannot rescind their rank.\n\r",ch);
		return;
	}

	if(victim->pcdata->rank == RANK_INITIATE )
	{	send_to_char("They cannot get any lower!\n\r",ch);
		return;
	}
	--victim->pcdata->rank;
	act_new(victim->pcdata->organization->dmt_msg,ch, NULL, victim, TO_VICT, POS_SLEEPING );
	printf_to_char(ch, "You have lowered their rank to %s.\n\r", orgrank_table[victim->pcdata->rank].name );
	return;
}
Exemplo n.º 25
0
void do_mpstat( CHAR_DATA *ch, char *argument )
{
    char        buf[ MAX_STRING_LENGTH ];
    char        arg[ MAX_INPUT_LENGTH  ];
    MPROG_DATA *mprg;
    CHAR_DATA  *victim;

    one_argument( argument, arg );

    if ( arg[0] == '\0' )
    {
	send_to_char( C_DEFAULT, "MobProg stat whom?\n\r", ch );
	return;
    }

    if ( ( victim = get_char_world( ch, arg ) ) == NULL )
    {
	send_to_char( C_DEFAULT,"They aren't here.\n\r", ch );
	return;
    }

    if ( !IS_NPC( victim ) )
    {
	send_to_char(C_DEFAULT, "Only Mobiles can have Programs!\n\r", ch);
	return;
    }

    if ( !( victim->pIndexData->progtypes ) )
    {
	send_to_char(C_DEFAULT, "That Mobile has no Programs set.\n\r", ch);
	return;
    }

    sprintf( buf, "Name: %s.  Vnum: %d.\n\r",
	victim->name, victim->pIndexData->vnum );
    send_to_char(C_DEFAULT, buf, ch );

    sprintf( buf, "Short description: %s.\n\rLong  description: %s",
	    victim->short_descr,
	    victim->long_descr[0] != '\0' ?
	    victim->long_descr : "(none).\n\r" );
    send_to_char(C_DEFAULT, buf, ch );

    sprintf( buf, "Hp: %d/%d(%d).  Mana: %d/%d(%d).  Move: %d/%d(%d).\n\r",
	victim->hit,         victim->perm_hit, MAX_HIT(victim),
	victim->mana,        victim->perm_mana, MAX_MANA(victim),
	victim->move,        victim->perm_move, MAX_MOVE(victim) );
    send_to_char(C_DEFAULT, buf, ch );

  sprintf( buf,
        "Exp: %d.\n\r", victim->exp );
  send_to_char(C_DEFAULT, buf, ch );
  sprintf( buf, "Gold: %d   Silver: %d   Copper: %d.\n\r",
           victim->money.gold, victim->money.silver, victim->money.copper );
  send_to_char(C_DEFAULT, buf, ch ); 
    for ( mprg = victim->pIndexData->mobprogs; mprg != NULL;
	 mprg = mprg->next )
    {
      sprintf( buf, ">%s %s\n\r%s\n\r\n\r",
	      mprog_type_to_name( mprg->type ),
	      mprg->arglist,
	      mprg->comlist );
      send_to_char(C_DEFAULT, buf, ch );
    }

    return;

}
Exemplo n.º 26
0
void do_revoke(CHAR_DATA *ch, char *argument)
{
    int             cmd;
    CHAR_DATA *     victim;
    char            arg1[MAX_INPUT_LENGTH];
    char            arg2[MAX_INPUT_LENGTH];
    char **         newArray=0;
    char **         ar=0;
    char            buf[MAX_STRING_LENGTH];

    argument = one_argument( argument, arg1 );
    argument = one_argument( argument, arg2 );
    
    if(arg1[0]=='\0' || arg2[0]=='\0')
    {
        send_to_char("\n\r{WSyntax:{C revoke {Y<player>{B <command>{x\n\r", ch);
        return;
    }
    
    if((victim=get_char_world(ch, arg1))==NULL)
    {
        send_to_char("\n\r{CThat Player is not online.{x\n\r", ch);
        return;
    }
    
    if(IS_NPC(victim))
    {
    	send_to_char("\n\r{RNot on NPC's.{x\n\r", ch );
    	return;
    }
    
    for(cmd=0;cmd_table[cmd].name[0]!='\0';cmd++)
    {
	   if(!str_prefix(arg2, cmd_table[cmd].name))
           break;
	}
	
	if(cmd_table[cmd].name[0]=='\0')
	{
	   send_to_char("\n\r{RNo valid command found.{x\n\r", ch);
	   return;
	}
	
    if(array_find(victim->pcdata->granted, cmd_table[cmd].name)==-1)
    {
        sprintf(buf, "\n\r{W%s{R has not yet been granted the {W%s{R command!{x\n\r", victim->name, cmd_table[cmd].name);
        send_to_char(buf, ch);
        return;
    }
    
    for(ar=victim->pcdata->granted;ar && *ar;ar++)
    {
        if(strcmp(*ar, cmd_table[cmd].name))
            newArray = array_append(newArray, *ar);
    }
    
    victim->pcdata->granted = array_free(victim->pcdata->granted);
    victim->pcdata->granted = newArray;
    
    sprintf(buf, "\n\r{GCommand {W%s{G was revoked from player {W%s{x\n\r", cmd_table[cmd].name, victim->name);
    send_to_char(buf, ch);
    
    sprintf(buf, "\n\r{GYou have been revoked from using the command: {W%s{x\n\r", cmd_table[cmd].name);
    send_to_char(buf, victim);

    if(array_len(victim->pcdata->granted)==1 && !strcmp(victim->pcdata->granted[0], "wizhelp"))
    {
	    sprintf(buf, "%s wizhelp", victim->name);	do_revoke(ch, buf);
    }    
    
    return;
}
Exemplo n.º 27
0
void do_mpforce( CHAR_DATA *ch, char *argument )
{
    char arg[ MAX_INPUT_LENGTH ];

    if ( !IS_NPC( ch ) )
    {
	typo_message( ch );
	return;
    }

    if ( IS_SET( ch->act , ACT_PET ) || IS_AFFECTED( ch, AFF_CHARM ) )
      return;

    argument = one_argument( argument, arg );

    if ( arg[0] == '\0' || argument[0] == '\0' )
    {
        sprintf( log_buf, "Mpforce - Bad syntax: vnum %d name %s short %s.",
                 ch->pIndexData->vnum, ch->name, ch->short_descr );
        bug( log_buf, -1 );
	return;
    }

    if ( !str_cmp( arg, "all" ) )
    {
        CHAR_DATA *vch;
        CHAR_DATA *vch_next;

	for ( vch = char_list; vch != NULL; vch = vch_next )
	{
	    vch_next = vch->next;

	    if ( vch->in_room == ch->in_room
		&& get_trust( vch ) < get_trust( ch ) 
		&& can_see( ch, vch ) )
	    {
		interpret( vch, argument );
	    }
	}
    }
    else
    {
	CHAR_DATA *victim;

	if ( ( victim = get_char_room( ch, arg ) ) == NULL )
	{
            sprintf( log_buf, "Mpforce - No such victim: vnum %d name %s short %s.",
                     ch->pIndexData->vnum, ch->name, ch->short_descr );
            bug( log_buf, -1 );
	    return;
	}

	if ( victim == ch )
    	{
            sprintf( log_buf, "Mpforce - Forcing oneself: vnum %d name %s short %s.",
                     ch->pIndexData->vnum, ch->name, ch->short_descr );
            bug( log_buf, -1 );
	    return;
	}

	interpret( victim, argument );
    }

    return;
}
Exemplo n.º 28
0
void do_grant(CHAR_DATA *ch, char *argument)
{
    int             cmd;
    CHAR_DATA *     victim;
    char            arg1[MAX_INPUT_LENGTH];
    char            arg2[MAX_INPUT_LENGTH];
    char            buf[MAX_STRING_LENGTH];
    
    argument = one_argument( argument, arg1 );
    argument = one_argument( argument, arg2 );
    
    if(arg1[0]=='\0')
    {
        send_to_char("\n\r{WSyntax:{C grant {Y<player>{B <command>{x\n\r", ch);
        return;
    }
    
    if((victim=get_char_world(ch, arg1))==NULL)
    {
        send_to_char("\n\r{CThat Player is not online.{x\n\r", ch);
        return;
    }
    
    if(IS_NPC(victim))
    {
    	send_to_char("\n\r{RNot on NPC's.{x\n\r", ch );
    	return;
    }
    
    if(arg2[0]=='\0')
    {
        sprintf(buf, "\n\r{CPlayer {W%s{C has been granted the following commands:{x\n\r", victim->name);
        send_to_char(buf, ch);
        show_granted_to_char(victim, ch);
        return;
    }
    
    if(!strcmp(arg2, "builder"))
    {
        sprintf(buf, "%s alist", victim->name);     do_grant(ch, buf);
        sprintf(buf, "%s asave", victim->name);		do_grant(ch, buf);
        sprintf(buf, "%s force", victim->name);		do_grant(ch, buf);
        sprintf(buf, "%s fvlist", victim->name);	do_grant(ch, buf);
        sprintf(buf, "%s goto", victim->name);		do_grant(ch, buf);
        sprintf(buf, "%s grab", victim->name);		do_grant(ch, buf);
        sprintf(buf, "%s hedit", victim->name);		do_grant(ch, buf);
        sprintf(buf, "%s holylight", victim->name);	do_grant(ch, buf);
        sprintf(buf, "%s medit", victim->name);		do_grant(ch, buf);
        sprintf(buf, "%s mlevel", victim->name);	do_grant(ch, buf);
        sprintf(buf, "%s mload", victim->name);		do_grant(ch, buf);
        sprintf(buf, "%s mpedit", victim->name);	do_grant(ch, buf);
        sprintf(buf, "%s msearch", victim->name);	do_grant(ch, buf);
        sprintf(buf, "%s mstat", victim->name);		do_grant(ch, buf);
        sprintf(buf, "%s oedit", victim->name);		do_grant(ch, buf);
        sprintf(buf, "%s oload", victim->name);		do_grant(ch, buf);
        sprintf(buf, "%s olevel", victim->name);	do_grant(ch, buf);
        sprintf(buf, "%s osearch", victim->name);	do_grant(ch, buf);
        sprintf(buf, "%s ostat", victim->name);		do_grant(ch, buf);
        sprintf(buf, "%s otype", victim->name);		do_grant(ch, buf);
        sprintf(buf, "%s peace", victim->name);		do_grant(ch, buf);
        sprintf(buf, "%s purge", victim->name);		do_grant(ch, buf);
        sprintf(buf, "%s redit", victim->name);		do_grant(ch, buf);
        sprintf(buf, "%s resets", victim->name);	do_grant(ch, buf);
        sprintf(buf, "%s rstat", victim->name);		do_grant(ch, buf);
        sprintf(buf, "%s slay", victim->name);		do_grant(ch, buf);
        sprintf(buf, "%s stat", victim->name);		do_grant(ch, buf);
        sprintf(buf, "%s vlist", victim->name);		do_grant(ch, buf);		
        sprintf(buf, "%s vnumlist", victim->name);	do_grant(ch, buf);
    }
    
    for(cmd=0;cmd_table[cmd].name[0]!='\0';cmd++)
    {
	   if(!str_prefix(arg2, cmd_table[cmd].name))
           break;
	}
	
	if(cmd_table[cmd].name[0]=='\0')
	{
	   send_to_char("\n\r{RNo valid command found.{x\n\r", ch);
	   return;
	}
	
	if(strcmp(cmd_table[cmd].name, "wizhelp") && array_find(victim->pcdata->granted, "wizhelp")==-1)
	{
	    sprintf(buf, "%s wizhelp", victim->name);	do_grant(ch, buf);
    }
    	
    if(array_find(victim->pcdata->granted, cmd_table[cmd].name)!=-1)
    {
        sprintf(buf, "\n\r{W%s{R already has the {W%s{R command!{x\n\r", victim->name, cmd_table[cmd].name);
        send_to_char(buf, ch);
        return;
    }
    
    victim->pcdata->granted = array_append(victim->pcdata->granted, cmd_table[cmd].name);

    sprintf(buf, "\n\r{GCommand {W%s{G was granted to player {W%s{x\n\r", cmd_table[cmd].name, victim->name);
    send_to_char(buf, ch);
    
    sprintf(buf, "\n\r{GYou have been granted the command: {W%s{x\n\r", cmd_table[cmd].name);
    send_to_char(buf, victim);
    
    return;
}
Exemplo n.º 29
0
Arquivo: marry.c Projeto: Firehed/RotK
void do_marry( CHAR_DATA *ch, char *argument)
{

    char arg1[MAX_INPUT_LENGTH],arg2[MAX_INPUT_LENGTH];
    CHAR_DATA *husband;
    CHAR_DATA *wife;
    char buf[MAX_STRING_LENGTH];
    
    argument = one_argument( argument, arg1 );
    argument = one_argument( argument, arg2 );

   if ((ch->level >= LEVEL_IMMORTAL))
   { 
    if ( arg1[0] == '\0' || arg2[0] == '\0' )
    {
        send_to_char( "Syntax: marry <char1> <char2>\n\r",ch);
        return;
    }
    if ( ( husband = get_char_world( ch, arg1 ) ) == NULL )
    {
        send_to_char( "The first person mentioned isn't playing.\n\r", ch );
        return;
    }
    
    if ( ( wife = get_char_world( ch, arg2 ) ) == NULL )
    {
	send_to_char( "The second person mentioned isn't playing.\n\r", ch);
	return;
    }
    
    if ( IS_NPC(husband) || IS_NPC(wife))
    {
     send_to_char("I don't think they want to be Married to the mob.\n\r", ch);
     return;
    }        
    
    if (!IS_SET(husband->act, PLR_CONSENT) || !IS_SET(wife->act, PLR_CONSENT))
    {
     send_to_char( "They do not give consent.\n\r", ch);
     return;
    }
    
    if (husband->spouse != NULL || wife->spouse != NULL)
    {
       send_to_char( "They are already married! \n\r", ch);
       return;
    }
   

    send_to_char( "You pronounce them man and wife!\n\r", ch);
    send_to_char( "You say the big 'I do.'\n\r", husband);
    send_to_char( "You say the big 'I do.'\n\r", wife);
        sprintf(buf, "%s", wife->name);
    husband->spouse = buf;
        sprintf(buf, "%s", husband->name);
    wife->spouse = buf;
    return;

   } 
   else
   {
    send_to_char( "You do not have marrying power.\n\r", ch);
    return;
   }
}
Exemplo n.º 30
0
void do_reset( CHAR_DATA *ch, const char *argument )
{
   char arg[MAX_INPUT_LENGTH];

   if( !argument || argument[0] == '\0' )
   {
      send_to_char( "Usage: reset area\r\n", ch );
      send_to_char( "Usage: reset randomize <direction>\r\n", ch );
      send_to_char( "Usage: reset delete <number>\r\n", ch );
      send_to_char( "Usage: reset hide <objname>\r\n", ch );
      send_to_char( "Usage: reset trap room <type> <charges> [flags]\r\n", ch );
      send_to_char( "Usage: reset trap obj <name> <type> <charges> [flags]\r\n", ch );
      return;
   }

   argument = one_argument( argument, arg );
   if( !str_cmp( arg, "area" ) )
   {
      reset_area( ch->in_room->area );
      send_to_char( "Area has been reset.\r\n", ch );
      return;
   }

   // Yeah, I know, this function is mucho ugly... but...
   if( !str_cmp( arg, "delete" ) )
   {
      RESET_DATA *pReset, *tReset, *pReset_next, *tReset_next, *gReset, *gReset_next;
      int num, nfind = 0;

      if( !argument || argument[0] == '\0' )
      {
         send_to_char( "You must specify a reset # in this room to delete one.\r\n", ch );
         return;
      }

      if( !is_number( argument ) )
      {
         send_to_char( "Specified reset must be designated by number. See &Wredit rlist&D.\r\n", ch );
         return;
      }
      num = atoi( argument );

      for( pReset = ch->in_room->first_reset; pReset; pReset = pReset_next )
      {
         pReset_next = pReset->next;

         nfind++;
         if( nfind == num )
         {
            UNLINK( pReset, ch->in_room->first_reset, ch->in_room->last_reset, next, prev );
            delete_reset( pReset );
            send_to_char( "Reset deleted.\r\n", ch );
            return;
         }

         for( tReset = pReset->first_reset; tReset; tReset = tReset_next )
         {
            tReset_next = tReset->next_reset;

            nfind++;
            if( nfind == num )
            {
               UNLINK( tReset, pReset->first_reset, pReset->last_reset, next_reset, prev_reset );
               delete_reset( tReset );
               send_to_char( "Reset deleted.\r\n", ch );
               return;
            }

            for( gReset = tReset->first_reset; gReset; gReset = gReset_next )
            {
               gReset_next = gReset->next_reset;

               nfind++;
               if( nfind == num )
               {
                  UNLINK( gReset, tReset->first_reset, tReset->last_reset, next_reset, prev_reset );
                  delete_reset( gReset );
                  send_to_char( "Reset deleted.\r\n", ch );
                  return;
               }
            }
         }
      }
      send_to_char( "No reset matching that number was found in this room.\r\n", ch );
      return;               
   }

   if( !str_cmp( arg, "random" ) )
   {
      RESET_DATA *pReset;
      int vnum = get_dir( arg );
      argument = one_argument( argument, arg );

      if( vnum < 0 || vnum > 9 )
      {
         send_to_char( "Reset which random doors?\r\n", ch );
         return;
      }

      if( vnum == 0 )
      {
         send_to_char( "There is no point in randomizing one door.\r\n", ch );
         return;
      }

      if( !get_room_index( vnum ) )
      {
         send_to_char( "Target room does not exist.\r\n", ch );
         return;
      }

      pReset = make_reset( 'R', 0, ch->in_room->vnum, vnum, 0 );
      pReset->prev = NULL;
      pReset->next = ch->in_room->first_reset;
      if( ch->in_room->first_reset )
         ch->in_room->first_reset->prev = pReset;
      ch->in_room->first_reset = pReset;
      if( !ch->in_room->last_reset )
         ch->in_room->last_reset = pReset;
      send_to_char( "Reset random doors created.\r\n", ch );
      return;
   }

   if( !str_cmp( arg, "trap" ) )
   {
      RESET_DATA *pReset = NULL, *tReset;
      char oname[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH];
      int num, chrg, value, extra = 0, vnum;

      argument = one_argument( argument, arg2 );

      if( !str_cmp( arg2, "room" ) )
      {
         vnum = ch->in_room->vnum;
         extra = TRAP_ROOM;

         argument = one_argument( argument, arg );
         num = is_number( arg ) ? atoi( arg ) : -1;
         argument = one_argument( argument, arg );
         chrg = is_number( arg ) ? atoi( arg ) : -1;
      }
      else if( !str_cmp( arg2, "obj" ) )
      {
         argument = one_argument( argument, oname );
         if( !( pReset = find_oreset( ch->in_room, oname ) ) )
         {
            send_to_char( "No matching reset found to set a trap on.\r\n", ch );
            return;
         }
         vnum = 0;
         extra = TRAP_OBJ;

         argument = one_argument( argument, arg );
         num = is_number( arg ) ? atoi( arg ) : -1;
         argument = one_argument( argument, arg );
         chrg = is_number( arg ) ? atoi( arg ) : -1;
      }
      else
      {
         send_to_char( "Trap reset must be on 'room' or 'obj'\r\n", ch );
         return;
      }

      if( num < 1 || num > MAX_TRAPTYPE )
      {
         send_to_char( "Invalid trap type.\r\n", ch );
         return;
      }

      if( chrg < 0 || chrg > 10000 )
      {
         send_to_char( "Invalid trap charges. Must be between 1 and 10000.\r\n", ch );
         return;
      }

      while( *argument )
      {
         argument = one_argument( argument, arg );
         value = get_trapflag( arg );
         if( value < 0 || value > 31 )
         {
            ch_printf( ch, "Bad trap flag: %s\r\n", arg );
            continue;
         }
         SET_BIT( extra, 1 << value );
      }
      tReset = make_reset( 'T', extra, num, chrg, vnum );
      if( pReset )
      {
         tReset->prev_reset = NULL;
         tReset->next_reset = pReset->first_reset;
         if( pReset->first_reset )
            pReset->first_reset->prev_reset = tReset;
         pReset->first_reset = tReset;
         if( !pReset->last_reset )
            pReset->last_reset = tReset;
      }
      else
      {
         tReset->prev = NULL;
         tReset->next = ch->in_room->first_reset;
         if( ch->in_room->first_reset )
            ch->in_room->first_reset->prev = tReset;
         ch->in_room->first_reset = tReset;
         if( !ch->in_room->last_reset )
            ch->in_room->last_reset = tReset;
      }
      send_to_char( "Trap created.\r\n", ch );
      return;
   }

   if( !str_cmp( arg, "hide" ) )
   {
      RESET_DATA *pReset = NULL, *tReset;

      if( !( pReset = find_oreset( ch->in_room, argument ) ) )
      {
         send_to_char( "No such object to hide in this room.\r\n", ch );
         return;
      }
      tReset = make_reset( 'H', 1, 0, 0, 0 );
      if( pReset )
      {
         tReset->prev_reset = NULL;
         tReset->next_reset = pReset->first_reset;
         if( pReset->first_reset )
            pReset->first_reset->prev_reset = tReset;
         pReset->first_reset = tReset;
         if( !pReset->last_reset )
            pReset->last_reset = tReset;
      }
      else
      {
         tReset->prev = NULL;
         tReset->next = ch->in_room->first_reset;
         if( ch->in_room->first_reset )
            ch->in_room->first_reset->prev = tReset;
         ch->in_room->first_reset = tReset;
         if( !ch->in_room->last_reset )
            ch->in_room->last_reset = tReset;
      }
      send_to_char( "Hide reset created.\r\n", ch );
      return;
   }
   do_reset( ch, "" );
   return;
}