Esempio n. 1
0
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);
}
Esempio n. 2
0
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[MSL]={'\0'};
	char title[MSL]={'\0'};
	BUFFER *buffer;
	int level = 0;
	WIZ_DATA *pwiz;
	int lngth = 0;
	int amt = 0;
	bool found;

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

	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 Dungeon World");
	sprintf(buf,"___________________________________________________________________________\n\r");
	add_buf(buffer,buf);
	sprintf(buf," /\\_\\%70s\\_\\\n\r", " ");
	add_buf(buffer,buf);
	lngth = (70 - strlen(title))/2;
	for( ; lngth >= 0; lngth--)
	{
		strcat(title, " ");
	}
	sprintf(buf,"|/\\\\_\\\tW%70s\tn\\_\\\n\r", title);
	add_buf(buffer,buf);
	sprintf(buf,"\\_/_|_|%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," ___|_|%69s|_|\n\r", " ");
				add_buf(buffer,buf);
			}
			continue;
		}
		sprintf(buf," |_|%37s [%d]%30s|_|\n\r", wiz_titles[IMPLEMENTOR-level], level, " ");
		add_buf(buffer,buf);
		sprintf(buf," |_|\tY%25s******************\tn%29s|_|\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, " |_|%12s%-23s ", pwiz->name, " ");
						add_buf(buffer, buf);
						lngth = 1;
					} 
					else if (amt > 1)
					{
						sprintf(buf, " |_|%21s%-23s ", pwiz->name, " ");
						add_buf(buffer, buf);
						lngth = 1;
					} 
					else
					{
						sprintf(buf, " |_|%30s%-42s|_|\n\r", pwiz->name, " ");
						add_buf(buffer, buf);
						lngth = 0;
					}
				} 
				else if (lngth == 1)
				{
					if (amt > 2)
					{
						sprintf(buf, "%-23s ", pwiz->name);
						add_buf(buffer, buf);
						lngth = 2;
					} 
					else
					{
						sprintf(buf, "%-30s|_|\n\r", pwiz->name);
						add_buf(buffer, buf);
						lngth = 0;
					}
				} 
				else
				{
					sprintf(buf, "%-21s|_|\n\r", pwiz->name);
					add_buf(buffer, buf);
					lngth = 0;
					amt -= 3;
				}
			}
		}
		if (level == HERO+1)
		{
			sprintf(buf," ___|_|%72s|_|\n\r", " ");
		} 
		else
		{
			sprintf(buf," |_|%72s|_|\n\r", " ");
		}
		add_buf(buffer,buf);
	}
	sprintf(buf,"/ \\ |_|%69s|_|\n\r", " ");
	add_buf(buffer,buf);
	sprintf(buf,"|\\//_/%70s/_/\n\r", " ");
	add_buf(buffer,buf);
	sprintf(buf," \\/_/______________________________________________________________________/_/\n\r");
	add_buf(buffer,buf);
	page_to_char( buf_string(buffer), ch );
	free_buf(buffer);
	return;
}
Esempio n. 3
0
File: sign.c Progetto: Firehed/RotK
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;
}
Esempio n. 4
0
//********************KONIEC PRZYTRZYMUJACYCH*******************//
//to jest do_owhere() tylko zmodyfikowany na potrzeby do_astat()
void awhere( CHAR_DATA *ch, char *argument )
{
	char buf[ MAX_INPUT_LENGTH ];
	BUFFER *buffer = NULL;
	OBJ_DATA *obj;
	OBJ_DATA *in_obj;
	bool found;
	int vnum = -1;

	found = FALSE;

	buffer = new_buf();

	if ( argument[ 0 ] == '\0' )
	{
		send_to_char( "Find what?\n\r", ch );
		return ;
	}

	if ( is_number( argument ) )
		vnum = atoi( argument );

	for ( obj = object_list; obj != NULL; obj = obj->next )
	{
		if ( vnum > 0 )
		{
			if ( !can_see_obj( ch, obj ) || obj->pIndexData->vnum != vnum )
				continue;
		}
		else
		{
			if ( !can_see_obj( ch, obj ) || !is_name( argument, obj->name ) )
				continue;
		}

		found = TRUE;

		for ( in_obj = obj; in_obj->in_obj != NULL; in_obj = in_obj->in_obj );

		if ( in_obj->carried_by != NULL && can_see( ch, in_obj->carried_by )
		     && in_obj->carried_by->in_room != NULL )
			sprintf( buf, " %s jest noszone przez %s [Room %d]\n\r",
			         obj->short_descr, PERS( in_obj->carried_by, ch ),
			         in_obj->carried_by->in_room->vnum );
		else if ( in_obj->in_room != NULL && can_see_room( ch, in_obj->in_room ) )
			sprintf( buf, " %s jest w %s [Room %d]\n\r",
			         obj->short_descr, in_obj->in_room->name,
			         in_obj->in_room->vnum );
		else
			sprintf( buf, " %s jest gdzies\n\r", obj->short_descr );

		sprintf( buf, "%s", capitalize( buf ) );
		add_buf( buffer, buf );

	}

	if ( !found )
		send_to_char( "	Niczego takiego nie ma aktualnie w grze.\n\r", ch );
	else
		page_to_char( buf_string( buffer ), ch );

	free_buf( buffer );
}
Esempio n. 5
0
int hostapd_build_ap_extra_ies(struct hostapd_data *hapd,
			       struct wpabuf **beacon_ret,
			       struct wpabuf **proberesp_ret,
			       struct wpabuf **assocresp_ret)
{
	struct wpabuf *beacon = NULL, *proberesp = NULL, *assocresp = NULL;
	u8 buf[200], *pos;

	*beacon_ret = *proberesp_ret = *assocresp_ret = NULL;

	pos = buf;
	pos = hostapd_eid_time_adv(hapd, pos);
	if (add_buf_data(&beacon, buf, pos - buf) < 0)
		goto fail;
	pos = hostapd_eid_time_zone(hapd, pos);
	if (add_buf_data(&proberesp, buf, pos - buf) < 0)
		goto fail;

	pos = buf;
	pos = hostapd_eid_ext_capab(hapd, pos);
	if (add_buf_data(&assocresp, buf, pos - buf) < 0)
		goto fail;
	pos = hostapd_eid_interworking(hapd, pos);
	pos = hostapd_eid_adv_proto(hapd, pos);
	pos = hostapd_eid_roaming_consortium(hapd, pos);
	if (add_buf_data(&beacon, buf, pos - buf) < 0 ||
	    add_buf_data(&proberesp, buf, pos - buf) < 0)
		goto fail;

#ifdef CONFIG_FST
	if (add_buf(&beacon, hapd->iface->fst_ies) < 0 ||
	    add_buf(&proberesp, hapd->iface->fst_ies) < 0 ||
	    add_buf(&assocresp, hapd->iface->fst_ies) < 0)
		goto fail;
#endif /* CONFIG_FST */

	if (add_buf(&beacon, hapd->wps_beacon_ie) < 0 ||
	    add_buf(&proberesp, hapd->wps_probe_resp_ie) < 0)
		goto fail;

#ifdef CONFIG_P2P
	if (add_buf(&beacon, hapd->p2p_beacon_ie) < 0 ||
	    add_buf(&proberesp, hapd->p2p_probe_resp_ie) < 0)
		goto fail;
#endif /* CONFIG_P2P */

#ifdef CONFIG_P2P_MANAGER
	if (hapd->conf->p2p & P2P_MANAGE) {
		if (wpabuf_resize(&beacon, 100) == 0) {
			u8 *start, *p;
			start = wpabuf_put(beacon, 0);
			p = hostapd_eid_p2p_manage(hapd, start);
			wpabuf_put(beacon, p - start);
		}

		if (wpabuf_resize(&proberesp, 100) == 0) {
			u8 *start, *p;
			start = wpabuf_put(proberesp, 0);
			p = hostapd_eid_p2p_manage(hapd, start);
			wpabuf_put(proberesp, p - start);
		}
	}
#endif /* CONFIG_P2P_MANAGER */

#ifdef CONFIG_WPS
	if (hapd->conf->wps_state) {
		struct wpabuf *a = wps_build_assoc_resp_ie();
		add_buf(&assocresp, a);
		wpabuf_free(a);
	}
#endif /* CONFIG_WPS */

#ifdef CONFIG_P2P_MANAGER
	if (hapd->conf->p2p & P2P_MANAGE) {
		if (wpabuf_resize(&assocresp, 100) == 0) {
			u8 *start, *p;
			start = wpabuf_put(assocresp, 0);
			p = hostapd_eid_p2p_manage(hapd, start);
			wpabuf_put(assocresp, p - start);
		}
	}
#endif /* CONFIG_P2P_MANAGER */

#ifdef CONFIG_WIFI_DISPLAY
	if (hapd->p2p_group) {
		struct wpabuf *a;
		a = p2p_group_assoc_resp_ie(hapd->p2p_group, P2P_SC_SUCCESS);
		add_buf(&assocresp, a);
		wpabuf_free(a);
	}
#endif /* CONFIG_WIFI_DISPLAY */

#ifdef CONFIG_HS20
	pos = hostapd_eid_hs20_indication(hapd, buf);
	if (add_buf_data(&beacon, buf, pos - buf) < 0 ||
	    add_buf_data(&proberesp, buf, pos - buf) < 0)
		goto fail;

	pos = hostapd_eid_osen(hapd, buf);
	if (add_buf_data(&beacon, buf, pos - buf) < 0 ||
	    add_buf_data(&proberesp, buf, pos - buf) < 0)
		goto fail;
#endif /* CONFIG_HS20 */

#ifdef CONFIG_MBO
	if (hapd->conf->mbo_enabled) {
		pos = hostapd_eid_mbo(hapd, buf, sizeof(buf));
		if (add_buf_data(&beacon, buf, pos - buf) < 0 ||
		    add_buf_data(&proberesp, buf, pos - buf) < 0 ||
		    add_buf_data(&assocresp, buf, pos - buf) < 0)
			goto fail;
	}
#endif /* CONFIG_MBO */

	add_buf(&beacon, hapd->conf->vendor_elements);
	add_buf(&proberesp, hapd->conf->vendor_elements);

	*beacon_ret = beacon;
	*proberesp_ret = proberesp;
	*assocresp_ret = assocresp;

	return 0;

fail:
	wpabuf_free(beacon);
	wpabuf_free(proberesp);
	wpabuf_free(assocresp);
	return -1;
}
Esempio n. 6
0
File: send.c Progetto: verias/SRMud
void do_tell( CHAR_DATA *ch, char *argument )
{
    char arg[MAX_INPUT_LENGTH],buf[MAX_STRING_LENGTH];
    CHAR_DATA *victim;

    if ( IS_SET(ch->comm, COMM_NOTELL) || IS_SET(ch->comm,COMM_DEAF))
    {
	send_to_char( "Your message didn't get through.\n\r", ch );
	return;
    }

    if ( IS_SET(ch->comm, COMM_QUIET) )
    {
	send_to_char( "You must turn off quiet mode first.\n\r", ch);
	return;
    }

    if (IS_SET(ch->comm,COMM_DEAF))
    {
	send_to_char("You must turn off deaf mode first.\n\r",ch);
	return;
    }

    argument = one_argument( argument, arg );

    if ( arg[0] == '\0' || argument[0] == '\0' )
    {
	send_to_char( "Tell whom what?\n\r", ch );
	return;
    }

    /*
     * Can tell to PC's anywhere, but NPC's only in same room.
     * -- Furey
     */
    if ( ( victim = get_char_world( ch, arg ) ) == NULL
    || ( IS_NPC(victim) && victim->in_room != ch->in_room ) )
    {
	send_to_char( "They aren't here.\n\r", ch );
	return;
    }

    if ( victim->desc == NULL && !IS_NPC(victim))
    {
	act("$N seems to have misplaced $S link...try again later.",
	    ch,NULL,victim,TO_CHAR);
        sprintf(buf,"{k%s tells you '{K%s{k'{x\n\r",PERS(ch,victim),argument);
        buf[0] = UPPER(buf[0]);
        add_buf(victim->pcdata->buffer,buf);
	return;
    }

    if ( !(IS_IMMORTAL(ch) && ch->level > LEVEL_IMMORTAL) && !IS_AWAKE(victim) )
    {
	act( "$E can't hear you.", ch, 0, victim, TO_CHAR );
	return;
    }
  
    if ((IS_SET(victim->comm,COMM_QUIET) || IS_SET(victim->comm,COMM_DEAF))
    && !IS_IMMORTAL(ch))
    {
	act( "$E is not receiving tells.", ch, 0, victim, TO_CHAR );
  	return;
    }

    if (IS_SET(victim->comm,COMM_AFK))
    {
	if (IS_NPC(victim))
	{
	    act("$E is AFK, and not receiving tells.",ch,NULL,victim,TO_CHAR);
	    return;
	}

	act("$E is AFK, but your tell will go through when $E returns.",
	    ch,NULL,victim,TO_CHAR);
	sprintf(buf,"{k%s tells you '{K%s{k'{x\n\r",PERS(ch,victim),argument);
	buf[0] = UPPER(buf[0]);
	add_buf(victim->pcdata->buffer,buf);
	return;
    }

    act( "{kYou tell $N '{K$t{k'{x", ch, argument, victim, TO_CHAR );
    act_new("{k$n tells you '{K$t{k'{x",ch,argument,victim,TO_VICT,POS_DEAD);
    victim->reply	= ch;

	if (!IS_NPC(ch) && IS_NPC(victim)&& HAS_TRIGGER_MOB(victim,TRIG_SPEECH) )
		p_act_trigger( argument, victim, NULL, NULL, ch, NULL, NULL, TRIG_SPEECH);

    return;
}
Esempio n. 7
0
File: send.c Progetto: verias/SRMud
void do_reply( CHAR_DATA *ch, char *argument )
{
    CHAR_DATA *victim;
    char buf[MAX_STRING_LENGTH];

    if ( IS_SET(ch->comm, COMM_NOTELL) )
    {
	send_to_char( "Your message didn't get through.\n\r", ch );
	return;
    }

    if ( ( victim = ch->reply ) == NULL )
    {
	send_to_char( "They aren't here.\n\r", ch );
	return;
    }

    if ( victim->desc == NULL && !IS_NPC(victim))
    {
        act("$N seems to have misplaced $S link...try again later.",
            ch,NULL,victim,TO_CHAR);
        sprintf(buf,"{k%s tells you '{K%s{k'{x\n\r",PERS(ch,victim),argument);
        buf[0] = UPPER(buf[0]);
        add_buf(victim->pcdata->buffer,buf);
        return;
    }

    if ( !IS_IMMORTAL(ch) && !IS_AWAKE(victim) )
    {
	act( "$E can't hear you.", ch, 0, victim, TO_CHAR );
	return;
    }

    if ((IS_SET(victim->comm,COMM_QUIET) || IS_SET(victim->comm,COMM_DEAF))
    &&  !IS_IMMORTAL(ch) && !IS_IMMORTAL(victim))
    {
        act_new( "$E is not receiving tells.", ch, 0, victim, TO_CHAR,POS_DEAD);
        return;
    }

    if (!IS_IMMORTAL(victim) && !IS_AWAKE(ch))
    {
	send_to_char( "In your dreams, or what?\n\r", ch );
	return;
    }

    if (IS_SET(victim->comm,COMM_AFK))
    {
        if (IS_NPC(victim))
        {
            act_new("$E is AFK, and not receiving tells.",
		ch,NULL,victim,TO_CHAR,POS_DEAD);
            return;
        }
 
        act_new("$E is AFK, but your tell will go through when $E returns.",
            ch,NULL,victim,TO_CHAR,POS_DEAD);
        sprintf(buf,"{k%s tells you '{K%s{k'{x\n\r",PERS(ch,victim),argument);
	buf[0] = UPPER(buf[0]);
        add_buf(victim->pcdata->buffer,buf);
        return;
    }

    act_new("{kYou tell $N '{K$t{k'{x",ch,argument,victim,TO_CHAR,POS_DEAD);
    act_new("{k$n tells you '{K$t{k'{x",ch,argument,victim,TO_VICT,POS_DEAD);
    victim->reply	= ch;

    return;
}
Esempio n. 8
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;
}