Example #1
0
void friend_note( CHAR_DATA *ch, char *o_kim, char *co, bool quiet)
{
	FRIEND_LIST *wsk;

	if ( !ch || IS_NPC( ch ) ) return;
	for( wsk = ch->pcdata->friends; wsk; wsk = wsk->next )
	{
		if ( !str_prefix( o_kim, wsk->name ) ) break;
	}
	if ( wsk )
	{
		if ( !wsk->opis ) free( wsk->opis );
		wsk->opis = NULL;
		wsk->opis = strdup( co );
		if ( !quiet )
		{
			switch ( ch->sex )
			{
			case SEX_MALE:
				print_char( ch, "Zapamiêta³e¶ informacje o osobie %s.\n\r", wsk->name );
				break;
			case SEX_FEMALE:
				print_char( ch, "Zapamiêta³a¶ informacje o osobie %s.\n\r", wsk->name );
				break;
			default:
				print_char( ch, "Zapamiêta³e¶ informacje o osobie %s.\n\r", wsk->name );
				break;
			}
			return;
		}
	}
	if ( !quiet ) print_char( ch, "Nie masz znajomego o imieniu %s.\n\r", o_kim );
	return;
}
Example #2
0
/***************************************************************************
 *	cmp_fn_flag
 ***************************************************************************/
bool cmp_fn_flag(long bit, const char * arg, const struct flag_type *	table, struct buf_type * buf)
{
    int iter;

    if (buf != NULL) {
        char flag[MAX_STRING_LENGTH];
        int col = 0;

        add_buf(buf, "\n\r     ");
        for (iter = 0; table[iter].name != NULL; iter++) {
            sprintf(flag, "%-19.18s", table[iter].name);
            add_buf(buf, flag);
            if (++col % 3 == 0)
                add_buf(buf, "\n\r     ");
        }

        if (col % 3 != 0)
            add_buf(buf, "\n\r");
    } else {
        while (isspace((int)*arg) || arg[0] == '=')
            arg++;

        if (is_number(arg)) {
            return IS_SET(bit, parse_long(arg)) > 0;
        } else {
            for (iter = 0; table[iter].name != NULL; iter++)
                if (!str_prefix(arg, table[iter].name))
                    return IS_SET(bit, (long)table[iter].bit) > 0;
        }
    }

    return false;
}
Example #3
0
bool check_ban(char *site,int type)
{
    BAN_DATA *pban;
    char host[MAX_STRING_LENGTH];
    char *p = host;

    strcpy(host,site);

    while (*p != '\0')
    {
        *p = LOWER(*p);
	p++;
    }

    for ( pban = ban_list; pban != NULL; pban = pban->next ) 
    {
	if(!IS_SET(pban->ban_flags,type))
	    continue;

	if (IS_SET(pban->ban_flags,BAN_PREFIX) 
	&&  IS_SET(pban->ban_flags,BAN_SUFFIX)  
	&&  strstr(host, pban->name) != NULL)
	    return TRUE;

	if (IS_SET(pban->ban_flags,BAN_PREFIX)
	&&  !str_suffix(host, pban->name))
	    return TRUE;

	if (IS_SET(pban->ban_flags,BAN_SUFFIX)
	&&  !str_prefix(host, pban->name))
	    return TRUE;
    }

    return FALSE;
}
Example #4
0
void mpedit (CHAR_DATA * ch, char *argument)
{
    MPROG_CODE *pMcode;
    char arg[MAX_INPUT_LENGTH];
    char command[MAX_INPUT_LENGTH];
    int cmd;
    AREA_DATA *ad;

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

    EDIT_MPCODE (ch, pMcode);

    if (pMcode)
    {
        ad = get_vnum_area (pMcode->vnum);

        if (ad == NULL)
        {                        /* ??? */
            edit_done (ch);
            return;
        }

        if (!IS_BUILDER (ch, ad))
        {
            send_to_char ("MPEdit: Insufficient security to modify code.\n\r",
                          ch);
            edit_done (ch);
            return;
        }
    }

    if (command[0] == '\0')
    {
        mpedit_show (ch, argument);
        return;
    }

    if (!str_cmp (command, "done"))
    {
        edit_done (ch);
        return;
    }

    for (cmd = 0; mpedit_table[cmd].name != NULL; cmd++)
    {
        if (!str_prefix (command, mpedit_table[cmd].name))
        {
            if ((*mpedit_table[cmd].olc_fun) (ch, argument) && pMcode)
                if ((ad = get_vnum_area (pMcode->vnum)) != NULL)
                    SET_BIT (ad->area_flags, AREA_CHANGED);
            return;
        }
    }

    interpret (ch, arg);

    return;
}
Example #5
0
void 
read_race_info (void)
{
  FILE *fp;
  int i = 0;
  char wrd[256];
  if ((fp = fopen ("races.dat", "r")) == NULL)
    {
      fprintf (stderr, "Races.dat could not be opened!!\n");
      exit (7);
    }
  for (;;)
    {
      strcpy (wrd, fread_word (fp));
      if (!str_cmp ("END", wrd))
	break;
      if (!str_prefix ("#", wrd))
	{
	  fread_to_eol (fp);
	  continue;
	}
      strcpy (race_info[i].name, wrd);
      race_info[i].bonus[0] = fread_number (fp);
      race_info[i].bonus[1] = fread_number (fp);
      race_info[i].bonus[2] = fread_number (fp);
      race_info[i].bonus[3] = fread_number (fp);
      race_info[i].bonus[4] = fread_number (fp);
      race_info[i].limits[0] = fread_number (fp);
      race_info[i].limits[1] = fread_number (fp);
      race_info[i].limits[2] = fread_number (fp);
      race_info[i].limits[3] = fread_number (fp);
      race_info[i].limits[4] = fread_number (fp);
      race_info[i].start_room = fread_number (fp);
      race_info[i].max_skills = fread_number (fp);
      race_info[i].max_spells = fread_number (fp);
      race_info[i].max_profs = fread_number (fp);
      race_info[i].height_min = fread_number (fp);
      race_info[i].height_max = fread_number (fp);
      race_info[i].affect_bits = fread_number (fp);
      race_info[i].affect_bits2 = fread_number (fp);
      race_info[i].nat_augments = fread_number (fp);
      race_info[i].natarmor = fread_number (fp);
      race_info[i].regen_hit_percent = fread_number (fp);
      race_info[i].regen_move_percent = fread_number (fp);
      race_info[i].switch_aligns = fread_number (fp); 
      race_info[i].attack_spell_percent = fread_number (fp);
      race_info[i].combat_damage_bonus = fread_number (fp);
      race_info[i].backstab_percent = fread_number (fp);
      race_info[i].heal_percent = fread_number (fp);
      race_info[i].hps_bonus = fread_number (fp);
      race_info[i].mana_percent = fread_number (fp);
      race_info[i].nat_skills[0] = fread_number(fp);
      race_info[i].nat_skills[1] = fread_number(fp);
      race_info[i].nat_skills[2] = fread_number(fp);
      race_info[i].remort_race = fread_number (fp);
      i++;
    }
  fclose (fp);
  return;
}
Example #6
0
bool rp_input_trigger( CHAR_DATA *ch, char * string )
{
	char buf[ MAX_STRING_LENGTH ];
	PROG_LIST *prg;

	for ( prg = ch->in_room->progs; prg != NULL; prg = prg->next )
	{
		if ( prg->trig_type == &TRIG_INPUT )
		{
			if ( prg->trig_phrase[ 0 ] == '@' )
			{
				sprintf( buf, "%s\n", string );
				if ( !regexp_match( prg->trig_phrase + 1, buf ) )
					continue;
			}
			else if ( prg->trig_phrase[ 0 ] == '*' )
			{
				if ( str_prefix( string, prg->trig_phrase + 1 ) )
					continue;
			}
			else
			{
				if ( str_cmp( string, prg->trig_phrase ) )
					continue;
			}

			rset_supermob( ch->in_room );
			create_rprog_env( prg->name, prg->code, ch->in_room, ch, NULL, NULL, prg->trig_type, string );
			program_flow();
			release_supermob();
			return ( TRUE );
		}
	}
	return ( FALSE );
}
Example #7
0
bool check_ban( DESCRIPTOR_DATA *d, int type )
{
    BAN_DATA *pban;
    char host[MAX_STRING_LENGTH];

    strcpy(host,capitalize(d->host));
    host[0] = LOWER(host[0]);

    for ( pban = ban_list; pban != NULL; pban = pban->next ) 
    {
	if( !IS_SET(pban->ban_flags, type) )
	    continue;

	if ( IS_SET(pban->ban_flags, BAN_USER)
	&&   str_cmp(pban->user, d->ident) )
	    continue;

	if (IS_SET(pban->ban_flags,BAN_PREFIX) 
	&&  IS_SET(pban->ban_flags,BAN_SUFFIX)  
	&&  strstr(pban->host,host) != NULL)
	    return TRUE;

	if (IS_SET(pban->ban_flags,BAN_PREFIX)
	&&  !str_suffix(pban->host,host))
	    return TRUE;

	if (IS_SET(pban->ban_flags,BAN_SUFFIX)
	&&  !str_prefix(pban->host,host))
	    return TRUE;
    }

    return FALSE;
}
Example #8
0
void bsedit( CHAR_DATA *ch, char *argument )
{
	BONUS_INDEX_DATA * pBonus;
	char arg[ MAX_INPUT_LENGTH ];
	char command[ MAX_INPUT_LENGTH ];
	int cmd;
	AREA_DATA *ad;

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

	EDIT_BSDATA( ch, pBonus );

	if ( pBonus )
	{
		ad = get_vnum_area( pBonus->vnum );

		if ( ad == NULL )
		{
			edit_done( ch );
			return ;
		}

		if ( !IS_BUILDER( ch, ad ) )
		{
			send_to_char( "BSEdit: Masz niewystarczaj±ce security.\n\r", ch );
			edit_done( ch );
			return ;
		}
	}

	if ( command[ 0 ] == '\0' )
	{
		bsedit_show( ch, argument );
		return ;
	}

	if ( !str_cmp( command, "done" ) )
	{
		edit_done( ch );
		return ;
	}

	for ( cmd = 0; bsedit_table[ cmd ].name != NULL; cmd++ )
	{
		if ( !str_prefix( command, bsedit_table[ cmd ].name ) )
		{
			if ( ( *bsedit_table[ cmd ].olc_fun ) ( ch, argument ) && pBonus )
				if ( ( ad = get_vnum_area( pBonus->vnum ) ) != NULL )
					SET_BIT( ad->area_flags, AREA_CHANGED );
			return ;
		}
	}

	interpret( ch, arg );
	return ;
}
Example #9
0
void rdedit( CHAR_DATA *ch, char *argument)
{
    RAND_DESC_DATA *pDdata;
    char arg[MAX_INPUT_LENGTH];
    char command[MAX_INPUT_LENGTH];
    int cmd;
    AREA_DATA *ad;

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

    EDIT_RDESCDATA(ch, pDdata);

    if (pDdata)
    {
        ad = get_vnum_area( pDdata->vnum );

        if ( ad == NULL )
        {
            edit_done(ch);
            return;
        }

        if ( !IS_BUILDER(ch, ad) )
        {
            send_to_char("DescEdit: Brak praw dostêpu.\n\r", ch);
            edit_done(ch);
            return;
        }
    }

    if (command[0] == '\0')
    {
        rdedit_show(ch, argument);
        return;
    }

    if (!str_cmp(command, "done") )
    {
        edit_done(ch);
        return;
    }

    for (cmd = 0; rdedit_table[cmd].name != NULL; cmd++)
    {
        if (!str_prefix(command, rdedit_table[cmd].name) )
        {
            if ((*rdedit_table[cmd].olc_fun) (ch, argument) && pDdata)
                if ((ad = get_vnum_area(pDdata->vnum)) != NULL)
                    SET_BIT(ad->area_flags, AREA_CHANGED);
            return;
        }
    }

    interpret(ch, arg);
    return;
}
Example #10
0
static void do_subscribe(USER *u, const char *arg) {
    MANAGER *m = u->manager;
    INSTANCE *ins = m->instance_find(u->get_id());
    if (!ins || !ins->user) return;

    std::string name;
    u->fetch_tag(&name);
    int subscribed = ins->vs.geti("subscribed");

    if (*arg == 0) {
        ins->vs.set("subscribed", 0);

        INSTANCE *subscribed_ins;
        if ( (subscribed_ins = m->instance_find(subscribed)) ) {
            std::string subscribed_tag;
            subscribed_ins->user->fetch_tag(&subscribed_tag);
            u->sendf("You are no longer subscribed to %s's broadcast.\n\r", subscribed_tag.c_str());
            subscribed_ins->user->sendf("%s is no longer subscribed to your broadcast.\n\r", name.c_str());
        }
        else u->send("Subscribe to whose broadcast?\n\r");
        return;
    }

    if (strlen(ins->vs.gets("team")) == 0) {
        u->send("You cannot subscribe unless you are in a team.\n\r");
        return;
    }

    bool found = false;
    VARSET find_vs;
    find_vs.set("team", ins->vs.gets("team"));
    std::set<int> members;
    m->instance_find("user", (const VARSET *) &find_vs, &members);
    for (auto member_id : members) {
        if (member_id == u->get_id()) continue;
        INSTANCE *ins_member = m->instance_find(member_id);
        std::string member_name;
        ins_member->user->fetch_tag(&member_name);
        if (str_prefix(arg, member_name.c_str())) {
            if (member_id == subscribed) {
                u->sendf("You have already subscribed to %s's broadcast.\n\r", member_name.c_str());
            }
            else {
                ins_member->user->sendf("%s subscribed to your broadcast.\n\r", name.c_str());
                u->sendf("You are now subscribed to %s's broadcast.\n\r", member_name.c_str());
                ins->vs.set("subscribed", member_id);
                INSTANCE *old_subscribe = m->instance_find(subscribed);
                if (old_subscribe) old_subscribe->user->sendf("%s is no longer subscribed to your broadcast.\n\r", name.c_str());
            }
            found = true;
            break;
        }
    }

    if (!found) {
        u->send("No such user is in a team with you.\n\r");
    }
}
Example #11
0
bool is_logged(const char * command) {
    for (size_t i=0; ; ++i) {
        if (fun_table[i].name == nullptr) break;
        if (str_prefix(command, fun_table[i].name)) {
            return fun_table[i].logging;
        }
    }
    return false;
}
Example #12
0
bool check_illegal(char *name)
{
    ILLEGAL_DATA *p;

    for (p = illegal_first; p; p = p->next) {
	if (p->mode == '#') {
	    if (!str_cmp(name, p->word) || is_name(name, p->word) || is_exact_name(name, p->word))
		return TRUE;
	} else if (p->mode == '@') {
	    if (!str_prefix(p->word, name))
		return TRUE;
	} else if (p->mode == '$') {
	    if (!str_cmp(name, p->word) || is_exact_name(name, p->word) || is_name(name, p->word) ||
		!str_infix(name, p->word) || !str_prefix(p->word, name) || strstr(name, p->word))
		return TRUE;
	}
    }
    return FALSE;
}
Example #13
0
void hedit( CHAR_DATA *ch, char *argument)
{
    HELP_DATA * pHelp;
    HELP_AREA *had;
    char arg[MAX_INPUT_LENGTH];
    char command[MAX_INPUT_LENGTH];
    int cmd;

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

    EDIT_HELP(ch, pHelp);

    had = get_help_area(pHelp);

    if (had == NULL)
    {
    	bugf( "hedit : had para help %s NULL", pHelp->keyword );
    	edit_done(ch);
    	return;
    }

    if (ch->pcdata->security < 9)
    {
        send_to_char("HEdit: Insuficiente seguridad para editar help.\n\r",ch);
	edit_done(ch);
	return;
    }

    if (command[0] == '\0')
    {
	hedit_show(ch, argument);
        return;
    }

    if (!str_cmp(command, "done") )
    {
        edit_done(ch);
        return;
    }

    for (cmd = 0; hedit_table[cmd].name != NULL; cmd++)
    {
	if (!str_prefix(command, hedit_table[cmd].name) )
	{
		if ((*hedit_table[cmd].olc_fun) (ch, argument))
			had->changed = TRUE;
		return;
	}
    }

    interpret(ch, arg);
    return;
}
Example #14
0
/* Room Interpreter, called by do_redit. */
void redit (CHAR_DATA * ch, char *argument)
{
    AREA_DATA *pArea;
    ROOM_INDEX_DATA *pRoom;
    char arg[MAX_STRING_LENGTH];
    char command[MAX_INPUT_LENGTH];
    int cmd;

    EDIT_ROOM (ch, pRoom);
    pArea = pRoom->area;

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

    if (!IS_BUILDER (ch, pArea))
    {
        send_to_char ("REdit:  Insufficient security to modify room.\n\r",
                      ch);
        edit_done (ch);
        return;
    }

    if (!str_cmp (command, "done"))
    {
        edit_done (ch);
        return;
    }

    if (command[0] == '\0')
    {
        redit_show (ch, argument);
        return;
    }

    /* Search Table and Dispatch Command. */
    for (cmd = 0; redit_table[cmd].name != NULL; cmd++)
    {
        if (!str_prefix (command, redit_table[cmd].name))
        {
            if ((*redit_table[cmd].olc_fun) (ch, argument))
            {
                SET_BIT (pArea->area_flags, AREA_CHANGED);
                return;
            }
            else
                return;
        }
    }

    /* Default to Standard Interpreter. */
    interpret (ch, arg);
    return;
}
Example #15
0
const Forge::WeaponInfo * Forge::LookupWeapon(const char * name)
{
    // Look for a name prefix match
    for (WeaponMap::const_iterator iter(Weapons().begin()); iter != Weapons().end(); ++iter)
    {
        if (!str_prefix(name, iter->second.name.c_str()))
            return &iter->second;
    }

    return NULL;
}
Example #16
0
int size_lookup (const char *name) {
  int size;
 
  for ( size = 0; size_table[size].name != NULL; size++) {
    if (LOWER(name[0]) == LOWER(size_table[size].name[0])
        &&  !str_prefix( name,size_table[size].name))
      return size;
  }
 
  return -1;
}
Example #17
0
int position_lookup (const char *name) {
  int pos;

  for (pos = 0; position_table[pos].name != NULL; pos++) {
    if (LOWER(name[0]) == LOWER(position_table[pos].name[0])
	&&  !str_prefix(name,position_table[pos].name))
      return pos;
  }
   
  return -1;
}
Example #18
0
int sex_lookup (const char *name) {
  int sex;
   
  for (sex = 0; sex_table[sex].name != NULL; sex++) {
    if (LOWER(name[0]) == LOWER(sex_table[sex].name[0])
	&&  !str_prefix(name,sex_table[sex].name))
      return sex;
  }

  return -1;
}
Example #19
0
/*
 * Lookup an ability by name.
 */
int ability_lookup( const char *name, const int from = 0 ) {
  for ( int sn = from; sn < MAX_ABILITY; sn++ ) {
    if ( ability_table[sn].name == NULL )
      break;
    if ( LOWER(name[0]) == LOWER(ability_table[sn].name[0])
	 &&   !str_prefix( name, ability_table[sn].name ) )
      return sn;
  }

  return -1;
}
Example #20
0
int flag_lookup (const char *name, struct flag_type *flag_table) {
  int flag;

  for (flag = 0; flag_table[flag].name != NULL; flag++) {
    if (LOWER(name[0]) == LOWER(flag_table[flag].name[0])
	&&  !str_prefix(name,flag_table[flag].name))
      return flag_table[flag].bit;
  }

  return 0;
}
Example #21
0
/* returns a flag for wiznet */
long wiznet_lookup (const char *name) {
  int flag;

  for (flag = 0; wiznet_table[flag].name != NULL; flag++) {
    if (LOWER(name[0]) == LOWER(wiznet_table[flag].name[0])
	&& !str_prefix(name,wiznet_table[flag].name))
      return flag;
  }

  return -1;
}
Example #22
0
// Added by SinaC 2001
// returns god number
int god_lookup (const char *name) {
  int god;

  for ( god = 0; god < MAX_GODS; god++) {
    if (LOWER(name[0]) == LOWER(gods_table[god].name[0])
	&&  !str_prefix( name,gods_table[god].name))
      return god;
  }

  return -1;
} 
Example #23
0
int item_lookup(const char *name) {
  int type;

  for (type = 0; item_table[type].name != NULL; type++) {
    if (LOWER(name[0]) == LOWER(item_table[type].name[0])
	&&  !str_prefix(name,item_table[type].name))
      return item_table[type].type;
  }
 
  return -1;
}
Example #24
0
int attack_lookup  (const char *name) {
  int att;

  for ( att = 0; attack_table[att].name != NULL; att++) {
    if (LOWER(name[0]) == LOWER(attack_table[att].name[0])
	&&  !str_prefix(name,attack_table[att].name))
      return att;
  }

  return 0;
}
Example #25
0
int weapon_lookup (const char *name) {
  int type;

  for (type = 0; weapon_table[type].name != NULL; type++) {
    if (LOWER(name[0]) == LOWER(weapon_table[type].name[0])
	&&  !str_prefix(name,weapon_table[type].name))
      return type;
  }
 
  return -1;
}
Example #26
0
bool check_adr(char *site,int type)
{
    char bans[MAX_STRING_LENGTH];
    char host[MAX_STRING_LENGTH];

    strcpy(host,capitalize(site));
    host[0] = LOWER(host[0]);

    if ( (strstr(bans,host) != NULL)
    ||  !str_suffix(bans,host)
    ||  !str_prefix(bans,host) )
	    return TRUE;

    if ( (strstr(bans,host) != NULL)
    ||  !str_suffix(bans,host)
    ||  !str_prefix(bans,host) )
	    return TRUE;

    return FALSE;
}
Example #27
0
int ore_lookup(const char *name)
{
	int ore;

	for (ore = 0; smith_ores_table[ore].name != NULL; ore++)
	{
		if (LOWER(name[0]) == LOWER(smith_ores_table[ore].name[0])
			&& !str_prefix(name,smith_ores_table[ore].name))
			return ore;
	}
	return -1;
}
Example #28
0
void area_editor(Client *conn, const char *argument)
{
    char arg[100];
    argument = one_argument(argument, arg);

    if (!str_prefix(arg, "show"))
    {
        conn->editing->show(conn);
        return;
    }

    if (!str_cmp(arg, "Q"))
    {
        finish_editing(conn);
        return;
    }

    if (!str_cmp(arg, "list"))
    {
        area_edit_list(conn);
        return;
    }
    Area *area = (Area *) conn->editing->data;

    if (!str_cmp(arg, "save"))
    {
        save_area(area);
        xwriteln(conn, "~CArea saved.~x");
        return;
    }

    if (!str_cmp(arg, "A") || !str_cmp(arg, "name"))
    {

        if (!argument || !*argument)
        {
            xwriteln(conn, "~CYou must provide a name to set.~x");
            return;
        }
        free_str_dup(&area->name, argument);
        conn->editing->show(conn);
        return;
    }

    if (!str_cmp(arg, "B") || !str_cmp(arg, "flags"))
    {

        if (edit_flag("flags", conn, area->flags, argument, area_flags)) {
            conn->editing->show(conn);
        }
        return;
    }
}
Example #29
0
int clan_lookup(const char *name)
{
    int clan;

    for (clan = 0; clan < MAX_CLAN; clan++)
    {
	if (!str_prefix(name, clan_table[clan].name))
	    return clan;
    }

    return 0;
} /* end: clan_lookup */
Example #30
0
int smith_item_lookup(const char *name)
{
	int item;

	for (item = 0; smith_items_table[item].name != NULL; item++)
	{
		if (LOWER(name[0]) == LOWER(smith_items_table[item].name[0])
			&& !str_prefix(name,smith_items_table[item].name))
			return item;
	}
	return -1;
}