This is version 3.1. Mostly just bug fixes. And in my prior snippet I forgot some code.

Ooook. Where do I start now. This is a major overhall from my prior Channel snippet (Version 2) This one is slightly
more advanced in someways. Still got your socials, smotes, echos, emotes, and what have you. Now I added a few new
functions to add more flexability to them, such as a better way of handling the channel name (No more repeditive code for me!).
And I have added social-emotes. Basicly you just type "ooc #grin I love you all. Be mine!" and it shows up "[OOC]
Davion grins, saying 'I love you all. Be mine!'" Its quite a wonderful feature. But to have that I threw in a new
bit to the socials, called chan_emote, and I shall also include Erwin S. Andreasen snippet for socials, slightly
modified mind you (Just the saving and loading parts). Now. To install this, do as followed.

Install Erwin's social editer snippet. Follow his lead! Just replace his social-edit.c
with my sedit.c file. If you already have it installed. Just replace the file and
remove the #define CONST_SOCIAL. But I am also including a full list of stock rom socials with
the added bit so you don't gotta sift through them all. Its annoying
Trust me (Some of them are quite lame [Might wanna change the beg one:P]
but they do the job.) 

Now. Make sure Erwin's snippet works properly, and continue to promptly remove all 
the channel codes. (Gossip, OOC, auction, ImmTalk, clan talk, Q/A, Quote, and grat.)
Add this in its place. (This next bit contains all functions in the channel code. This
is made to fit my mud, you may not have some of the things I do [Such as the channel 
pre for clans. Simply just add it. If you don't know how e-mail me at davionkalhen@hotmail.com
and I'll try to help ya's. Or simply just ask the folks at Kyndig.com. Dem helpful buggers!]
so it may not work.)

Actual code starts here!->

void do_newchan( CHAR_DATA *ch, char *argument, int channel)
{
	char arg[MSL];
	char arg2[MSL];
	char *talk;
	char *pre;
	char emote[2*MSL];
	char buf[MAX_STRING_LENGTH];
	char soc[MSL];
        DESCRIPTOR_DATA *d;
	pre = get_pre(ch, channel);
	if (channel == CHAN_CLAN)
	{
		if (IS_NPC(ch))
		{
		send_to_char("You aren't in a clan.\n\r",ch);
		return;
		}
	}

    if (argument[0] == '\0' )
    {
      if (IS_SET(ch->comm,chan_table[channel].bit))
      {
		sprintf( buf, "The %s {xchannel is now ON.\n\r", chan_table[channel].chan_pre );
		send_to_char( buf, ch );
		REMOVE_BIT(ch->comm,chan_table[channel].bit);
		return;
      }
      else
      {
		sprintf( buf, "The %s {xchannel is now OFF.\n\r", chan_table[channel].chan_pre );
		send_to_char( buf, ch );
		SET_BIT(ch->comm,chan_table[channel].bit);
		return;
      }
    }
    else  /* message sent, toggle channel on/off */
	{
		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_NOCHANNELS))
		{
		send_to_char("The gods have revoked your channel priviliges.\n\r",ch);
		return;
		}

		if (IS_SET(ch->comm,chan_table[channel].bit))
		{
		send_to_char("Try turning the channel on?\n\r",ch);
		return;
		}
    }

     if( check_color_string(argument) )
	send_to_char("{RFinal {{ removed. Do not do this again.{x\r\n",ch);

    arg2[0] = '\0';
    talk = argument;
    one_argument(argument, arg);
    argument = one_argument(argument,arg);
	sprintf( emote, "%s", argument );
    argument = one_argument(argument,arg2);

    if(islower(*talk) )
      if(check_chansocial(ch,arg,arg2,channel))
	     return;

	if(!strcmp(arg, "emote") || !strcmp(arg, "!") )
    {
		argument = one_argument(argument,arg);

		sprintf( buf, "%s {%s$n %s{x", pre, chan_table[channel].chan_name,  emote);  
		act(buf,ch,argument,NULL,TO_CHAR,POS_DEAD);	
		for ( d = descriptor_list; d != NULL; d = d->next )
		{
			CHAR_DATA *vch;
        		vch = d->character; 

			if ( d->connected == CON_PLAYING &&
				 vch != ch && 
				 !IS_SET(vch->comm,chan_table[channel].bit) &&
				 !IS_SET(vch->comm,COMM_QUIET) ) 
				 {
			           	if(can_be_sent(ch,vch,channel) )
					{
			                     act(buf,ch,argument,vch,TO_VICT,POS_DEAD);
					}
			                else
            				     continue;
				}	
			}
		 return;
    }

    if(!strcmp(arg, "smote"))
    {
		if(smote_check(ch, arg, emote, channel))
			return;
    }   

	if(!strcmp(arg, "echo"))
    {
		if(echo_check(ch,arg,emote,channel))
			return;
    }

    sprintf( soc, "%s", get_emote(ch, talk ) );

    if(*talk == '#')
	sprintf(talk, "%s", emote);

      if(channel == CHAN_GOSSIP)
      {
      if (!IS_NPC(ch) && ch->pcdata->condition[COND_DRUNK] > 10)
	talk = makedrunk(talk,ch);
      }

	printf_to_char( ch, "%s {%s%s %s '{%s%s{%s'{x\n\r", pre, chan_table[channel].chan_name,ch->name, soc,
		chan_table[channel].chan_say, talk, chan_table[channel].chan_name );

    for ( d = descriptor_list; d != NULL; d = d->next )
    {
	CHAR_DATA *vch;
        vch = ( d->original != NULL ) ? d->original : d->character; 

		if ( d->connected == CON_PLAYING &&
			 !IS_SET(vch->comm,chan_table[channel].bit) &&
			 !IS_SET(vch->comm,COMM_QUIET) )
		{
           if(can_be_sent(ch,vch,channel) )
	   {
	    sprintf( buf, "%s {%s%s %s '{%s%s{%s'{x", 
	  	pre,
		chan_table[channel].chan_name,
		PERS_CHAN(ch, vch ),
		soc,
		chan_table[channel].chan_say,
		talk,
		chan_table[channel].chan_name);
            act_new(buf,ch,argument,vch,TO_VICT,POS_DEAD);
 	     
	   }
           else
            continue;
		}
    }
}

char *get_emote( CHAR_DATA *ch, char *argument)
{ 
    char arg[MSL], buf[MSL];
    int cmd, len, i, y;
    bool found = FALSE;

    arg[0] = '\0';
    buf[0] = '\0';

    argument = one_argument(argument, arg);
    i = 0;
    if( arg[0] == '#' )
    {	
	len = strlen_color(arg);
	for (i=y=0; i < len; i++)
	{
		if(arg[i] == '#' )
			i++;
	
		buf[y] = arg[i];
		y++;
		buf[y] = '\0';

	}
		
	if( ( cmd = social_lookup(buf) ) < 0)
		return "says";
	else
		found = TRUE;
	if(found)
		return social_table[cmd].chan_emote;
	}
   return "says";
}


char *get_pre(CHAR_DATA *ch, int channel)
{
	if(channel == CHAN_CLAN)
		return clan_table[ch->clan].channame;
	else
		return chan_table[channel].chan_pre;
}


bool smote_check(CHAR_DATA *ch, char *argument, char *emote, int channel )
{
    CHAR_DATA *vch;
    char *letter,*name;
    char last[MAX_INPUT_LENGTH], temp[MAX_STRING_LENGTH];
    int matches = 0;
    char *pre;
    char buf[MSL];
    DESCRIPTOR_DATA *d; 
 	
    pre = get_pre(ch, channel);
	
    if ( !IS_NPC(ch) && IS_SET(ch->comm, COMM_NOEMOTE) )
    {
	return FALSE;
    }
 
    if ( argument[0] == '\0' )
    {
	return FALSE;
    }
    
    if (strstr(emote,ch->name) == NULL)
    {
	send_to_char("You must include your name in an smote.\n\r",ch);
	return TRUE;
    }

    sprintf( buf, "%s {%s%s{x", pre, chan_table[channel].chan_name, emote); 

    send_to_char(buf,ch);
    send_to_char("\n\r",ch);
 
    for ( d = descriptor_list; d != NULL; d = d->next )
    {
        vch = ( d->original != NULL ) ? d->original : d->character; 
		if ( d->connected == CON_PLAYING &&
			 vch != ch &&
			 !IS_SET(vch->comm,chan_table[channel].bit) &&
			 !IS_SET(vch->comm,COMM_QUIET) )
		{

		if(!can_be_sent(ch,vch,channel) )
		    continue;
        if (vch->desc == NULL || vch == ch)
            continue;
 
        if ((letter = strstr(argument,vch->name)) == NULL)
        {
		act(buf,ch,NULL,vch,TO_VICT,POS_DEAD);
            continue;
        }
 
        strcpy(temp,emote);
        temp[strlen(emote) - strlen(letter)] = '\0';
        last[0] = '\0';
        name = vch->name;
 
        for (; *letter != '\0'; letter++)
        {
            if (*letter == '\'' && matches == strlen(vch->name))
            {
                strcat(temp,"r");
                continue;
            }
 
            if (*letter == 's' && matches == strlen(vch->name))
            {
                matches = 0;
                continue;
            }
 
            if (matches == strlen(vch->name))
            {
                matches = 0;
            }
 
            if (*letter == *name)
            {
                matches++;
                name++;
                if (matches == strlen(vch->name))
                {
                    strcat(temp,"you");
                    last[0] = '\0';
                    name = vch->name;
                    continue;
                }
                strncat(last,letter,1);
                continue;
            }
 
            matches = 0;
            strcat(temp,last);
            strncat(temp,letter,1);
            last[0] = '\0';
            name = vch->name;
        }
 
		act(buf,ch,NULL,vch,TO_VICT,POS_DEAD);


    }
  } 
		return TRUE;
}
bool echo_check(CHAR_DATA *ch, char *argument, char *emote, int channel)
{
    DESCRIPTOR_DATA *d;
    char *pre;
	char buf[MSL];
    buf[0] = '\0';
	pre = get_pre(ch, channel);

    if ( argument[0] == '\0' )
    {
	return FALSE;
    }
    if(!IS_IMMORTAL(ch))
	return FALSE;

    sprintf( buf, "%s {%s%s{x", pre, chan_table[channel].chan_name, emote); 
	send_to_char(buf,ch);
	send_to_char("\n\r",ch);
    for ( d = descriptor_list; d != NULL; d = d->next )
    {
	CHAR_DATA *vch;
        vch = ( d->original != NULL ) ? d->original : d->character;; 
		if ( d->connected == CON_PLAYING &&
			 vch != ch &&
			 !IS_SET(vch->comm,chan_table[channel].bit) &&
			 !IS_SET(vch->comm,COMM_QUIET) )
			{
           if(can_be_sent(ch, vch,channel) )
            act(buf,ch,NULL,vch,TO_VICT,POS_DEAD);
           else
            continue;
   		}
    }
	return TRUE;
}

bool check_chansocial( CHAR_DATA *ch, char *command, char *argument, int channel )
{
    char arg[MAX_INPUT_LENGTH];
    CHAR_DATA *victim;
    int cmd;
    bool found;
    char buf[MSL];
    int counter;
    int count;
    char buf2[MSL];        
    char buf3[MSL];
	char *pre;
    DESCRIPTOR_DATA *d;

	pre = get_pre(ch, channel);


    buf[0] = '\0';
    buf2[0] = '\0';
    buf3[0] = '\0';
    found  = FALSE;
    for ( cmd = 0; social_table[cmd].name[0] != '\0'; cmd++ )
    {
	if ( command[0] == social_table[cmd].name[0]
	&&   !str_prefix( command, social_table[cmd].name ) )
	{
	    found = TRUE;
	    break;
	}
    }

    if ( !found )
	return FALSE;

    one_argument( argument, arg );
    victim = NULL;
    if ( arg[0] == '\0' )
    {
      sprintf( buf, "%s {%s{%s%s{%s{x", 
		pre, 
		chan_table[channel].chan_name,
		chan_table[channel].chan_say, 
		social_table[cmd].others_no_arg,
		chan_table[channel].chan_name);

      sprintf( buf2, "%s {%s{%s%s{%s{x\n\r",
		pre,
		chan_table[channel].chan_name,
		chan_table[channel].chan_say,
		social_table[cmd].char_no_arg,
		chan_table[channel].chan_name);

	for (d = descriptor_list; d != NULL; d = d->next)
	{
	    CHAR_DATA *vch;
	    vch = ( d->original != NULL ) ? d->original : d->character;
	    if (d->connected == CON_PLAYING &&
		  vch != ch &&
		  !IS_SET(vch->comm,chan_table[channel].bit) &&
	 	  !IS_SET(vch->comm,COMM_QUIET))
	    {
           if(can_be_sent(ch,vch,channel) )
            act(buf,ch,NULL,vch,TO_VICT,POS_DEAD);
           else
            continue;
          }
       }
	send_to_char(buf2,ch);	
    }
    else if ( ( victim = get_char_world( ch, arg ) ) == NULL || IS_NPC(victim))
    {
	return FALSE;
    }	
    else if(IS_SET(victim->comm,chan_table[channel].bit))
    	{
	    send_to_char("They cannot see this channel, therefor you cannot do that to them.\n\r",ch);
    	    return TRUE;
      }
    else if ( victim == ch )
    {
      sprintf( buf, "%s {%s{%s%s{%s{x",
		pre,
		chan_table[channel].chan_name,
		chan_table[channel].chan_say,
		social_table[cmd].others_auto,
		chan_table[channel].chan_name);

      sprintf( buf2, "%s {%s{%s%s{%s{x\n\r",
		pre,
		chan_table[channel].chan_name,
		chan_table[channel].chan_say,
		social_table[cmd].char_auto,
		chan_table[channel].chan_name);	
	send_to_char(buf2,ch);

      for ( d = descriptor_list; d != NULL; d = d->next )
      {
		CHAR_DATA *vch;
        	vch = ( d->original != NULL ) ? d->original : d->character;
           if(!can_be_sent(ch, vch,channel) )
            continue;
 
        if ( d->connected == CON_PLAYING &&
             vch != ch &&
		 victim->name != arg &&
             !IS_SET(vch->comm,chan_table[channel].bit) &&
             !IS_SET(vch->comm,COMM_QUIET) )
        {
	    act(buf,ch,NULL,vch,TO_VICT,POS_DEAD);
        }
      }
    }
    else
    {
      sprintf( buf, "%s {%s{%s%s{%s{x",
		pre,
		chan_table[channel].chan_name,
		chan_table[channel].chan_say,
		social_table[cmd].others_found,
		chan_table[channel].chan_name);

      sprintf( buf2, "%s {%s{%s%s{%s{x",
		pre,
		chan_table[channel].chan_name,
		chan_table[channel].chan_say,
		social_table[cmd].char_found,
		chan_table[channel].chan_name);

      sprintf( buf3, "%s {%s{%s%s{%s{x",
		pre,
		chan_table[channel].chan_name,
		chan_table[channel].chan_say,
		social_table[cmd].vict_found,
		chan_table[channel].chan_name);
	  act(buf3,ch,NULL,victim,TO_VICT,POS_DEAD);
	  act(buf2,ch,NULL,victim,TO_CHAR,POS_DEAD);
        for (counter = 0; buf[counter+1] != '\0'; counter++)
        {
            if (buf[counter] == '$' && buf[counter + 1] == 'N')
            {
                strcpy(buf2,buf);
                buf2[counter] = '\0';
                strcat(buf2,victim->name);
                for (count = 0; buf[count] != '\0'; count++)
                {
                    buf[count] = buf[count+counter+2];
                }
                strcat(buf2,buf);
                strcpy(buf,buf2);

            }
            else if (buf[counter] == '$' && buf[counter + 1] == 'E')
            {
                switch (victim->sex)
                {
                default:
                    strcpy(buf2,buf);
                    buf2[counter] = '\0';
                    strcat(buf2,"it");
                    for (count = 0; buf[count] != '\0'; count ++)
                    {
                        buf[count] = buf[count+counter+2];
                    }
                    strcat(buf2,buf);
                    strcpy(buf,buf2);
                    break;
                case 1:
                    strcpy(buf2,buf);
                    buf2[counter] = '\0';
                    strcat(buf2,"it");
                    for (count = 0; buf[count] != '\0'; count++)
                    {
                        buf[count] = buf[count+counter+2];
                    }
                    strcat(buf2,buf);
                    strcpy(buf,buf2);
                    break;
                case 2:
                    strcpy(buf2,buf);
                    buf2[counter] = '\0';
                    strcat(buf2,"it");
                    for (count = 0; buf[count] != '\0'; count++)
                    {
                        buf[count] = buf[count+counter+2];
                    }
                    strcat(buf2,buf);
                    strcpy(buf,buf2);
                    break;
                }
            }
            else if (buf[counter] == '$' && buf[counter + 1] == 'M')
            {
                buf[counter] = '%';
                buf[counter + 1] = 's';
                switch (victim->sex)
                {
                default:
                    strcpy(buf2,buf);
                    buf2[counter] = '\0';
                    strcat(buf2,"it");
                    for (count = 0; buf[count] != '\0'; count++)
                    {
                        buf[count] = buf[count+counter+2];
                    }
                    strcat(buf2,buf);
                    strcpy(buf,buf2);
                    break;
                case 1:
                    strcpy(buf2,buf);
                    buf2[counter] = '\0';
                    strcat(buf2,"him");
                    for (count = 0; buf[count] != '\0'; count++)
                    {
                        buf[count] = buf[count+counter+2];
                    }
                    strcat(buf2,buf);
                    strcpy(buf,buf2);
                    break;
                case 2:
                    strcpy(buf2,buf);
                    buf2[counter] = '\0';
                    strcat(buf2,"her");
                    for (count = 0; buf[count] != '\0'; count++);
                    {
                        buf[count] = buf[count+counter+2];
                    }
                    strcat(buf2,buf);
                    strcpy(buf,buf2);
                    break;
                }
            }
            else if (buf[counter] == '$' && buf[counter + 1] == 'S')
            {
                switch (victim->sex)
                {
                default:
                strcpy(buf2,buf);
                buf2[counter] = '\0';
                strcat(buf2,"its");
                for (count = 0;buf[count] != '\0'; count++)
                {
                    buf[count] = buf[count+counter+2];
                }
                strcat(buf2,buf);
                strcpy(buf,buf2);
                break;
                case 1:
                    strcpy(buf2,buf);
                    buf2[counter] = '\0';
                    strcat(buf2,"his");
                    for (count = 0; buf[count] != '\0'; count++)
                    {
                        buf[count] = buf[count+counter+2];
                    }
                    strcat(buf2,buf);
                    strcpy(buf,buf2);
                    break;
                case 2:
                    strcpy(buf2,buf);
                    buf2[counter] = '\0';
                    strcat(buf2,"hers");
                    for (count = 0; buf[count] != '\0'; count++)
                    {
                        buf[count] = buf[count+counter+2];
                    }
                    strcat(buf2,buf);
                    strcpy(buf,buf2);
                    break;
                }
            }

        }

      for ( d = descriptor_list; d != NULL; d = d->next )
      {
	  CHAR_DATA *vch;
        vch = ( d->original != NULL ) ? d->original : d->character;
 
        if ( d->connected == CON_PLAYING &&
             vch != ch &&
			  victim != vch &&
             !IS_SET(vch->comm,chan_table[channel].bit) &&
             !IS_SET(vch->comm,COMM_QUIET) )
        {
	   if(can_be_sent(ch,vch,channel) )
	    act(buf,ch,NULL,vch,TO_VICT,POS_DEAD);
	   else
	    continue;
        }
      }	
    }

    return TRUE;
}

void do_ooc( CHAR_DATA *ch, char *argument)	    
{
	do_newchan( ch, argument, CHAN_OOC );
	return;
}
void do_gossip( CHAR_DATA *ch, char *argument)	    
{
	do_newchan( ch, argument, CHAN_GOSSIP );
	return;
}
void do_quote( CHAR_DATA *ch, char *argument)	    
{
	do_newchan( ch, argument, CHAN_QUOTE );
	return;
}
void do_grats( CHAR_DATA *ch, char *argument)	    
{
	do_newchan( ch, argument, CHAN_GRATS );
	return;
}
void do_question( CHAR_DATA *ch, char *argument)	    
{
	do_newchan( ch, argument, CHAN_QA );
	return;
}
void do_music( CHAR_DATA *ch, char *argument)	    
{
	do_newchan( ch, argument, CHAN_MUSIC );
	return;
}
void do_immtalk( CHAR_DATA *ch, char *argument)	    
{
	do_newchan( ch, argument, CHAN_IMM );
	return;
}
void do_clantalk( CHAR_DATA *ch, char *argument)	    
{
	do_newchan( ch, argument, CHAN_CLAN );
	return;
}
void do_imp( CHAR_DATA *ch, char *argument )
{
	do_newchan( ch, argument, CHAN_IMP );
	return;
}
void do_hero( CHAR_DATA *ch, char *argument )
{
	do_newchan( ch, argument, CHAN_HERO );
	return;
}      
void do_newbie( CHAR_DATA *ch, char *argument )
{

        do_newchan( ch, argument, CHAN_NEWBIE );
        return;
}

bool can_be_sent(CHAR_DATA *ch, CHAR_DATA *vch, int channel )
{
    
    if ((channel == CHAN_IMM) && (!IS_IMMORTAL(vch)))
    	return FALSE;
    if (channel == CHAN_CLAN && !is_same_clan(ch,vch))
        return FALSE;
    if (channel == CHAN_IMP && !IS_IMP(vch) )
	return FALSE; 
    if (channel == CHAN_HERO && !IS_HERO(vch) && number_classes(vch) <= 1)
	return FALSE;

    return TRUE;   
}
//Submited by Snafu Life
bool check_color_string(char *string )
{
        int i,length;
        int count=1;

        /* Sanity check for empty strings */
        if ( *(string+0) == '\0') {
                return FALSE;
        }

        /* Determine the length of the string. */
        length = strlen(string);

        /*
         * subtacrt one from length to get to the last character
         * Then if the string doesn't end in {, we are done
         */
        if(*(string+(--length)) != '{') {
                return FALSE;
        }

        /* Loop through the string backwards until we know how
         * many {'s are at the end.
         * Also we already checked length so we can set i to length - 1
         */
        for(i=length-1;i>=0;i--) {

                /* If the current character isn't a '{'
                 * We are done.
                 */
                if (*(string+i) != '{')
                        break;

                /* If it is add to count and continue */
                if(*(string+(i-1)) == '{') {
                        count++;
                        continue;
                }
        }

        /* Now if we divide by two and have a remainder,
         * It's an odd number of {'s and we need to kill
         * the last one, otherwise we can just leave it be.
         */
        if( count % 2 ) {
                *(string+length) = '\0';
                return TRUE;
        }

        return FALSE;
}


/*End of act_comm.c*/

/*begining of tables.c*/
//Add this anywhere, best is prolly at bottom of file.

const	struct	chan_type chan_table[] =
{
	{	"{w[{WOOC{w]",    	"W",	"W",	COMM_NOOOC},
	{	"{D[{yGossip{D]",	"D",	"y",	COMM_NOGOSSIP},
	{	"{w[Quote]",		"w",	"w",	COMM_NOQUOTE},
	{	"{b[{BMusic{b]",	"B",	"b",	COMM_NOMUSIC},
	{	"{g[{GQ&A{g]",		"g",	"g",    COMM_NOQUESTION},
	{	"{r[{RAuction{r]",	"R",	"R",	COMM_NOAUCTION},
	{	"{M[{mGrats{M]",	"M",	"m",	COMM_NOGRATS},
	{	"{W[{DImmChat{W]",	"W",	"W",	COMM_NOWIZ},
	{	"{y[{YClan{y]",		"y",	"y",	COMM_NOCLAN},
	{	"{B[{yIMP{B]",		"B",	"c",	COMM_NOIMP},
	{	"{B[{GHERO{B]",		"B",    "c",	COMM_NOHERO},
	{	"{B[{RNewbie{B]",       "B",    "c",    COMM_NONEWBIE},
	{	NULL,			" ",	" ",	0            }
};

/*End of tables.c*/

/*begining of tables.h*/

extern 	const   struct	chan_type       chan_table[];

struct chan_type
{
	char *chan_pre;
	char *chan_name;
	char *chan_say;
	int bit;
};
/*End of tables.h*/


<- That is a bunch of code! Woo!

Now.  you aint done yet, mister! In merc.h under act_comm.c throw in these
prototypes

char *get_pre args( (CHAR_DATA *ch, int channel) );
void do_newchan args ( ( CHAR_DATA *ch, char *argument, int channel) );
bool smote_check args ( (CHAR_DATA *ch, char *argument, char *emote, int channel ) );
bool echo_check args ( (CHAR_DATA *ch, char *argument, char *emote, int channel ) );
bool check_chansocial args ( ( CHAR_DATA *ch, char *command, char *argument, int channel ) );
char *get_emote args ( ( CHAR_DATA *ch, char *argument) );
bool can_be_sent args ( (CHAR_DATA *ch, CHAR_DATA *vch, int channel ) );

Now do a clean make. Copyover, and walla, your set to go!
Credits go to:

Noximist for debugging and being so cute!
Descil for the idea, and alowing me to base my chansnip of his actual real code.
Davvol for the inital newchan() idea, and for coding it.
And myself! For the countless hours expanding on it, and writing this snippet!


Just remember, if you don't have some of the channels in, you have to put in the
COMM_NO what ever channel, and the adding to the table in interp.c.

I hope thats everything. I havn't slept in a few days, so kick me if I'm wrong!
Bugfixes are always welcome. davionkalhen@hotmail.com is the e-mail address. I'm always
wanting ideas. As well, you can stop by my mud telnet://beyond.kyndig.com:5500
If you got something you've always wanted in a channel just send
me an e-mail and it'll prolly be in my next update, along with credits for your
self.