diff --git a/conf/channels.conf b/conf/channels.conf
index 5930531c0d3..c83e5ecdbc9 100644
--- a/conf/channels.conf
+++ b/conf/channels.conf
@@ -1,16 +1,5 @@
 // Channel System Configuration File
-
-chsys: (
-{
-	/* Default channels (available to all players) */
-	default_channels: {
-		/* channel_name : channel_messages_color */
-	 	main: "Yellow"
-		support: "Blue"
-		trade: "Red"
-		chat: "Default"
-		/* Add as many channels as you'd like. */
-	}
+channel_config: {
 
 	/* Colors available */
 	colors: {
@@ -21,24 +10,112 @@ chsys: (
 		Cyan: "0x00b89d"
 		Yellow: "0xffff90"
 		Green: "0x28bf00"
+		White: "0xFFFFFF"
+		Purple: "0xD67FFF"
+		LightGreen: "0xB6FF00"
 		Normal: "0x00ff00"
 		/* Add as many colors as you'd like. */
 	}
 
-	/* Allow users to create their own (private) channels through @channel command? */
-	/* (must also allow players to use @channel in groups.conf) */
-	allow_user_channel_creation: true
+	/**
+	 * Private channel config
+	 * - Always CHAN_TYPE_PUBLIC
+	 * - Always displayed in chat log as "#channel_name: <name>: <chat>"
+	 * - ID of private channels are started from 1000
+	 **/
+	private_channel: {
+		allow: true			  // (bool)	Allow playerto create own channel?
+		color: "Default"	  // (string)	Default color, see colors
+		delay: 1000			  // (int)	Chat delay for each member
+		max_member: 1000	  // (int)	Max member
+		self_notif: true	  // (bool)	Show message when you enter or leave the channel
+		join_notif: false	  // (bool)	Show message when player joined the channel
+		leave_notif: false	  // (bool)	Show message when player left the channel
+		/* Moderation feature for channel owner, allowed to: */
+		ban: true			  // (bool)	Ban player
+		kick: true			  // (bool)	Kick player
+		color_override: false // (bool)	Player allow color override for private channel
+		change_delay: false	  // (bool)	Change allow to change channel dealy
+	}
 
-	/* "map_local_channel" is an instanced channel unique to each map. */
-	map_local_channel: false
-	map_local_channel_name: "map"
-	map_local_channel_color: "Yellow"
-	map_local_channel_autojoin: true /* Disable autojoin in specific maps through mapflag 'nomapchannelautojoin'. */
+	/**
+	 * Default server channels
+	 **/
+	channels: (
+	/**
+	 * Structure
+	{
+		name: "#channel"		 // (string)	Channel name
+		password: ""			 // (string)	Password
+		alias: "[Channel]"		 // (string)	Message from this channel will be displayed with this name instead the channel name
+		color: "Default"		 // (string)	Color for this channel
+		type: "CHAN_TYPE_PUBLIC" // (string)	Channel type: CHAN_TYPE_PUBLIC, CHAN_TYPE_ALLY, CHAN_TYPE_MAP
+		autojoin: false			 // (bool)	Player will auto join channel
+		delay: 1000				 // (int)	Chat delay for each player
+		leave: true				 // (bool)	Player is allowed to leave the channel
+		chat: true				 // (bool)	Player is allowed to chat on this channel
+		color_override: false	 // (bool)	Override channel color with personal color
+		self_notif: true		 // (bool)	Show message when you enter or leave the channel
+		join_notif: false		 // (bool)	Show message when player joined the channel
+		leave_notif: false		 // (bool)	Show message when player left the channel
+		groupid: (0,..,99)		 // (list,int)	Only player with there group ids allowed to join. Group with 'channel_admin' always can enter the channel.
+		/// All values above are default settings
+	},							 // Use comma if followed by other channel
+	 **/
+	{
+		name: "#global"
+		alias: "[Global]"
+		color: "White"
+		type: "CHAN_TYPE_PUBLIC"
+		delay: 1000
+		autojoin: false
+		leave: false
+	},
+	{
+		name: "#support"
+		alias: "[Support]"
+		color: "Blue"
+		type: "CHAN_TYPE_PUBLIC"
+		delay: 1000
+		autojoin: false
+	},
+	{
+		name: "#trade"
+		alias: "[Trade]"
+		color: "LightGreen"
+		type: "CHAN_TYPE_PUBLIC"
+		delay: 1000
+		autojoin: false
+	}
+	)
 
-	/* "ally_channel" is a channel shared by all your guild allies. */
-	ally_channel_enabled: true
-	ally_channel_name: "ally"
-	ally_channel_color: "Green"
-	ally_channel_autojoin: true
+	/**
+	 * Channel config for guild alliance
+	 * For the structure, see the 'channels' above
+	 **/
+	ally: {
+		name: "#ally"
+		alias: "[Ally]"
+		color: "Green"
+		type: "CHAN_TYPE_ALLY" // DO NOT CHANGE THIS VALUE
+		delay: 1000
+		autojoin: false
+		leave: true
+		chat: true
+	}
+
+	/**
+	 * Channel config for map channel
+	 * For the structure, see the 'channels' above
+	 **/
+	map: {
+		name: "#map"
+		alias: "[Map]"
+		color: "Yellow"
+		type: "CHAN_TYPE_MAP" // DO NOT CHANGE THIS VALUE
+		delay: 1000
+		autojoin: false
+		leave: true
+		chat: true
+	}
 }
-)
diff --git a/conf/map_athena.conf b/conf/map_athena.conf
index 5df09c33b29..8c2a56522ae 100644
--- a/conf/map_athena.conf
+++ b/conf/map_athena.conf
@@ -119,6 +119,9 @@ help_txt: conf/help.txt
 help2_txt: conf/help2.txt
 charhelp_txt: conf/charhelp.txt
 
+// Load channel config from
+channel_conf: conf/channels.conf
+
 // Maps:
 import: conf/maps_athena.conf
 
diff --git a/conf/msg_conf/map_msg.conf b/conf/msg_conf/map_msg.conf
index f4dfc4624d0..a56ba3aab8d 100644
--- a/conf/msg_conf/map_msg.conf
+++ b/conf/msg_conf/map_msg.conf
@@ -803,6 +803,18 @@
 
 //753-899 free
 
+881: Cannot join channel '%s'. Reached limit of private channel %d.
+882: %s %s has joined
+883: You cannot leave '%s' channel.
+884: %s %s left
+885: Cannot set color_override for this channel '%s'.
+886: Not allowed to ban a player.
+887: You cannot kick player from this channel '%s'.
+888: Not allowed to kick a player.
+889: %s %s is kicked.
+890: %s %s is banned.
+891: %s %s is unbanned.
+
 //------------------------------------
 // More atcommands message
 //------------------------------------
diff --git a/doc/script_commands.txt b/doc/script_commands.txt
index 112432925ef..eeb90903ba1 100644
--- a/doc/script_commands.txt
+++ b/doc/script_commands.txt
@@ -9360,5 +9360,162 @@ If <char id> is specified, the specified player is used rather than the attached
 
 ---------------------------------------
 
+===========================
+| Channel Commands [Cydh] |
+===========================
+---------------------------------------
+
+*channel_create "<chname>","<alias>"{,"<password>"{<option>{,<delay>{,<color>{,<char_id>}}}}};
+
+Creates public channel with <chname> as the channel name. To protect the
+channel, use <password> or write "null" to create it without password.
+Channel name must be started with '#' and cannot be same with map or ally
+channel names.
+
+<alias> will be used to change the channel name when the channel message
+is displayed.
+
+<option> values are:
+	CHAN_OPT_BASE		    - Default option including CHAN_OPT_ANNOUNCE_SELF|CHAN_OPT_MSG_DELAY|CHAN_OPT_CAN_CHAT|CHAN_OPT_CAN_LEAVE
+	CHAN_OPT_ANNOUNCE_SELF  - Show info for player itself if player is joined/left the channel
+	CHAN_OPT_ANNOUNCE_JOIN  - Display message when player is joining the channel
+	CHAN_OPT_ANNOUNCE_LEAVE - Display message when player is leaving the channel
+	CHAN_OPT_MSG_DELAY	    - Enable chat delay for the channel
+	CHAN_OPT_COLOR_OVERRIDE - Player's fontcolor will override channel's color
+	CHAN_OPT_CAN_CHAT	    - Player can chat in the channel
+	CHAN_OPT_CAN_LEAVE	    - Player can leave from the channel
+	CHAN_OPT_AUTOJOIN	    - Logged player will auto join the channel
+
+The <delay> is chat delay in milisecond for a single player can chat again
+in the same channel.
+
+Use <color> hex code to set color for this channel, if not defined, default
+channel color will be used.
+
+If <char_id> is defined, the channel will be private channel and the player
+will be the the channel owner.
+
+Returns 1 on success.
+
+	/**
+	 * This example will shows the message on this channel as
+	 * [rAthena] Admin : Hello world!
+	 * instead of
+	 * #rathena Admin : Hello world!
+	 **/
+	channel_create("#rathena","[rAthena]");
+	channel_create("#vip","[VIP]","vipmemberonly");
+
+---------------------------------------
+
+*channel_setopt "<chname>",<option>,<value>;
+
+Set option for the channel. Use 1 in <value> to set it, or 0 to unset.
+The <option> values are same with 'channel_create'.
+
+For CHAN_OPT_MSG_DELAY must followed with delay in milisecond or use 0
+to remove the delay at <value>.
+
+Returns 1 on success.
+
+	// Example to set delay
+	channel_setopt("#global",CHAN_OPT_MSG_DELAY,5000);
+
+Only for public and private channel.
+
+---------------------------------------
+
+*channel_setcolor "<chname>",<color>;
+
+To change channel color.
+<color> is using hex RGB value.
+
+Returns 1 on success.
+
+---------------------------------------
+
+*channel_setpass "<chname>","<password>";
+
+To set, unset, or change password of a channel.
+Use "null" to remove the password.
+
+Returns 1 on success.
+Only for public and private channel.
+
+---------------------------------------
+
+*channel_setgroup "<chname>",<group_id>{,...,<group_id>};
+*channel_setgroup2 "<chname>",<array_of_groups>;
+
+Set group restriction for a channel. Only player with matched <group_id>
+that allowed to to join the channel.
+
+By using 0 in the first group channel, the group restriction will be
+removed from the channel config.
+
+'channel_setgroup2' receives input for group list as an array.
+
+Returns 0 on failure, and 1 (or n groups count) on success.
+
+	// Example 1: Remove groups
+	channel_setgroup("#event",0);
+
+	// Example 2: Multiple values
+	channel_setgroup("#vip",2,5);
+
+	// Example 3: Using array
+	setarray .@staffs[0],2,3,4,10,99;
+	channel_setgroup("#staff",.@staffs);
+
+Only for public and private channel.
+
+---------------------------------------
+
+*channel_chat "<chname>","<message>"{,<color>};
+
+Sends message to the channel.
+Returns 1 on success.
+
+	// Example if channel doesn't have alias
+	channel_chat(#rathena,"Hello World!"); // #rathena Hello World!
+
+	// Example if channel has alias
+	channel_chat(#rathena,"Hello World!"); // [rAthena] Hello World!
+
+---------------------------------------
+
+*channel_ban "<chname>",<char_id>;
+
+Ban player from channel public or private channel.
+Channel's owner and group with PC_PERM_CHANNEL_ADMIN cannot be banned.
+Returns 1 on success.
+
+---------------------------------------
+
+*channel_unban "<chname>",<char_id>;
+
+Unban player from channel public or private channel.
+Returns 1 on success.
+
+---------------------------------------
+
+*channel_kick "<chname>",<char_id>;
+*channel_kick "<chname>","<char_name>";
+
+Kick player from channel public or private channel.
+Channel's owner and group with PC_PERM_CHANNEL_ADMIN cannot be kicked.
+Returns 1 on success.
+
+---------------------------------------
+
+*channel_delete "<chname>";
+
+Delete existing public or private channel. Cannot delete ally or local map
+channel.
+Returns 0 on success.
+
+---------------------------------------
+
+
 Whew.
 That's about all of them.
diff --git a/src/map/atcommand.c b/src/map/atcommand.c
index 85c3c627622..72528a47477 100644
--- a/src/map/atcommand.c
+++ b/src/map/atcommand.c
@@ -9330,7 +9330,7 @@ static inline void atcmd_channel_help(struct map_session_data *sd, const char *c
 {
 	int fd = sd->fd;
 	bool can_delete = pc_has_permission(sd, PC_PERM_CHANNEL_ADMIN);
-	bool can_create = (can_delete || channel_config.user_chenable);
+	bool can_create = (can_delete || channel_config.private_channel.allow);
 	clif_displaymessage(fd, msg_txt(sd,1414));// ---- Available options:
 
 	//option create
@@ -9439,6 +9439,8 @@ ACMD_FUNC(channel) {
 		return channel_pcunbind(sd);
 	} else if ( strcmpi(key,"ban") == 0 ) {
 		return channel_pcban(sd,sub1,sub2,0);
+	} else if ( strcmpi(key,"kick") == 0 ) {
+		return channel_pckick(sd,sub1,sub2,0);
 	} else if ( strcmpi(key,"banlist") == 0 ) {
 		return channel_pcban(sd,sub1,NULL,3);
 	} else if ( strcmpi(key,"unban") == 0 ) {
@@ -9449,7 +9451,7 @@ ACMD_FUNC(channel) {
 		char sub3[CHAN_NAME_LENGTH], sub4[CHAN_NAME_LENGTH];
 		sub3[0] = sub4[0] = '\0';
 		sscanf(sub2, "%19s %19s", sub3, sub4);
-		if( strcmpi(key,"create") == 0 && ( channel_config.user_chenable || pc_has_permission(sd, PC_PERM_CHANNEL_ADMIN) ) ) {
+		if( strcmpi(key,"create") == 0 && ( channel_config.private_channel.allow || pc_has_permission(sd, PC_PERM_CHANNEL_ADMIN) ) ) {
 			if (sub4[0] != '\0') {
 				clif_displaymessage(fd, msg_txt(sd, 1408)); // Channel password may not contain spaces.
 				return -1;
diff --git a/src/map/channel.c b/src/map/channel.c
index 3451d02c8dd..ba0a1f84ef8 100644
--- a/src/map/channel.c
+++ b/src/map/channel.c
@@ -5,6 +5,7 @@
 #include "../common/malloc.h"
 #include "../common/conf.h" //libconfig
 #include "../common/showmsg.h"
+#include "../common/nullpo.h"
 #include "../common/strlib.h" //safestrncpy
 #include "../common/socket.h" //set_eof
 
@@ -20,11 +21,6 @@ struct Channel_Config channel_config;
 
 DBMap* channel_get_db(void){ return channel_db; }
 
-struct chan_banentry {
-	uint32 char_id;
-	char char_name[NAME_LENGTH];
-} chan_banentry;
-
 /*
  * Create *channel
  * - will then add it in channel_db if type not map or ally
@@ -35,34 +31,91 @@ struct chan_banentry {
  * return
  *  NULL : creation failed
  */
-struct Channel* channel_create(char *name, char *pass, unsigned char color, enum Channel_Type chantype, int val) {
+struct Channel* channel_create(struct Channel *tmp_chan) {
 	struct Channel* channel;
 
-	if(!name) return NULL;
+	if (!tmp_chan->name)
+		return NULL;
 
-	CREATE( channel, struct Channel, 1 ); //will exit on fail allocation
+	CREATE(channel, struct Channel, 1); //will exit on fail allocation
+	//channel->id = tmp_chan->id;
 	channel->users = idb_alloc(DB_OPT_BASE);
 	channel->banned = idb_alloc(DB_OPT_BASE|DB_OPT_RELEASE_DATA);
-	channel->opt = CHAN_OPT_BASE;
-	channel->type = chantype;
-	channel->color = color;
-	safestrncpy(channel->name, name, CHAN_NAME_LENGTH);
-	if( !pass )
+	channel->opt = tmp_chan->opt;
+	channel->type = tmp_chan->type;
+	channel->color = tmp_chan->color;
+	safestrncpy(channel->name, tmp_chan->name, CHAN_NAME_LENGTH); // Store channel cname without '#'
+	safestrncpy(channel->alias, tmp_chan->alias ? tmp_chan->alias : tmp_chan->name, CHAN_NAME_LENGTH);
+	if (!tmp_chan->pass)
 		channel->pass[0] = '\0';
 	else
-		safestrncpy(channel->pass, pass, CHAN_NAME_LENGTH);
-
-	//ShowInfo("Create channel %s type=%d, val=%d\n",channel->name,chantype,val);
-	switch(channel->type){
-	case CHAN_TYPE_MAP: channel->m = val; break;
-	case CHAN_TYPE_ALLY: channel->gid = val; break;
-	case CHAN_TYPE_PRIVATE: channel->owner = val; //dont break here private need to put in db
-	default: strdb_put(channel_db, channel->name, channel);
+		safestrncpy(channel->pass, tmp_chan->pass, CHAN_NAME_LENGTH);
+	channel->msg_delay = tmp_chan->msg_delay;
+
+	switch (channel->type) {
+		case CHAN_TYPE_MAP:
+			channel->m = tmp_chan->m;
+			break;
+		case CHAN_TYPE_ALLY:
+			channel->gid = tmp_chan->gid;
+			break;
+		case CHAN_TYPE_PRIVATE:
+			channel->char_id = tmp_chan->char_id;
+		default:
+			strdb_put(channel_db, channel->name, channel);
+			break;
 	}
 
+	if (battle_config.etc_log)
+		ShowInfo("Create channel %s alias %s type=%d, owner=%d/%d/%d\n",channel->name,channel->alias,channel->type,channel->char_id,channel->m,channel->gid);
+
 	return channel;
 }
 
+struct Channel* channel_create_simple(char *name, char *pass, enum Channel_Type chantype, unsigned int owner) {
+	struct Channel tmp_chan;
+	memset(&tmp_chan, 0, sizeof(struct Channel));
+
+	switch (chantype) {
+		case CHAN_TYPE_ALLY:
+			memcpy(&tmp_chan, &channel_config.ally_tmpl, sizeof(channel_config.ally_tmpl));
+			tmp_chan.gid = (int)owner;
+			break;
+		case CHAN_TYPE_MAP:
+			memcpy(&tmp_chan, &channel_config.map_tmpl, sizeof(channel_config.map_tmpl));
+			tmp_chan.m = (uint16)owner;
+			break;
+		case CHAN_TYPE_PUBLIC:
+			safestrncpy(tmp_chan.name, name+1, sizeof(tmp_chan.name));
+			if (pass)
+				safestrncpy(tmp_chan.pass, pass, sizeof(tmp_chan.pass));
+			else
+				tmp_chan.pass[0] = '\0';
+			safestrncpy(tmp_chan.alias, name, sizeof(tmp_chan.name));
+			tmp_chan.type = CHAN_TYPE_PUBLIC;
+			tmp_chan.opt = CHAN_OPT_BASE;
+			tmp_chan.msg_delay = 1000;
+			tmp_chan.color = channel_getColor("Default");
+			break;
+		case CHAN_TYPE_PRIVATE:
+			safestrncpy(tmp_chan.name, name+1, sizeof(tmp_chan.name));
+			if (pass)
+				safestrncpy(tmp_chan.pass, pass, sizeof(tmp_chan.pass));
+			else
+				tmp_chan.pass[0] = '\0';
+			safestrncpy(tmp_chan.alias, name, sizeof(tmp_chan.name));
+			tmp_chan.type = CHAN_TYPE_PRIVATE;
+			tmp_chan.opt = channel_config.private_channel.opt;
+			tmp_chan.msg_delay = channel_config.private_channel.delay;
+			tmp_chan.color = channel_config.private_channel.color;
+			break;
+		default:
+			return NULL;
+	}
+
+	return channel_create(&tmp_chan);
+}
+
 /*
  * Delete channel *channel
  * - check if there is any user in channel and make them all quit
@@ -71,10 +124,10 @@ struct Channel* channel_create(char *name, char *pass, unsigned char color, enum
  *  -1 : invalid channel
  *  -2 : can't delete now
  */
-int channel_delete(struct Channel *channel) {
+int channel_delete(struct Channel *channel, bool force) {
 	if(!channel)
 		return -1;
-	if(channel->type == CHAN_TYPE_PUBLIC && runflag == MAPSERVER_ST_RUNNING) //only delete those serv stop
+	if(!force && channel->type == CHAN_TYPE_PUBLIC && runflag == MAPSERVER_ST_RUNNING) //only delete those serv stop
 		return -2;
 	if( db_size(channel->users)) {
 		struct map_session_data *sd;
@@ -84,9 +137,14 @@ int channel_delete(struct Channel *channel) {
 		}
 		dbi_destroy(iter);
 	}
-	//ShowInfo("Deleting channel %s\n",channel->name);
+	if (battle_config.etc_log)
+		ShowInfo("Deleting channel %s alias %s type %d\n",channel->name,channel->alias,channel->type);
 	db_destroy(channel->users);
 	db_destroy(channel->banned);
+	if (channel->groups)
+		aFree(channel->groups);
+	channel->groups = NULL;
+	channel->group_count = 0;
 	switch(channel->type){
 	case CHAN_TYPE_MAP:
 		map[channel->m].channel = NULL;
@@ -114,6 +172,7 @@ int channel_delete(struct Channel *channel) {
  * -1 : invalid channel or sd
  * -2 : sd already in channel
  * -3 : sd banned
+ * -4 : reached max limit
  */
 int channel_join(struct Channel *channel, struct map_session_data *sd) {
 	if(!channel || !sd)
@@ -122,24 +181,38 @@ int channel_join(struct Channel *channel, struct map_session_data *sd) {
 		return 0; // fake success
 	if(channel_haspc(channel,sd)==1)
 		return -2;
+	if (!pc_has_permission(sd, PC_PERM_CHANNEL_ADMIN) && !channel_pccheckgroup(channel, sd->group_id))
+		return -2;
 
 	if(channel_haspcbanned(channel,sd)==1){
-		char output[128];
+		char output[CHAT_SIZE_MAX];
 		sprintf(output, msg_txt(sd,1438),channel->name); //You're currently banned from the '%s' channel.
 		clif_displaymessage(sd->fd, output);
 		return -3;
 	}
 
+	if (channel->type == CHAN_TYPE_PRIVATE && db_size(channel->users) >= channel_config.private_channel.max_member) {
+		char output[CHAT_SIZE_MAX];
+		sprintf(output, msg_txt(sd,881), channel->name, channel_config.private_channel.max_member); // Cannot join channel '%s'. Reached limit of private channel %d.
+		clif_displaymessage(sd->fd, output);
+		return -4;
+	}
+
+	if (channel_pcisjoined(channel, sd))
+		return 0;
+
 	RECREATE(sd->channels, struct Channel *, ++sd->channel_count);
 	sd->channels[ sd->channel_count - 1 ] = channel;
 	idb_put(channel->users, sd->status.char_id, sd);
+	RECREATE(sd->channel_tick, unsigned int, sd->channel_count);
+	sd->channel_tick[sd->channel_count-1] = 0;
 
 	if( sd->stealth ) {
 		sd->stealth = false;
 	} else if( channel->opt & CHAN_OPT_ANNOUNCE_JOIN ) {
-		char message[60];
-		sprintf(message, "[ #%s ] '%s' has joined.",channel->name,sd->status.name);
-		clif_channel_msg(channel,sd,message,channel->color);
+		char output[CHAT_SIZE_MAX+1];
+		safesnprintf(output, CHAT_SIZE_MAX, msg_txt(sd,882), channel->alias, sd->status.name); // %s %s has joined
+		clif_channel_msg(channel,output,channel->color);
 	}
 
 	/* someone is cheating, we kindly disconnect the bastard */
@@ -159,15 +232,15 @@ int channel_join(struct Channel *channel, struct map_session_data *sd) {
  *  -3 : sd banned (channel_join)
  */
 int channel_mjoin(struct map_session_data *sd) {
+	char mout[60];
 	if(!sd) return -1;
 
 	if( !map[sd->bl.m].channel ) {
-		map[sd->bl.m].channel = channel_create(channel_config.map_chname,NULL,channel_config.map_chcolor,CHAN_TYPE_MAP,sd->bl.m);
+		map[sd->bl.m].channel = channel_create_simple(NULL,NULL,CHAN_TYPE_MAP,sd->bl.m);
 	}
 
-	if( !( map[sd->bl.m].channel->opt & CHAN_OPT_ANNOUNCE_JOIN ) ) {
-		char mout[60];
-		sprintf(mout, msg_txt(sd,1435),channel_config.map_chname,map[sd->bl.m].name); // You're now in the '#%s' channel for '%s'.
+	if( map[sd->bl.m].channel->opt & CHAN_OPT_ANNOUNCE_SELF ) {
+		sprintf(mout, msg_txt(sd,1435),map[sd->bl.m].channel->name,map[sd->bl.m].name); // You're now in the '#%s' channel for '%s'.
 		clif_disp_onlyself(sd, mout, strlen(mout));
 	}
 
@@ -218,7 +291,7 @@ int channel_gjoin(struct map_session_data *sd, int flag){
 
 	channel = g->channel;
 	if(!channel){
-		channel = channel_create(channel_config.ally_chname,NULL,channel_config.ally_chcolor,CHAN_TYPE_ALLY,g->guild_id);
+		channel = channel_create_simple(NULL,NULL,CHAN_TYPE_ALLY,g->guild_id);
 		g->channel = channel;
 		channel_ajoin(g);
 	}
@@ -258,23 +331,28 @@ int channel_clean(struct Channel *channel, struct map_session_data *sd, int flag
 	if( i < sd->channel_count ) {
 		unsigned char cursor = i;
 		sd->channels[i] = NULL;
+		sd->channel_tick[i] = 0;
 		for(; i < sd->channel_count; i++ ) { //slice move list down
 			if( sd->channels[i] == NULL )
 				continue;
-			if(i != cursor)
+			if(i != cursor) {
 				sd->channels[cursor] = sd->channels[i];
+				sd->channel_tick[cursor] = sd->channel_tick[i];
+			}
 			cursor++;
 		}
 		if ( !(sd->channel_count = cursor) ) { //if in no more chan delete db
 			aFree(sd->channels);
+			aFree(sd->channel_tick);
 			sd->channels = NULL;
+			sd->channel_tick = NULL;
 		}
 	}
 
 	idb_remove(channel->users,sd->status.char_id); //remove user for channel user list
 	//auto delete when no more user in
 	if( !db_size(channel->users) && !(flag&1) )
-		channel_delete(channel);
+		channel_delete(channel,false);
 
 	return 0;
 }
@@ -298,7 +376,7 @@ int channel_pcquit(struct map_session_data *sd, int type){
 	if(!sd) return -1;
 
 	// Leave all chat channels.
-	if(type&(1|2) && channel_config.ally_enable && sd->guild){ //quit guild and ally chan
+	if(type&(1|2) && channel_config.ally_tmpl.name != NULL && sd->guild){ //quit guild and ally chan
 		struct guild *g = sd->guild;
 		if(type&1 && channel_haspc(g->channel,sd)==1){
 			channel_clean(g->channel,sd,0); //leave guild chan
@@ -314,7 +392,7 @@ int channel_pcquit(struct map_session_data *sd, int type){
 			}
 		}
 	}
-	if(type&4 && channel_config.map_enable && channel_haspc(map[sd->bl.m].channel,sd)==1){ //quit map chan
+	if(type&4 && channel_config.map_tmpl.name != NULL && channel_haspc(map[sd->bl.m].channel,sd)==1){ //quit map chan
 		channel_clean(map[sd->bl.m].channel,sd,0);
 	}
 	if(type&8 && sd->channel_count ) { //quit all chan
@@ -335,22 +413,23 @@ int channel_pcquit(struct map_session_data *sd, int type){
  *  -2 : delay msg too low since last talk
  */
 int channel_send(struct Channel *channel, struct map_session_data *sd, const char *msg) {
-	if(!channel || !sd || !msg)
+	int idx = 0;
+
+	if(!channel || !sd || !msg || (idx = channel_pc_haschan(sd, channel)) < 0)
 		return -1;
 
-	if(!pc_has_permission(sd, PC_PERM_CHANNEL_ADMIN) && channel->msg_delay != 0 && DIFF_TICK(sd->channel_tick + ( channel->msg_delay * 1000 ), gettick()) > 0) {
+	if(!pc_has_permission(sd, PC_PERM_CHANNEL_ADMIN) && channel->msg_delay != 0 && DIFF_TICK(sd->channel_tick[idx] + channel->msg_delay, gettick()) > 0) {
 		clif_colormes(sd->fd,color_table[COLOR_RED],msg_txt(sd,1455)); //You're talking too fast!
 		return -2;
 	}
 	else {
-		char message[CHAN_MSG_LENGTH], color;
-		if((channel->opt)&CHAN_OPT_COLOR_OVERRIDE && sd->fontcolor)
-			color = sd->fontcolor;
-		else
-			color = channel->color;
-		snprintf(message, CHAN_MSG_LENGTH, "[ #%s ] %s : %s",channel->name,sd->status.name, msg);
-		clif_channel_msg(channel,sd,message,color);
-		sd->channel_tick = gettick();
+		char output[CHAT_SIZE_MAX+1];
+		unsigned long color = channel->color;
+		if((channel->opt&CHAN_OPT_COLOR_OVERRIDE) && sd->fontcolor && sd->fontcolor < channel_config.colors_count && channel_config.colors[sd->fontcolor])
+			color = channel_config.colors[sd->fontcolor];
+		safesnprintf(output, CHAT_SIZE_MAX, "%s %s : %s", channel->alias, sd->status.name, msg);
+		clif_channel_msg(channel,output,color);
+		sd->channel_tick[idx] = gettick();
 	}
 	return 0;
 }
@@ -375,8 +454,8 @@ int channel_chk(char *chname, char *chpass, int type){
 		if ( strlen(chname) < 3 || strlen(chname) > CHAN_NAME_LENGTH )
 			return -2;
 		if( (type&2) && (
-			strcmpi(chname + 1,channel_config.map_chname) == 0
-			|| strcmpi(chname + 1,channel_config.ally_chname) == 0
+			strcmpi(chname + 1,channel_config.map_tmpl.name) == 0
+			|| strcmpi(chname + 1,channel_config.ally_tmpl.name) == 0
 			|| strdb_exists(channel_db, chname + 1) )
 			) {
 			return -4;
@@ -394,24 +473,24 @@ int channel_chk(char *chname, char *chpass, int type){
  * @chname : channel name
  * @sd : can be NULL, use to solve #map and #ally case
  * @flag&1 : create channel if not exist (map or ally only)
- * @flag&2 : join the channel (map or ally only)
+ * @flag&2 : join the channel if not joined yet (map or ally only)
  * return
  *  NULL : channel not found
  */
 struct Channel* channel_name2channel(char *chname, struct map_session_data *sd, int flag){
 	if(channel_chk(chname, NULL, 1))
 		return NULL;
-	if(sd && strcmpi(chname + 1,channel_config.map_chname) == 0){
+	if(sd && strcmpi(chname + 1,channel_config.map_tmpl.name) == 0){
 		if(flag&1 && !map[sd->bl.m].channel)
-			map[sd->bl.m].channel = channel_create(channel_config.map_chname,NULL,channel_config.map_chcolor,CHAN_TYPE_MAP,sd->bl.m);
-		if(flag&2)
+			map[sd->bl.m].channel = channel_create_simple(NULL,NULL,CHAN_TYPE_MAP,sd->bl.m);
+		if(flag&2 && channel_pc_haschan(sd,map[sd->bl.m].channel) < 1)
 			channel_mjoin(sd);
 		return map[sd->bl.m].channel;
 	}
-	else if(sd && (strcmpi(chname + 1,channel_config.ally_chname) == 0) && sd->guild){
+	else if(sd && (strcmpi(chname + 1,channel_config.ally_tmpl.name) == 0) && sd->guild){
 		if(flag&1 && !sd->guild->channel)
-			sd->guild->channel = channel_create(channel_config.ally_chname,NULL,channel_config.ally_chcolor,CHAN_TYPE_ALLY,sd->guild->guild_id);
-		if(flag&2)
+			sd->guild->channel = channel_create_simple(NULL,NULL,CHAN_TYPE_ALLY,sd->guild->guild_id);
+		if(flag&2 && channel_pc_haschan(sd,map[sd->bl.m].channel) < 1)
 			channel_gjoin(sd,3);
 		return sd->guild->channel;
 	}
@@ -513,19 +592,21 @@ int channel_display_list(struct map_session_data *sd, char *options){
 		char output[128];
 
 		clif_displaymessage(sd->fd, msg_txt(sd,1410)); // ---- Public Channels ----
-		if( channel_config.map_enable && map[sd->bl.m].channel ) {
-			sprintf(output, msg_txt(sd,1409), channel_config.map_chname, map[sd->bl.m].channel ? db_size(map[sd->bl.m].channel->users) : 0);// - #%s (%d users)
+		if( channel_config.map_tmpl.name != NULL && map[sd->bl.m].channel ) {
+			sprintf(output, msg_txt(sd,1409), map[sd->bl.m].channel->name, db_size(map[sd->bl.m].channel->users));// - #%s (%d users)
 			clif_displaymessage(sd->fd, output);
 		}
-		if( channel_config.ally_enable && sd->status.guild_id ) {
+		if( channel_config.ally_tmpl.name != NULL && sd->status.guild_id ) {
 			struct guild *g = sd->guild;
 			if (g && g->channel) {
-				sprintf(output, msg_txt(sd,1409), channel_config.ally_chname, db_size(((struct Channel *)g->channel)->users));// - #%s (%d users)
+				sprintf(output, msg_txt(sd,1409), g->channel->name, db_size(((struct Channel *)g->channel)->users));// - #%s (%d users)
 				clif_displaymessage(sd->fd, output);
 			}
 		}
 		iter = db_iterator(channel_db);
 		for(channel = (struct Channel *)dbi_first(iter); dbi_exists(iter); channel = (struct Channel *)dbi_next(iter)) {
+			if (!has_perm && !channel_pccheckgroup(channel, sd->group_id))
+				continue;
 			if( has_perm || channel->type == CHAN_TYPE_PUBLIC ) {
 				sprintf(output, msg_txt(sd,1409), channel->name, db_size(channel->users));// - #%s (%d users)
 				clif_displaymessage(sd->fd, output);
@@ -544,7 +625,7 @@ int channel_display_list(struct map_session_data *sd, char *options){
  *  -1 : fail
  */
 int channel_pccreate(struct map_session_data *sd, char *chname, char *chpass){
-	char output[128];
+	char output[CHAT_SIZE_MAX];
 	int8 res;
 
 	if(!sd || !chname)
@@ -552,9 +633,9 @@ int channel_pccreate(struct map_session_data *sd, char *chname, char *chpass){
 
 	res = channel_chk(chname,chpass,7);
 	if(res==0){ //success
-		struct Channel *channel = channel_create(chname + 1,chpass,0,CHAN_TYPE_PRIVATE,sd->status.char_id);
+		struct Channel *channel = channel_create_simple(chname,chpass,CHAN_TYPE_PRIVATE,sd->status.char_id);
 		channel_join(channel,sd);
-		if( !( channel->opt & CHAN_OPT_ANNOUNCE_JOIN ) ) {
+		if( ( channel->opt & CHAN_OPT_ANNOUNCE_SELF ) ) {
 			sprintf(output, msg_txt(sd,1403),chname); // You're now in the '%s' channel.
 			clif_displaymessage(sd->fd, output);
 		}
@@ -594,7 +675,7 @@ int channel_pcdelete(struct map_session_data *sd, char *chname){
 		clif_displaymessage(sd->fd, output);
 		return -2; //channel doesn't exist or player don't have it
 	}
-	channel_delete(channel);
+	channel_delete(channel,false);
 
 	sprintf(output, msg_txt(sd,1448),chname); // Channel '%s' deleted.
 	clif_displaymessage(sd->fd, output);
@@ -627,10 +708,16 @@ int channel_pcleave(struct map_session_data *sd, char *chname){
 		return -2; //channel doesn't exist or player don't have it
 	}
 
-	if( !channel_config.closing && (channel->opt & CHAN_OPT_ANNOUNCE_JOIN) ) {
-		char message[60];
-		sprintf(message, "#%s '%s' left",channel->name,sd->status.name);
-		clif_channel_msg(channel,sd,message,channel->color);
+	if (!(channel->opt&CHAN_OPT_CAN_LEAVE)) {
+		sprintf(output, msg_txt(sd,883) ,chname); // You cannot leave '%s' channel.
+		clif_displaymessage(sd->fd, output);
+		return -1;
+	}
+
+	if( !channel_config.closing && (channel->opt & CHAN_OPT_ANNOUNCE_LEAVE) ) {
+		char output[CHAT_SIZE_MAX+1];
+		safesnprintf(output, CHAT_SIZE_MAX, msg_txt(sd,884), channel->alias, sd->status.name); // %s %s left
+		clif_channel_msg(channel,output,channel->color);
 	}
 	switch(channel->type){
 	case CHAN_TYPE_ALLY: channel_pcquit(sd,3); break;
@@ -664,6 +751,11 @@ int channel_pcjoin(struct map_session_data *sd, char *chname, char *pass){
 
 	channel = channel_name2channel(chname,sd,1);
 	if(channel){
+		if (!pc_has_permission(sd, PC_PERM_CHANNEL_ADMIN) && !channel_pccheckgroup(channel, sd->group_id)) {
+			sprintf(output, msg_txt(sd,1407), chname); // Channel '%s' is not available.
+			clif_displaymessage(sd->fd, output);
+			return -1;
+		}
 		if(channel_haspc(channel,sd)==1) {
 			sprintf(output, msg_txt(sd,1434),chname); // You're already in the '%s' channel.
 			clif_displaymessage(sd->fd, output);
@@ -687,16 +779,17 @@ int channel_pcjoin(struct map_session_data *sd, char *chname, char *pass){
 		return -1;
 	}
 
-	if( !( channel->opt & CHAN_OPT_ANNOUNCE_JOIN ) ) {
-		sprintf(output, msg_txt(sd,1403),chname); // You're now in the '%s' channel.
-		clif_displaymessage(sd->fd, output);
-	}
-
 	switch(channel->type){
 	case CHAN_TYPE_ALLY: channel_gjoin(sd,3); break;
 	case CHAN_TYPE_MAP: channel_mjoin(sd); break;
 	default: //private and public atm
-		channel_join(channel,sd);
+		if (channel_join(channel,sd) != 0)
+			return -1;
+	}
+
+	if( ( channel->opt & CHAN_OPT_ANNOUNCE_SELF ) ) {
+		sprintf(output, msg_txt(sd,1403),chname); // You're now in the '%s' channel.
+		clif_displaymessage(sd->fd, output);
 	}
 
 	return 0;
@@ -729,10 +822,17 @@ int channel_pccolor(struct map_session_data *sd, char *chname, char *color){
 		return -1;
 	}
 
-	if( channel->owner != sd->status.char_id && !pc_has_permission(sd, PC_PERM_CHANNEL_ADMIN) ) {
-		sprintf(output, msg_txt(sd,1412), chname);// You're not the owner of channel '%s'.
-		clif_displaymessage(sd->fd, output);
-		return -1;
+	if( !pc_has_permission(sd, PC_PERM_CHANNEL_ADMIN) ) {
+		if (channel->char_id != sd->status.char_id) {
+			sprintf(output, msg_txt(sd,1412), chname);// You're not the owner of channel '%s'.
+			clif_displaymessage(sd->fd, output);
+			return -1;
+		}
+		else if (!(channel->opt&CHAN_OPT_COLOR_OVERRIDE)) {
+			sprintf(output, msg_txt(sd,885), chname); // Cannot set color_override for this channel '%s'.
+			clif_displaymessage(sd->fd, output);
+			return -1;
+		}
 	}
 
 	ARR_FIND(0,channel_config.colors_count,k,( strcmpi(color,channel_config.colors_name[k]) == 0 ) );
@@ -812,7 +912,7 @@ int channel_pcunbind(struct map_session_data *sd){
  */
 int channel_pcban(struct map_session_data *sd, char *chname, char *pname, int flag){
 	struct Channel *channel;
-	char output[128];
+	char output[CHAT_SIZE_MAX];
 	struct map_session_data *tsd = map_nick2sd(pname);
 
 	if( channel_chk(chname,NULL,1) ) {
@@ -827,9 +927,14 @@ int channel_pcban(struct map_session_data *sd, char *chname, char *pname, int fl
 		return -1;
 	}
 
-	if( channel->owner != sd->status.char_id && !pc_has_permission(sd, PC_PERM_CHANNEL_ADMIN) ) {
-		sprintf(output, msg_txt(sd,1412), chname);// You're not the owner of channel '%s'.
-		clif_displaymessage(sd->fd, output);
+	if( !pc_has_permission(sd, PC_PERM_CHANNEL_ADMIN) ) {
+		if (channel->char_id != sd->status.char_id) {
+			sprintf(output, msg_txt(sd,1412), chname);// You're not the owner of channel '%s'.
+			clif_displaymessage(sd->fd, output);
+		} else if (!channel_config.private_channel.ban) {
+			sprintf(output, msg_txt(sd,886), chname); // Not allowed to ban a player.
+			clif_displaymessage(sd->fd, output);
+		}
 		return -1;
 	}
 
@@ -891,7 +996,10 @@ int channel_pcban(struct map_session_data *sd, char *chname, char *pname, int fl
 		sprintf(output, msg_txt(sd,1443), channel->name);// ---- '#%s' Ban List:
 		clif_displaymessage(sd->fd, output);
 		for( cbe = (struct chan_banentry *)dbi_first(iter); dbi_exists(iter); cbe = (struct chan_banentry *)dbi_next(iter) ) { //for all users
-			sprintf(output, "%d: %s",cbe->char_id,cbe->char_name);
+			if (cbe->char_name && cbe->char_name[0] != '\0')
+				sprintf(output, "%d: %s",cbe->char_id,cbe->char_name);
+			else
+				sprintf(output, "%d: ****",cbe->char_id);
 			clif_displaymessage(sd->fd, output);
 		}
 		dbi_destroy(iter);
@@ -903,6 +1011,66 @@ int channel_pcban(struct map_session_data *sd, char *chname, char *pname, int fl
 	return 0;
 }
 
+int channel_pckick(struct map_session_data *sd, char *chname, char *pname, int flag) {
+	struct Channel *channel;
+	char output[CHAT_SIZE_MAX];
+	struct map_session_data *tsd = map_nick2sd(pname);
+
+	if( channel_chk(chname,NULL,1) ) {
+		clif_displaymessage(sd->fd, msg_txt(sd,1405));// Channel name must start with '#'.
+		return -1;
+	}
+
+	channel = channel_name2channel(chname,sd,0);
+	if( !channel ) {
+		sprintf(output, msg_txt(sd,1407), chname);// Channel '%s' is not available.
+		clif_displaymessage(sd->fd, output);
+		return -1;
+	}
+
+	if (!tsd) {
+		clif_displaymessage(sd->fd, msg_txt(sd,3));
+		return -1;
+	}
+
+	if( !pc_has_permission(sd, PC_PERM_CHANNEL_ADMIN) ) {
+		if (channel->char_id != sd->status.char_id) {
+			sprintf(output, msg_txt(sd,1412), chname);// You're not the owner of channel '%s'.
+			clif_displaymessage(sd->fd, output);
+		} else if (!channel_config.private_channel.kick) {
+			sprintf(output, msg_txt(sd,887), chname); // Not allowed to kick a player.
+			clif_displaymessage(sd->fd, output);
+		}
+		return -1;
+	}
+
+	if (channel_pc_haschan(sd, channel) < 0) {
+		sprintf(output, msg_txt(sd,888), pname, chname); // Player '%s' not join channel '%s'.
+		clif_displaymessage(sd->fd, output);
+		return -1;
+	}
+
+	if (channel->char_id == sd->status.char_id) {
+		clif_displaymessage(sd->fd, msg_txt(sd, 888)); // Not allowed to kick a player.
+		return -1;
+	}
+
+	if( !channel_config.closing && (channel->opt & CHAN_OPT_ANNOUNCE_LEAVE) ) {
+		char output[CHAT_SIZE_MAX+1];
+		safesnprintf(output, CHAT_SIZE_MAX, msg_txt(sd,889), channel->alias, tsd->status.name); // %s %s is kicked
+		clif_channel_msg(channel,output,channel->color);
+	}
+
+	switch(channel->type){
+		case CHAN_TYPE_ALLY: channel_pcquit(tsd,3); break;
+		case CHAN_TYPE_MAP: channel_pcquit(tsd,4); break;
+		default: //private and public atm
+			channel_clean(channel,tsd,0);
+	}
+
+	return 1;
+}
+
 /*
  * A user *sd is attempting to set an option on channel named *chname
  * @chname = channel name
@@ -914,13 +1082,18 @@ int channel_pcban(struct map_session_data *sd, char *chname, char *pname, int fl
  */
 int channel_pcsetopt(struct map_session_data *sd, char *chname, const char *option, const char *val){
 	struct Channel *channel;
-	char output[128];
-	int k, s=0;
+	char output[CHAT_SIZE_MAX];
+	int k, s = 0, opt;
 	const char* opt_str[] = {
 		"None",
+		"SelfAnnounce",
 		"JoinAnnounce",
+		"LeaveAnnounce",
 		"MessageDelay",
 		"ColorOverride",
+		"CanChat",
+		"CanLeave",
+		"Autojoin",
 	};
 
 	if( channel_chk(chname,NULL,1) ) {
@@ -928,6 +1101,9 @@ int channel_pcsetopt(struct map_session_data *sd, char *chname, const char *opti
 		return -1;
 	}
 
+	if (!sd)
+		return - 1;
+
 	channel = channel_name2channel(chname,sd,0);
 	if( !channel ) {
 		sprintf(output, msg_txt(sd,1407), chname);// Channel '%s' is not available.
@@ -935,7 +1111,7 @@ int channel_pcsetopt(struct map_session_data *sd, char *chname, const char *opti
 		return -1;
 	}
 
-	if( channel->owner != sd->status.char_id && !pc_has_permission(sd, PC_PERM_CHANNEL_ADMIN) ) {
+	if( sd && channel->char_id != sd->status.char_id && !pc_has_permission(sd, PC_PERM_CHANNEL_ADMIN) ) {
 		sprintf(output, msg_txt(sd,1412), chname);// You're not the owner of channel '%s'.
 		clif_displaymessage(sd->fd, output);
 		return -1;
@@ -954,57 +1130,72 @@ int channel_pcsetopt(struct map_session_data *sd, char *chname, const char *opti
 		return -1;
 	}
 
+	opt = 1<<(k-1);
+
+	if (channel->type == CHAN_TYPE_PRIVATE && !pc_has_permission(sd, PC_PERM_CHANNEL_ADMIN)) {
+		switch (opt) {
+			case CHAN_OPT_MSG_DELAY:
+				if (!channel_config.private_channel.change_delay)
+					return -1;
+				break;
+			case CHAN_OPT_COLOR_OVERRIDE:
+				if (!channel_config.private_channel.color_override)
+					return -1;
+				break;
+		}
+	}
+
 	if( val[0] == '\0' ) {
-		if ( k == CHAN_OPT_MSG_DELAY ) {
+		if ( opt == CHAN_OPT_MSG_DELAY ) {
 			sprintf(output, msg_txt(sd,1466), opt_str[k]);// Input the number of seconds (0-10) for the '%s' option.
 			clif_displaymessage(sd->fd, output);
 			return -1;
-		} else if( channel->opt & k ) {
+		} else if( channel->opt & opt ) {
 			sprintf(output, msg_txt(sd,1449), opt_str[k],opt_str[k]); // Option '%s' is already enabled (use '@channel setopt %s 0' to disable).
 			clif_displaymessage(sd->fd, output);
 			return -1;
 		} else {
-			channel->opt |= k;
+			channel->opt |= opt;
 			sprintf(output, msg_txt(sd,1450), opt_str[k],channel->name);// Option '%s' is enabled for channel '#%s'.
 			clif_displaymessage(sd->fd, output);
 		}
 	} else {
 		int v = atoi(val);
-		if( k == CHAN_OPT_MSG_DELAY ) {
+		if( opt == CHAN_OPT_MSG_DELAY ) {
 			if( v < 0 || v > 10 ) {
 				sprintf(output, msg_txt(sd,1451), v, opt_str[k]);// Value '%d' for option '%s' is out of range (limit 0-10).
 				clif_displaymessage(sd->fd, output);
 				return -1;
 			}
 			if( v == 0 ) {
-				channel->opt &=~ k;
+				channel->opt &=~ opt;
 				channel->msg_delay = 0;
 				sprintf(output, msg_txt(sd,1453), opt_str[k],channel->name,v);// Option '%s' is disabled for channel '#%s'.
 				clif_displaymessage(sd->fd, output);
 			} else {
-				channel->opt |= k;
-				channel->msg_delay = v;
+				channel->opt |= opt;
+				channel->msg_delay = v * 1000;
 				sprintf(output, msg_txt(sd,1452), opt_str[k],channel->name,v);// Option '%s' is enabled for channel '#%s' at %d seconds.
 				clif_displaymessage(sd->fd, output);
 			}
 		} else {
 			if( v ) {
-				if( channel->opt & k ) {
+				if( channel->opt & opt ) {
 					sprintf(output, msg_txt(sd,1449), opt_str[k],opt_str[k]); // Option '%s' is already enabled (use '@channel setopt %s 0' to disable).
 					clif_displaymessage(sd->fd, output);
 					return -1;
 				} else {
-					channel->opt |= k;
+					channel->opt |= opt;
 					sprintf(output, msg_txt(sd,1450), opt_str[k],channel->name);// Option '%s' is enabled for channel '#%s'.
 					clif_displaymessage(sd->fd, output);
 				}
 			} else {
-				if( !(channel->opt & k) ) {
+				if( !(channel->opt & opt) ) {
 					sprintf(output, msg_txt(sd,1450), opt_str[k],channel->name); // Option '%s' is enabled for channel '#%s'.
 					clif_displaymessage(sd->fd, output);
 					return -1;
 				} else {
-					channel->opt &=~ k;
+					channel->opt &=~ opt;
 					sprintf(output, msg_txt(sd,1453), opt_str[k],channel->name);// Option '%s' is disabled for channel '#%s'.
 					clif_displaymessage(sd->fd, output);
 				}
@@ -1014,66 +1205,179 @@ int channel_pcsetopt(struct map_session_data *sd, char *chname, const char *opti
 	return 0;
 }
 
-/*
- * Read and verify configuration in confif_filename
- * Assign table value with value
- */
-void channel_read_config(void) {
-	config_t channels_conf;
-	config_setting_t *chsys = NULL;
-	const char *config_filename = "conf/channels.conf"; // FIXME hardcoded name
+bool channel_pccheckgroup(struct Channel *channel, int group_id) {
+	int i;
+
+	nullpo_ret(channel);
+
+	if (!channel->groups || !channel->group_count)
+		return true;
+
+	for (i = 0; i < channel->group_count; i++) {
+		if (channel->groups[i] == group_id)
+			return true;
+	}
+
+	return false;
+}
+
+int channel_pcautojoin_sub(DBKey key, DBData *data, va_list ap) {
+	struct Channel *channel = (struct Channel *)db_data2ptr(data);
+	struct map_session_data *sd = NULL;
+	char channame[CHAN_NAME_LENGTH+1];
+
+	nullpo_ret(channel);
+	nullpo_ret((sd = va_arg(ap, struct map_session_data *)));
+
+	if (channel->pass && channel->pass[0] != '\0')
+		return 0;
+	if (!(channel->opt&CHAN_OPT_AUTOJOIN))
+		return 0;
+	if (!pc_has_permission(sd, PC_PERM_CHANNEL_ADMIN) && !channel_pccheckgroup(channel, sd->group_id))
+		return 0;
+	safesnprintf(channame, sizeof(channame), "#%s", channel->name);
+	channel_pcjoin(sd, channame, NULL);
+
+	return 1;
+}
 
-	if (conf_read_file(&channels_conf, config_filename))
+void channel_autojoin(struct map_session_data *sd) {
+	nullpo_retv(sd);
+	if (sd->state.autotrade || !sd->fd)
 		return;
+	channel_db->foreach(channel_db, channel_pcautojoin_sub, sd);
+}
+
+int channel_pcisjoined_sub(DBKey key, DBData *data, va_list ap) {
+	unsigned int char_id = (unsigned int)db_data2ptr(data);
+	struct map_session_data *sd = NULL;
+
+	nullpo_ret(char_id);
+	nullpo_ret((sd = va_arg(ap, struct map_session_data *)));
+
+	if (char_id == sd->status.char_id)
+		return 1;
 
-	chsys = config_lookup(&channels_conf, "chsys");
+	return 0;
+}
 
-	if (chsys != NULL) {
-		config_setting_t *settings = config_setting_get_elem(chsys, 0);
-		config_setting_t *channels;
-		config_setting_t *colors;
-		int i,k;
-		const char *map_chname, *ally_chname,*map_color, *ally_color;
-		int ally_enabled = 0, local_enabled = 0;
-		int local_autojoin = 0, ally_autojoin = 0;
-		int allow_user_channel_creation = 0;
+bool channel_pcisjoined(struct Channel *channel, struct map_session_data *sd) {
+	nullpo_ret(channel);
+	nullpo_ret(sd);
 
-		if( !config_setting_lookup_string(settings, "map_local_channel_name", &map_chname) )
-			map_chname = "map";
-		safestrncpy(channel_config.map_chname, map_chname, CHAN_NAME_LENGTH);
+	if (channel->users)
+		return channel->users->foreach(channel->users, channel_pcisjoined_sub);
 
-		if( !config_setting_lookup_string(settings, "ally_channel_name", &ally_chname) )
-			ally_chname = "ally";
-		safestrncpy(channel_config.ally_chname, ally_chname, CHAN_NAME_LENGTH);
+	return false;
+}
+
+/**
+ * Get color by name or RGB hex code
+ * @Param color_str Color name
+ * @return Color in BGR
+ **/
+unsigned long channel_getColor(char *color_str) {
+	int i;
+	for (i = 0; i < channel_config.colors_count; i++) {
+		if (strcmpi(channel_config.colors_name[i], color_str) == 0)
+			return channel_config.colors[i];
+	}
+	return 1;
+}
 
-		config_setting_lookup_bool(settings, "map_local_channel", &local_enabled);
-		config_setting_lookup_bool(settings, "ally_channel_enabled", &ally_enabled);
+bool channel_read_sub(config_setting_t *chan, struct Channel *tmp_chan, uint8 i) {
+	config_setting_t  *group_list = NULL;
+	int id = 0;
+	int delay = 1000, autojoin = 0, leave = 1, chat = 1, color_override = 0,
+		self_notif = 1, join_notif = 0, leave_notif = 0;
+	int type = CHAN_TYPE_PUBLIC, group_count = 0;
+	char *name = NULL, *password = NULL, *alias = NULL, *color_str = "Default", *type_str = NULL;
+
+	if (tmp_chan == NULL)
+		return false;
+
+	//config_setting_lookup_int(chan, "id", &id); // Unused yet
+	if (!config_setting_lookup_string(chan, "name", &name)) {
+		ShowError("Please input channel 'name' at '%s' line '%d'! Skipping...\n", chan->file, chan->line);
+		return false;
+	}
+	if (config_setting_lookup_string(chan, "type", &type_str) && !script_get_constant(type_str, &type)) {
+		ShowError("Invalid channel type %s at '%s' line '%d'! Skipping...\n", type_str, chan->file, chan->line);
+		return false;
+	}
+	config_setting_lookup_string(chan, "password", &password);
+	config_setting_lookup_string(chan, "alias", &alias);
+	config_setting_lookup_string(chan, "color", &color_str);
+	config_setting_lookup_int(chan, "delay", &delay);
+	config_setting_lookup_bool(chan, "autojoin", &autojoin);
+	config_setting_lookup_bool(chan, "leave", &leave);
+	config_setting_lookup_bool(chan, "chat", &chat);
+	config_setting_lookup_bool(chan, "color_override", &color_override);
+	config_setting_lookup_bool(chan, "self_notif", &self_notif);
+	config_setting_lookup_bool(chan, "join_notif", &join_notif);
+	config_setting_lookup_bool(chan, "leave_notif", &leave_notif);
+
+	//tmp_chan->id = id;
+	safestrncpy(tmp_chan->name,name+1,sizeof(tmp_chan->name));
+	if (password)
+		safestrncpy(tmp_chan->pass,password,sizeof(tmp_chan->pass));
+	else
+		tmp_chan->pass[0] = '\0';
+	safestrncpy(tmp_chan->alias,alias?alias:name,sizeof(tmp_chan->alias));
+	tmp_chan->msg_delay = delay;
+	tmp_chan->type = (enum Channel_Type)type;
+	tmp_chan->color = channel_getColor(color_str);
+
+	tmp_chan->opt = (autojoin ? CHAN_OPT_AUTOJOIN : 0) |
+		(leave ? CHAN_OPT_CAN_LEAVE : 0) |
+		(chat ? CHAN_OPT_CAN_CHAT : 0) |
+		(color_override ? CHAN_OPT_COLOR_OVERRIDE : 0) |
+		(self_notif ? CHAN_OPT_ANNOUNCE_SELF : 0) |
+		(join_notif ? CHAN_OPT_ANNOUNCE_JOIN : 0) |
+		(leave_notif ? CHAN_OPT_ANNOUNCE_LEAVE : 0);
+
+	if ((group_list = config_setting_get_member(chan, "groupid")) && (group_count = config_setting_length(group_list)) > 0) {
+		int j;
+		CREATE(tmp_chan->groups, unsigned short, group_count);
+		tmp_chan->group_count = group_count;
+		for (j = 0; j < group_count; j++) {
+			int groupid = config_setting_get_int_elem(group_list, j);
+			tmp_chan->groups[j] = groupid;
+		}
+	}
 
-		if( local_enabled )
-			channel_config.map_enable = true;
-		if( ally_enabled )
-			channel_config.ally_enable = true;
+	return true;
+}
 
-		config_setting_lookup_bool(settings, "map_local_channel_autojoin", &local_autojoin);
-		config_setting_lookup_bool(settings, "ally_channel_autojoin", &ally_autojoin);
+/*
+ * Read and verify configuration in confif_filename
+ * Assign table value with value
+ */
+void channel_read_config(void) {
+	config_t channels_conf;
+	config_setting_t *chsys = NULL;
+	config_setting_t *colors = NULL;
+	config_setting_t *chan_setting = NULL;
 
-		if( local_autojoin )
-			channel_config.map_autojoin = true;
-		if( ally_autojoin )
-			channel_config.ally_autojoin = true;
+	if (conf_read_file(&channels_conf, channel_conf)) {
+		ShowError("Cannot read file '%s' for channel connfig.\n", channel_conf);
+		return;
+	}
 
-		config_setting_lookup_bool(settings, "allow_user_channel_creation", &allow_user_channel_creation);
+	chan_setting = config_lookup(&channels_conf, "channel_config");
+	if (chan_setting != NULL) {
+		config_setting_t *colors, *private_channel = NULL, *channels = NULL;
+		int count = 0, channel_count = 0;
 
-		if( allow_user_channel_creation )
-			channel_config.user_chenable = true;
+		colors = config_setting_get_member(chan_setting, "colors");
+		if (colors != NULL) {
+			int i, color_count = config_setting_length(colors);
 
-		if( (colors = config_setting_get_member(settings, "colors")) != NULL ) {
-			int color_count = config_setting_length(colors);
-			CREATE( channel_config.colors, unsigned long, color_count );
-			CREATE( channel_config.colors_name, char *, color_count );
-			for(i = 0; i < color_count; i++) {
+			CREATE(channel_config.colors, unsigned long, color_count);
+			CREATE(channel_config.colors_name, char *, color_count);
+			for (i = 0; i < color_count; i++) {
 				config_setting_t *color = config_setting_get_elem(colors, i);
-				CREATE( channel_config.colors_name[i], char, CHAN_NAME_LENGTH );
+				CREATE(channel_config.colors_name[i], char, CHAN_NAME_LENGTH);
 
 				safestrncpy(channel_config.colors_name[i], config_setting_name(color), CHAN_NAME_LENGTH);
 				channel_config.colors[i] = strtoul(config_setting_get_string_elem(colors,i),NULL,0);
@@ -1082,58 +1386,71 @@ void channel_read_config(void) {
 			channel_config.colors_count = color_count;
 		}
 
-		config_setting_lookup_string(settings, "map_local_channel_color", &map_color);
-
-		for (k = 0; k < channel_config.colors_count; k++) {
-			if( strcmpi(channel_config.colors_name[k],map_color) == 0 )
-				break;
-		}
-
-		if( k < channel_config.colors_count ) {
-			channel_config.map_chcolor = k;
-		} else {
-			ShowError("channels.conf: unknown color '%s' for 'map_local_channel_color', disabling '#%s'...\n",map_color,map_chname);
-			channel_config.map_enable = false;
+		private_channel = config_setting_get_member(chan_setting, "private_channel");
+		if (private_channel != NULL) {
+			int allow = 1, ban = 1, kick = 1, color_override = 0, change_delay = 0,
+				self_notif = 1, join_notif = 0, leave_notif = 0,
+				delay = 1000, max_member = 1000;
+			char *color_str = "Default";
+
+			config_setting_lookup_bool(private_channel, "allow", &allow);
+			config_setting_lookup_int(private_channel, "delay", &delay);
+			config_setting_lookup_string(private_channel, "color", &color_str);
+			config_setting_lookup_int(private_channel, "max_member", &max_member);
+			config_setting_lookup_bool(private_channel, "self_notif", &self_notif);
+			config_setting_lookup_bool(private_channel, "join_notif", &join_notif);
+			config_setting_lookup_bool(private_channel, "leave_notif", &leave_notif);
+			config_setting_lookup_bool(private_channel, "ban", &ban);
+			config_setting_lookup_bool(private_channel, "kick", &kick);
+			config_setting_lookup_bool(private_channel, "color_override", &color_override);
+			config_setting_lookup_bool(private_channel, "change_delay", &change_delay);
+
+			channel_config.private_channel.allow = allow;
+			channel_config.private_channel.color = channel_getColor(color_str);
+			channel_config.private_channel.delay = delay;
+			channel_config.private_channel.max_member = min(max_member, UINT16_MAX);
+			channel_config.private_channel.ban = ban;
+			channel_config.private_channel.kick = kick;
+			channel_config.private_channel.color_override = color_override;
+			channel_config.private_channel.change_delay = change_delay;
+			channel_config.private_channel.opt = CHAN_OPT_CAN_CHAT|CHAN_OPT_CAN_LEAVE|
+				(color_override ? CHAN_OPT_COLOR_OVERRIDE : 0) |
+				(self_notif ? CHAN_OPT_ANNOUNCE_SELF : 0) |
+				(join_notif ? CHAN_OPT_ANNOUNCE_JOIN : 0) |
+				(leave_notif ? CHAN_OPT_ANNOUNCE_LEAVE : 0);
 		}
 
-		config_setting_lookup_string(settings, "ally_channel_color", &ally_color);
-
-		for (k = 0; k < channel_config.colors_count; k++) {
-			if( strcmpi(channel_config.colors_name[k],ally_color) == 0 )
-				break;
+		channels = config_setting_get_member(chan_setting, "ally");
+		if (channels != NULL) {
+			memset(&channel_config.ally_tmpl, 0, sizeof(struct Channel));
+			channel_read_sub(channels, &channel_config.ally_tmpl, 0);
 		}
-
-		if( k < channel_config.colors_count ) {
-			channel_config.ally_chcolor = k;
-		} else {
-			ShowError("channels.conf: unknown color '%s' for 'ally_channel_color', disabling '#%s'...\n",ally_color,ally_chname);
-			channel_config.ally_enable = false;
+		channels = config_setting_get_member(chan_setting, "map");
+		if (channels != NULL) {
+			memset(&channel_config.map_tmpl, 0, sizeof(struct Channel));
+			channel_read_sub(channels, &channel_config.map_tmpl, 0);
 		}
 
-		if( (channels = config_setting_get_member(settings, "default_channels")) != NULL ) {
-			int channel_count = config_setting_length(channels);
+		channels = config_setting_get_member(chan_setting, "channels");
+		if (channels != NULL && (count = config_setting_length(channels)) > 0) {
+			int i;
+			for (i = 0; i < count; i++) {
+				config_setting_t *chan = config_setting_get_elem(channels, i);
+				struct Channel *channel = NULL, tmp_chan;
 
-			for(i = 0; i < channel_count; i++) {
-				config_setting_t *channel = config_setting_get_elem(channels, i);
-				const char *color = config_setting_get_string_elem(channels,i);
-				char *name = config_setting_name(channel);
-				for (k = 0; k < channel_config.colors_count; k++) {
-					if( strcmpi(channel_config.colors_name[k],color) == 0 )
-						break;
-				}
-				if( k == channel_config.colors_count ) {
-					ShowError("channels.conf: unknown color '%s' for channel '%s', skipping channel...\n",color,name);
-					continue;
-				}
-				if( strcmpi(name,channel_config.map_chname) == 0 || strcmpi(name,channel_config.ally_chname) == 0 || strdb_exists(channel_db, name) ) {
-					ShowError("channels.conf: duplicate channel '%s', skipping channel...\n",name);
+				memset(&tmp_chan, 0, sizeof(struct Channel));
+				if (!channel_read_sub(chan, &tmp_chan, i))
 					continue;
+
+				if ((channel = channel_create(&tmp_chan))) {
+					channel_count++;
+					channel->group_count = tmp_chan.group_count;
+					channel->groups = tmp_chan.groups;
 				}
-				channel_create(name,NULL,k,CHAN_TYPE_PUBLIC,0);
 			}
 		}
 
-		ShowStatus("Done reading '"CL_WHITE"%d"CL_RESET"' channels in '"CL_WHITE"%s"CL_RESET"'.\n", db_size(channel_db), config_filename);
+		ShowStatus("Done reading '"CL_WHITE"%d"CL_RESET"' channels in '"CL_WHITE"%s"CL_RESET"'.\n", db_size(channel_db), channel_conf);
 		config_destroy(&channels_conf);
 	}
 }
@@ -1145,7 +1462,9 @@ void channel_read_config(void) {
  */
 void do_init_channel(void) {
 	channel_db = stridb_alloc(DB_OPT_DUP_KEY|DB_OPT_RELEASE_DATA, CHAN_NAME_LENGTH);
-	channel_config.ally_enable = channel_config.map_enable = channel_config.ally_autojoin = channel_config.map_autojoin = false;
+	memset(&channel_config.private_channel, 0, sizeof(struct Channel));
+	memset(&channel_config.ally_tmpl, 0, sizeof(struct Channel));
+	memset(&channel_config.map_tmpl, 0, sizeof(struct Channel));
 	channel_read_config();
 }
 
@@ -1160,7 +1479,7 @@ void do_final_channel(void) {
 	//delete all in remaining chan db
 	iter = db_iterator(channel_db);
 	for( channel = (struct Channel *)dbi_first(iter); dbi_exists(iter); channel = (struct Channel *)dbi_next(iter) ) {
-		channel_delete(channel);
+		channel_delete(channel,false);
 	}
 	dbi_destroy(iter);
 	//at this point all user should have left their channel (private and public should be gone)
diff --git a/src/map/channel.h b/src/map/channel.h
index a57af60161d..54c3078187f 100644
--- a/src/map/channel.h
+++ b/src/map/channel.h
@@ -14,49 +14,79 @@ extern "C" {
 #define CHAN_MSG_LENGTH 150
 
 enum Channel_Opt {
-	CHAN_OPT_BASE		= 0,
-	CHAN_OPT_ANNOUNCE_JOIN	= 1,	//display message when join or leave
-	CHAN_OPT_MSG_DELAY	= 2,
-	CHAN_OPT_COLOR_OVERRIDE = 3,
+	CHAN_OPT_NONE		    = 0,	///< None
+	CHAN_OPT_ANNOUNCE_SELF  = 0x01,	///< Shows info when player joined/left channel to self
+	CHAN_OPT_ANNOUNCE_JOIN  = 0x02,	///< Shows info if player joined the channel
+	CHAN_OPT_ANNOUNCE_LEAVE = 0x04,	///< Shows info if player left the channel
+	CHAN_OPT_MSG_DELAY	    = 0x08,	///< Enables chat delay
+	CHAN_OPT_COLOR_OVERRIDE = 0x10,	///< Enables color channel be override by player's font color
+	CHAN_OPT_CAN_CHAT		= 0x20,	///< Allows player to chat in the channel
+	CHAN_OPT_CAN_LEAVE		= 0x40,	///< Allows player to leave the channel
+	CHAN_OPT_AUTOJOIN		= 0x80,	///< Player will be autojoined to the channel
+
+	CHAN_OPT_BASE = CHAN_OPT_ANNOUNCE_SELF|CHAN_OPT_MSG_DELAY|CHAN_OPT_CAN_CHAT|CHAN_OPT_CAN_LEAVE,
 };
 
 enum Channel_Type {
-	CHAN_TYPE_PUBLIC	= 0,	//config file made
-	CHAN_TYPE_PRIVATE	= 1,	//user made
-	CHAN_TYPE_MAP		= 2,	//made by map
-	CHAN_TYPE_ALLY		= 3,	//guild
+	CHAN_TYPE_PUBLIC  = 0, ///< Config file made
+	CHAN_TYPE_PRIVATE = 1, ///< User's channel
+	CHAN_TYPE_MAP	  = 2, ///< Local map
+	CHAN_TYPE_ALLY	  = 3, ///< Guild + its alliance
 };
 
-struct Channel_Config {
-	unsigned long *colors;		//color avail int list
-	char **colors_name;		//colors avail name list
-	unsigned char colors_count;	//color avail count
-	unsigned char map_chcolor, ally_chcolor; //msg color for map, ally
-	bool map_enable, ally_enable, user_chenable; //map, ally, users channels enable ?
-	bool map_autojoin, ally_autojoin;	//do user auto join in mapchange, guildjoin ?
-	char map_chname[CHAN_NAME_LENGTH], ally_chname[CHAN_NAME_LENGTH]; //channel name for map and ally
-	bool closing;			//server is closing
+struct Channel {
+	//unsigned short id;			  ///< Channel ID (unused yet)
+	char name[CHAN_NAME_LENGTH];  ///< Channel Name
+	char pass[CHAN_NAME_LENGTH];  ///< Channe display name
+	char alias[CHAN_NAME_LENGTH]; ///< Password
+	enum Channel_Type type;		  ///< Channel type @see enum Channel_Type
+	unsigned long color;		  ///< Channel color in BGR
+	unsigned char opt;			  ///< Channel options @see enum Channel_Opt
+	unsigned short msg_delay;	  ///< Chat delay in miliseconds
+	unsigned int char_id;		  ///< If CHAN_TYPE_PRIVATE, owner is char_id of channel creator
+	uint16 m;					  ///< If CHAN_TYPE_MAP, owner is map id
+	int gid;					  ///< If CHAN_TYPE_ALLY, owner is first logged guild_id
+	DBMap *users;				  ///< List of users
+	DBMap *banned;				  ///< List of banned chars -> char_id
+	unsigned short group_count;	  ///< Number of group id
+	unsigned short *groups;		  ///< List of group id, only these groups can join the channel
 };
-extern struct Channel_Config channel_config;
 
-struct Channel {
-	char name[CHAN_NAME_LENGTH];	//channel name
-	char pass[CHAN_NAME_LENGTH];	//channel password
-	unsigned char color;		//msg color
-	DBMap *users;			//users in channel charid list
-	DBMap *banned;			//users banned from channel charid list
-	enum Channel_Opt opt;		//flag for some treatement
-	enum Channel_Type type;		//type of channel
-	unsigned int owner;		//if chan_type private charid of creator
-	uint16 m;			//if chan_type map guild_id
-	int gid;			//if chan_type guild type guild_id
-	unsigned char msg_delay;	//delay in second if opt_msg_delay
+struct chan_banentry {
+	uint32 char_id;
+	char char_name[NAME_LENGTH];
+} chan_banentry;
+
+struct Channel_Config {
+	unsigned long *colors;		///< List of available colors
+	char **colors_name;			///< Name list of available colors
+	unsigned char colors_count;	///< Number of available colors
+
+	/// Private channel default configs
+	struct {
+		unsigned char opt;			 ///< Options @see enum Channel_Opt
+		unsigned long color;		 ///< Default color
+		unsigned int delay;			 ///< Message delay
+		unsigned short max_member;	 ///< Max member for each channel
+		unsigned allow : 1;			 ///< Allow private channel creation?
+		unsigned ban : 1;			 ///< Allow player to ban
+		unsigned kick : 1;			 ///< Allow player to kick
+		unsigned color_override : 1; ///< Owner cannot change the color_override
+		unsigned change_delay : 1;	 ///< Owner cannot change the delay
+	} private_channel;
+
+	struct Channel map_tmpl;  ///< Map channel default config
+	struct Channel ally_tmpl; ///< Alliance channel default config
+
+	bool closing; ///< Server is closing
 };
+extern struct Channel_Config channel_config;
 
 DBMap* channel_get_db(void);
 
-struct Channel* channel_create(char *name, char *pass, unsigned char color, enum Channel_Type chantype, int val);
-int channel_delete(struct Channel *channel);
+struct Channel* channel_create(struct Channel *tmp_chan);
+struct Channel* channel_create_simple(char *name, char *pass, enum Channel_Type chantype, unsigned int owner);
+int channel_delete(struct Channel *channel, bool force);
 
 int channel_join(struct Channel *channel, struct map_session_data *sd);
 int channel_mjoin(struct map_session_data *sd);
@@ -65,6 +95,8 @@ int channel_ajoin(struct guild *g);
 int channel_clean(struct Channel *channel, struct map_session_data *sd, int flag);
 int channel_pcquit(struct map_session_data *sd, int type);
 
+unsigned long channel_getColor(char *color_str);
+
 int channel_send(struct Channel *channel, struct map_session_data *sd, const char *msg);
 void channel_read_config(void);
 
@@ -75,6 +107,10 @@ int channel_haspcbanned(struct Channel *channel,struct map_session_data *sd);
 int channel_pc_haschan(struct map_session_data *sd, struct Channel *channel);
 int channel_display_list(struct map_session_data *sd, char *option);
 
+void channel_autojoin(struct map_session_data *sd);
+bool channel_pcisjoined(struct Channel *channel, struct map_session_data *sd);
+bool channel_pccheckgroup(struct Channel *channel, int group_id);
+
 int channel_pccreate(struct map_session_data *sd, char *chname, char *pass);
 int channel_pcdelete(struct map_session_data *sd, char *chname);
 int channel_pcjoin(struct map_session_data *sd, char *chname, char *pass);
@@ -83,6 +119,7 @@ int channel_pccolor(struct map_session_data *sd, char *chname, char *color);
 int channel_pcbind(struct map_session_data *sd, char *chname);
 int channel_pcunbind(struct map_session_data *sd);
 int channel_pcban(struct map_session_data *sd, char *chname, char *pname, int flag);
+int channel_pckick(struct map_session_data *sd, char *chname, char *pname, int flag);
 int channel_pcsetopt(struct map_session_data *sd, char *chname, const char *option, const char *val);
 
 void do_init_channel(void);
diff --git a/src/map/clif.c b/src/map/clif.c
index 747f2531187..3db63741375 100644
--- a/src/map/clif.c
+++ b/src/map/clif.c
@@ -6138,31 +6138,35 @@ void clif_broadcast2(struct block_list* bl, const char* mes, int len, unsigned l
 }
 
 /*
- * Display *msg from *sd to all *users in channel
+ * Display *msg to all *users in channel
  */
-void clif_channel_msg(struct Channel *channel, struct map_session_data *sd, char *msg, short color) {
+void clif_channel_msg(struct Channel *channel, const char *msg, unsigned long color) {
 	DBIterator *iter;
 	struct map_session_data *user;
-	unsigned short msg_len = (unsigned short)(strlen(msg) + 1);
+	unsigned short msg_len = 0, len = 0;
+	unsigned char buf[12+CHAT_SIZE_MAX+1];
+
+	if (!channel || !msg)
+		return;
+
+	msg_len = (unsigned short)(strlen(msg) + 1);
+
+	if( msg_len > sizeof(buf)-12 ) {
+		ShowWarning("clif_channel_msg: Truncating too long message '%s' (len=%u).\n", msg, msg_len);
+		msg_len = sizeof(buf)-12;
+	}
 
-	WFIFOHEAD(sd->fd,msg_len + 12);
-	WFIFOW(sd->fd,0) = 0x2C1;
-	WFIFOW(sd->fd,2) = msg_len + 12;
-	WFIFOL(sd->fd,4) = 0;
-	WFIFOL(sd->fd,8) = channel_config.colors[color];
-	safestrncpy(WFIFOCP(sd->fd,12), msg, msg_len);
+	WBUFW(buf,0) = 0x2C1;
+	WBUFW(buf,2) = (len = msg_len + 12);
+	WBUFL(buf,4) = 0;
+	WBUFL(buf,8) = color;
+	safestrncpy(WBUFCP(buf,12), msg, msg_len);
 
 	iter = db_iterator(channel->users);
 	for( user = (struct map_session_data *)dbi_first(iter); dbi_exists(iter); user = (struct map_session_data *)dbi_next(iter) ) {
-		if( user->fd == sd->fd )
-			continue;
-		WFIFOHEAD(user->fd,msg_len + 12);
-		memcpy(WFIFOP(user->fd,0), WFIFOP(sd->fd,0), msg_len + 12);
-		WFIFOSET(user->fd, msg_len + 12);
+		clif_send(buf, len, &user->bl, SELF);
 	}
 	dbi_destroy(iter);
-
-	WFIFOSET(sd->fd, msg_len + 12);
 }
 
 /// Displays heal effect.
@@ -10335,7 +10339,7 @@ void clif_parse_LoadEndAck(int fd,struct map_session_data *sd)
 #endif
 
 		// Instances do not need their own channels
-		if( channel_config.map_enable && channel_config.map_autojoin && !map[sd->bl.m].flag.chmautojoin && !map[sd->bl.m].instance_id )
+		if( channel_config.map_tmpl.name != NULL && (channel_config.map_tmpl.opt&CHAN_OPT_AUTOJOIN) && !map[sd->bl.m].flag.chmautojoin && !map[sd->bl.m].instance_id )
 			channel_mjoin(sd); //join new map
 	} else if (sd->guild && (battle_config.guild_notice_changemap == 2 || guild_notice))
 		clif_guild_notice(sd); // Displays at end
@@ -10663,7 +10667,7 @@ void clif_parse_GlobalMessage(int fd, struct map_session_data* sd)
 	if( !clif_process_message(sd, false, name, message, output ) )
 		return;
 
-	if( sd->gcbind ) {
+	if( sd->gcbind && ((sd->gcbind->opt&CHAN_OPT_CAN_CHAT) || pc_has_permission(sd, PC_PERM_CHANNEL_ADMIN)) ) {
 		channel_send(sd->gcbind,sd,message);
 		return;
 	}
@@ -11019,12 +11023,13 @@ void clif_parse_WisMessage(int fd, struct map_session_data* sd)
 		char* chname = target;
 
 		channel = channel_name2channel(chname,sd,3);
-		if(channel){
+		if(channel && (pc_has_permission(sd, PC_PERM_CHANNEL_ADMIN) || ((channel->opt&CHAN_OPT_CAN_CHAT) && channel_pccheckgroup(channel,sd->group_id)))){
 			if(channel_pc_haschan(sd,channel)>=0){ //we are in the chan
 				channel_send(channel,sd,message);
 			}
 			else if( channel->pass[0] == '\0') { //no pass needed
-				if (channel_join(channel,sd)==0) channel_send(channel,sd,message); //join success
+				if (channel_join(channel,sd)==0)
+					channel_send(channel,sd,message); //join success
 			}
 			else {
 				clif_displaymessage(fd, msg_txt(sd,1402)); //You're not in that channel, type '@join <#channel_name>'
diff --git a/src/map/clif.h b/src/map/clif.h
index 8ef4e176594..b65e10f4428 100644
--- a/src/map/clif.h
+++ b/src/map/clif.h
@@ -1002,7 +1002,7 @@ enum clif_colors {
 unsigned long color_table[COLOR_MAX];
 int clif_colormes(int fd, unsigned long color, const char* msg);
 
-void clif_channel_msg(struct Channel *channel, struct map_session_data *sd, char *msg, short color);
+void clif_channel_msg(struct Channel *channel, const char *msg, unsigned long color);
 
 #define clif_menuskill_clear(sd) (sd)->menuskill_id = (sd)->menuskill_val = (sd)->menuskill_val2 = 0;
 
diff --git a/src/map/guild.c b/src/map/guild.c
index cf7a7d886bf..16843797e63 100644
--- a/src/map/guild.c
+++ b/src/map/guild.c
@@ -534,7 +534,7 @@ int guild_recv_info(struct guild *sg) {
 		if( sd==NULL )
 			continue;
 		sd->guild = g;
-		if(channel_config.ally_autojoin ) {
+		if(channel_config.ally_tmpl.name && (channel_config.ally_tmpl.opt&CHAN_OPT_AUTOJOIN)) {
 			channel_gjoin(sd,3); //make all member join guildchan+allieschan
 		}
 
@@ -703,7 +703,7 @@ void guild_member_joined(struct map_session_data *sd) {
 
 		if (g->instance_id != 0)
 			instance_reqinfo(sd, g->instance_id);
-		if( channel_config.ally_enable && channel_config.ally_autojoin ) {
+		if( channel_config.ally_tmpl.name != NULL && (channel_config.ally_tmpl.opt&CHAN_OPT_AUTOJOIN) ) {
 			channel_gjoin(sd,3);
 		}
 	}
@@ -1745,8 +1745,8 @@ int guild_broken(int guild_id,int flag) {
 	guild_db->foreach(guild_db,guild_broken_sub,guild_id);
 	castle_db->foreach(castle_db,castle_guild_broken_sub,guild_id);
 	storage_guild_delete(guild_id);
-	if( channel_config.ally_enable ) {
-		channel_delete(g->channel);
+	if( channel_config.ally_tmpl.name != NULL ) {
+		channel_delete(g->channel,false);
 	}
 	idb_remove(guild_db,guild_id);
 	return 0;
@@ -2267,7 +2267,7 @@ void do_final_guild(void) {
 	struct guild *g;
 
 	for( g = (struct guild *)dbi_first(iter); dbi_exists(iter); g = (struct guild *)dbi_next(iter) ) {
-		channel_delete(g->channel);
+		channel_delete(g->channel,false);
 	}
 	dbi_destroy(iter);
 
diff --git a/src/map/map.c b/src/map/map.c
index d07e584d475..9fb32e6450a 100644
--- a/src/map/map.c
+++ b/src/map/map.c
@@ -148,6 +148,7 @@ char motd_txt[256] = "conf/motd.txt";
 char help_txt[256] = "conf/help.txt";
 char help2_txt[256] = "conf/help2.txt";
 char charhelp_txt[256] = "conf/charhelp.txt";
+char channel_conf[256] = "conf/channels.conf";
 
 char wisp_server_name[NAME_LENGTH] = "Server"; // can be modified in char-server configuration file
 
@@ -3871,6 +3872,8 @@ int map_config_read(char *cfgName)
 			strcpy(help2_txt, w2);
 		else if (strcmpi(w1, "charhelp_txt") == 0)
 			strcpy(charhelp_txt, w2);
+		else if (strcmpi(w1, "channel_conf") == 0)
+			safestrncpy(channel_conf, w2, sizeof(channel_conf));
 		else if(strcmpi(w1,"db_path") == 0)
 			safestrncpy(db_path,w2,ARRAYLENGTH(db_path));
 		else if (strcmpi(w1, "console") == 0) {
@@ -4377,7 +4380,7 @@ void do_final(void)
 		ShowStatus("Cleaning up maps [%d/%d]: %s..."CL_CLL"\r", i+1, map_num, map[i].name);
 		if (map[i].m >= 0) {
 			map_foreachinmap(cleanup_sub, i, BL_ALL);
-			channel_delete(map[i].channel);
+			channel_delete(map[i].channel,false);
 		}
 	}
 	ShowStatus("Cleaned up %d maps."CL_CLL"\n", map_num);
@@ -4728,12 +4731,12 @@ int do_init(int argc, char *argv[])
 	do_init_atcommand();
 	do_init_battle();
 	do_init_instance();
-	do_init_channel();
 	do_init_chrif();
 	do_init_clan();
 	do_init_clif();
 	do_init_script();
 	do_init_itemdb();
+	do_init_channel();
 	do_init_cashshop();
 	do_init_skill();
 	do_init_mob();
diff --git a/src/map/map.h b/src/map/map.h
index 8f2ec969fe3..ad58eba5b15 100644
--- a/src/map/map.h
+++ b/src/map/map.h
@@ -750,6 +750,7 @@ extern char motd_txt[];
 extern char help_txt[];
 extern char help2_txt[];
 extern char charhelp_txt[];
+extern char channel_conf[];
 
 extern char wisp_server_name[];
 
diff --git a/src/map/pc.c b/src/map/pc.c
index 5bfad2b4b20..bc50b22f611 100755
--- a/src/map/pc.c
+++ b/src/map/pc.c
@@ -1462,6 +1462,8 @@ void pc_reg_received(struct map_session_data *sd)
 
 		clif_changeoption( &sd->bl );
 	}
+
+	channel_autojoin(sd);
 }
 
 static int pc_calc_skillpoint(struct map_session_data* sd)
diff --git a/src/map/pc.h b/src/map/pc.h
index 43db0872990..1dee1844faf 100644
--- a/src/map/pc.h
+++ b/src/map/pc.h
@@ -632,7 +632,7 @@ struct map_session_data {
 	struct Channel *gcbind;
 	bool stealth;
 	unsigned char fontcolor;
-	unsigned int channel_tick;
+	unsigned int *channel_tick;
 
 	/* [Ind] */
 	struct sc_display_entry **sc_display;
diff --git a/src/map/script.c b/src/map/script.c
index b72500fd9c6..981ddcce014 100644
--- a/src/map/script.c
+++ b/src/map/script.c
@@ -48,6 +48,7 @@
 #include "mail.h"
 #include "quest.h"
 #include "elemental.h"
+#include "channel.h"
 
 #include <math.h>
 #ifndef WIN32
@@ -22037,6 +22038,445 @@ BUILDIN_FUNC(openstorage2) {
 	return SCRIPT_CMD_SUCCESS;
 }
 
+/** Create a new channel
+ * channel_create "<chname>","<alias>"{,"<password>"{<option>{,<delay>{,<color>{,<char_id>}}}}};
+ * @author [Cydh]
+ **/
+BUILDIN_FUNC(channel_create) {
+	struct Channel tmp_chan, *ch = NULL;
+	const char *chname = script_getstr(st,2), *pass = NULL;
+	int i = channel_chk((char*)chname, NULL, 3);
+	TBL_PC *sd = NULL;
+
+	if (i != 0) {
+		ShowError("buildin_channel_create: Channel name '%s' is invalid. Errno %d\n", chname, i);
+		script_pushint(st,i);
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	memset(&tmp_chan, 0, sizeof(struct Channel));
+
+	if (script_hasdata(st,8)) {
+		tmp_chan.char_id = script_getnum(st,8);
+		if (!(sd = map_charid2sd(tmp_chan.char_id))) {
+			ShowError("buildin_channel_create: Player with char id '%d' is not found.\n", tmp_chan.char_id);
+			script_pushint(st,-5);
+			return SCRIPT_CMD_FAILURE;
+		}
+		tmp_chan.type = CHAN_TYPE_PRIVATE;
+		i = 1;
+	}
+	else {
+		tmp_chan.type = CHAN_TYPE_PUBLIC;
+		i = 0;
+	}
+
+	safestrncpy(tmp_chan.name, chname+1, sizeof(tmp_chan.name));
+	safestrncpy(tmp_chan.alias, script_getstr(st,3), sizeof(tmp_chan.alias));
+	if (script_hasdata(st,4) && (pass = script_getstr(st,4)) && strcmpi(pass,"null") != 0)
+		safestrncpy(tmp_chan.pass, pass, sizeof(tmp_chan.pass));
+	if (script_hasdata(st,5))
+		tmp_chan.opt = script_getnum(st,5);
+	else
+		tmp_chan.opt = i ? channel_config.private_channel.opt : CHAN_OPT_BASE;
+	if (script_hasdata(st,6))
+		tmp_chan.msg_delay = script_getnum(st,6);
+	else
+		tmp_chan.msg_delay = i ? channel_config.private_channel.delay : 1000;
+	if (script_hasdata(st,7))
+		tmp_chan.color = script_getnum(st,7);
+	else
+		tmp_chan.color = i ? channel_config.private_channel.color : channel_getColor("Default");
+
+	if (!(ch = channel_create(&tmp_chan))) {
+		ShowError("buildin_channel_create: Cannot create channel '%s'.\n", chname);
+		script_pushint(st,0);
+		return SCRIPT_CMD_FAILURE;
+	}
+	if (tmp_chan.char_id)
+		channel_join(ch, sd);
+	script_pushint(st,1);
+	return SCRIPT_CMD_SUCCESS;
+}
+
+/** Set channel option
+ * channel_setopt "<chname>",<option>,<value>;
+ * @author [Cydh]
+ **/
+BUILDIN_FUNC(channel_setopt) {
+	struct Channel *ch = NULL;
+	const char *chname = script_getstr(st,2);
+	int opt = script_getnum(st,3), value = script_getnum(st,4);
+
+	if (!(ch = channel_name2channel((char *)chname, NULL, 0))) {
+		ShowError("buildin_channel_setopt: Channel name '%s' is invalid.\n", chname);
+		script_pushint(st,0);
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	switch (opt) {
+		case CHAN_OPT_ANNOUNCE_SELF:
+		case CHAN_OPT_ANNOUNCE_JOIN:
+		case CHAN_OPT_ANNOUNCE_LEAVE:
+		case CHAN_OPT_COLOR_OVERRIDE:
+		case CHAN_OPT_CAN_CHAT:
+		case CHAN_OPT_CAN_LEAVE:
+		case CHAN_OPT_AUTOJOIN:
+			if (value)
+				ch->opt |= opt;
+			else
+				ch->opt &= ~opt;
+			break;
+		case CHAN_OPT_MSG_DELAY:
+			ch->msg_delay = value;
+			break;
+		default:
+			ShowError("buildin_channel_setopt: Invalid option %d!\n", opt);
+			script_pushint(st,0);
+			return SCRIPT_CMD_FAILURE;
+	}
+
+	script_pushint(st,1);
+	return SCRIPT_CMD_SUCCESS;
+}
+
+/** Set channel color
+ * channel_setcolor "<chname>",<color>;
+ * @author [Cydh]
+ **/
+BUILDIN_FUNC(channel_setcolor) {
+	struct Channel *ch = NULL;
+	const char *chname = script_getstr(st,2);
+	int color = script_getnum(st,3);
+
+	if (!(ch = channel_name2channel((char *)chname, NULL, 0))) {
+		ShowError("buildin_channel_setcolor: Channel name '%s' is invalid.\n", chname);
+		script_pushint(st,0);
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	ch->color = (color & 0x0000FF) << 16 | (color & 0x00FF00) | (color & 0xFF0000) >> 16;//RGB to BGR
+
+	script_pushint(st,1);
+	return SCRIPT_CMD_SUCCESS;
+}
+
+/** Set channel password
+ * channel_setpass "<chname>","<password>";
+ * @author [Cydh]
+ **/
+BUILDIN_FUNC(channel_setpass) {
+	struct Channel *ch = NULL;
+	const char *chname = script_getstr(st,2), *passwd = script_getstr(st,3);
+
+	if (!(ch = channel_name2channel((char *)chname, NULL, 0))) {
+		ShowError("buildin_channel_setpass: Channel name '%s' is invalid.\n", chname);
+		script_pushint(st,0);
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	if (!passwd || !strcmpi(passwd,"null"))
+		memset(ch->pass, '\0', sizeof(ch->pass));
+	else
+		safestrncpy(ch->pass, passwd, sizeof(ch->pass));
+	script_pushint(st,1);
+	return SCRIPT_CMD_SUCCESS;
+}
+
+/** Set authorized groups
+ * channel_setgroup "<chname>",<group_id>{,...,<group_id>};
+ * @author [Cydh]
+ **/
+BUILDIN_FUNC(channel_setgroup) {
+	struct Channel *ch = NULL;
+	const char *funcname = script_getfuncname(st), *chname = script_getstr(st,2);
+	int i, n = 0, group = 0;
+
+	if (!(ch = channel_name2channel((char *)chname, NULL, 0))) {
+		ShowError("buildin_channel_setgroup: Channel name '%s' is invalid.\n", chname);
+		script_pushint(st,0);
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	if (funcname[strlen(funcname)-1] == '2') {
+		struct script_data *data = script_getdata(st,3);
+		const char *varname = reference_getname(data);
+		int32 id, idx;
+
+		if (varname[strlen(varname)-1] == '$') {
+			ShowError("buildin_channel_setgroup: The array %s is not numeric type.\n", varname);
+			script_pushint(st,0);
+			return SCRIPT_CMD_FAILURE;
+		}
+
+		n = script_array_highest_key(st, NULL, reference_getname(data), reference_getref(data));
+		if (n < 1) {
+			ShowError("buildin_channel_setgroup: No group id listed.\n");
+			script_pushint(st,0);
+			return SCRIPT_CMD_FAILURE;
+		}
+
+		if (ch->groups)
+			aFree(ch->groups);
+		ch->groups = NULL;
+		ch->group_count = 0;
+
+		id = reference_getid(data);
+		idx = reference_getindex(data);
+		for (i = 0; i < n; i++) {
+			group = (int32)__64BPRTSIZE(get_val2(st,reference_uid(id,idx+i),reference_getref(data)));
+			if (group == 0) {
+				script_pushint(st,1);
+				return SCRIPT_CMD_SUCCESS;
+			}
+			RECREATE(ch->groups, unsigned short, ++ch->group_count);
+			ch->groups[ch->group_count-1] = group;
+			ShowInfo("buildin_channel_setgroup: (2) Added group %d. Num: %d\n", ch->groups[ch->group_count-1], ch->group_count);
+		}
+	}
+	else {
+		group = script_getnum(st,3);
+		n = script_lastdata(st)-1;
+
+		if (n < 1) {
+			ShowError("buildin_channel_setgroup: Please input at least 1 group_id.\n");
+			script_pushint(st,0);
+			return SCRIPT_CMD_FAILURE;
+		}
+
+		if (ch->groups)
+			aFree(ch->groups);
+		ch->groups = NULL;
+		ch->group_count = 0;
+
+		if (group == 0) { // Removed group list
+			script_pushint(st,1);
+			return SCRIPT_CMD_SUCCESS;
+		}
+
+		CREATE(ch->groups, unsigned short, n);
+		for (i = 3; i < n+2; i++) {
+			ch->groups[ch->group_count++] = script_getnum(st,i);
+			ShowInfo("buildin_channel_setgroup: (1) Added group %d. Num: %d\n", ch->groups[ch->group_count-1], ch->group_count);
+		}
+	}
+	script_pushint(st,n);
+	return SCRIPT_CMD_SUCCESS;
+}
+
+/** Send message on channel
+ * channel_chat "<chname>","<message>"{,<color>};
+ * @author [Cydh]
+ **/
+BUILDIN_FUNC(channel_chat) {
+	struct Channel *ch = NULL;
+	const char *chname = script_getstr(st,2), *msg = script_getstr(st,3);
+	char output[CHAT_SIZE_MAX+1];
+	unsigned long color = 0;
+
+	// Check also local channels
+	if (chname[0] != '#') { // By Map
+		int m = mapindex_name2id(chname);
+		if (!m || (m = map_mapindex2mapid(m)) < 0) {
+			ShowError("buildin_channel_chat: Invalid map '%s'.\n", chname);
+			script_pushint(st,0);
+			return SCRIPT_CMD_FAILURE;
+		}
+		if (!(ch = map[m].channel)) {
+			ShowDebug("buildin_channel_chat: Map '%s' doesn't have local channel yet.\n", chname);
+			script_pushint(st,0);
+			return SCRIPT_CMD_SUCCESS;
+		}
+	}
+	else if (strcmpi(chname+1,channel_config.map_tmpl.name) == 0) {
+		TBL_NPC *nd = map_id2nd(st->oid);
+		if (!nd || nd->bl.m == -1) {
+			ShowError("buildin_channel_chat: Floating NPC needs map name instead '%s'.\n", chname);
+			script_pushint(st,0);
+			return SCRIPT_CMD_FAILURE;
+		}
+		if (!(ch = map[nd->bl.m].channel)) {
+			ShowDebug("buildin_channel_chat: Map '%s' doesn't have local channel yet.\n", chname);
+			script_pushint(st,0);
+			return SCRIPT_CMD_SUCCESS;
+		}
+	}
+	else if (!(ch = channel_name2channel((char *)chname, NULL, 0))) {
+		ShowError("buildin_channel_chat: Channel name '%s' is invalid.\n", chname);
+		script_pushint(st,0);
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	if (!ch) {
+		script_pushint(st,0);
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	color = ch->color;
+	FETCH(4, color);
+
+	safesnprintf(output, CHAT_SIZE_MAX, "%s %s", ch->alias, msg);
+	clif_channel_msg(ch,output,color);
+	script_pushint(st,1);
+	return SCRIPT_CMD_SUCCESS;
+}
+
+/** Ban player from a channel
+ * channel_ban "<chname>",<char_id>;
+ * @author [Cydh]
+ **/
+BUILDIN_FUNC(channel_ban) {
+	struct Channel *ch = NULL;
+	const char *chname = script_getstr(st,2);
+	unsigned int char_id = script_getnum(st,3);
+	TBL_PC *tsd;
+
+	if (!(ch = channel_name2channel((char *)chname, NULL, 0))) {
+		ShowError("buildin_channel_ban: Channel name '%s' is invalid.\n", chname);
+		script_pushint(st,0);
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	if (ch->char_id == char_id) {
+		script_pushint(st,0);
+		return SCRIPT_CMD_SUCCESS;
+	}
+
+	tsd = map_charid2sd(char_id);
+	if (tsd && pc_has_permission(tsd,PC_PERM_CHANNEL_ADMIN)) {
+		script_pushint(st,0);
+		return SCRIPT_CMD_SUCCESS;
+	}
+
+	if (!idb_exists(ch->banned, char_id)) {
+		struct chan_banentry *cbe;
+		char output[CHAT_SIZE_MAX+1];
+
+		CREATE(cbe, struct chan_banentry, 1);
+		cbe->char_id = char_id;
+		if (tsd) {
+			strcpy(cbe->char_name,tsd->status.name);
+			channel_clean(ch,tsd,0);
+			safesnprintf(output, CHAT_SIZE_MAX, msg_txt(tsd,890), ch->alias, tsd->status.name); // "%s %s is banned"
+		}
+		else
+			safesnprintf(output, CHAT_SIZE_MAX, msg_txt(tsd,890), ch->alias, "****"); // "%s %s is banned"
+		idb_put(ch->banned, char_id, cbe);
+		clif_channel_msg(ch,output,ch->color);
+	}
+
+	script_pushint(st,1);
+	return SCRIPT_CMD_SUCCESS;
+}
+
+/** Ban player from a channel
+ * channel_unban "<chname>",<char_id>;
+ * @author [Cydh]
+ **/
+BUILDIN_FUNC(channel_unban) {
+	struct Channel *ch = NULL;
+	const char *chname = script_getstr(st,2);
+	unsigned int char_id = script_getnum(st,3);
+
+	if (!(ch = channel_name2channel((char *)chname, NULL, 0))) {
+		ShowError("buildin_channel_unban: Channel name '%s' is invalid.\n", chname);
+		script_pushint(st,0);
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	if (ch->char_id == char_id) {
+		script_pushint(st,0);
+		return SCRIPT_CMD_SUCCESS;
+	}
+
+	if (idb_exists(ch->banned, char_id)) {
+		char output[CHAT_SIZE_MAX+1];
+		TBL_PC *tsd = map_charid2sd(char_id);
+		if (tsd)
+			safesnprintf(output, CHAT_SIZE_MAX, msg_txt(tsd,891), ch->alias, tsd->status.name); // "%s %s is unbanned"
+		else
+			safesnprintf(output, CHAT_SIZE_MAX, msg_txt(tsd,891), ch->alias, "****"); // "%s %s is unbanned"
+		idb_remove(ch->banned, char_id);
+		clif_channel_msg(ch,output,ch->color);
+	}
+
+	script_pushint(st,1);
+	return SCRIPT_CMD_SUCCESS;
+}
+
+/** Kick player from a channel
+ * channel_kick "<chname>",<char_id>;
+ * channel_kick "<chname>","<char_name>";
+ * @author [Cydh]
+ **/
+BUILDIN_FUNC(channel_kick) {
+	struct Channel *ch = NULL;
+	const char *chname = script_getstr(st,2);
+	struct script_data *data = script_getdata(st,3);
+	TBL_PC *tsd = NULL;
+	int res = 1;
+
+	get_val(st, data);
+	if (data_isstring(data)) {
+		if (!(tsd = map_nick2sd(conv_str(st,data)))) {
+			ShowError("buildin_channel_kick: Player with nick '%s' is not online\n", conv_str(st,data));
+			script_pushint(st,0);
+			return SCRIPT_CMD_FAILURE;
+		}
+	}
+	else {
+		if (!(tsd = map_charid2sd(conv_num(st,data)))) {
+			ShowError("buildin_channel_kick: Player with char_id '%d' is not online\n", conv_num(st,data));
+			script_pushint(st,0);
+			return SCRIPT_CMD_FAILURE;
+		}
+	}
+
+	if (!(ch = channel_name2channel((char *)chname, tsd, 0))) {
+		ShowError("buildin_channel_kick: Channel name '%s' is invalid.\n", chname);
+		script_pushint(st,0);
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	if (channel_pc_haschan(tsd, ch) < 0 || ch->char_id == tsd->status.char_id || pc_has_permission(tsd,PC_PERM_CHANNEL_ADMIN)) {
+		script_pushint(st,0);
+		return SCRIPT_CMD_SUCCESS;
+	}
+
+	switch(ch->type){
+		case CHAN_TYPE_ALLY: res = channel_pcquit(tsd,3); break;
+		case CHAN_TYPE_MAP: res = channel_pcquit(tsd,4); break;
+		default: res = channel_clean(ch,tsd,0); break;
+	}
+	
+	if (res == 0) {
+		char output[CHAT_SIZE_MAX+1];
+		safesnprintf(output, CHAT_SIZE_MAX, msg_txt(tsd,889), ch->alias, tsd->status.name); // "%s %s is kicked"
+		clif_channel_msg(ch,output,ch->color);
+	}
+
+	script_pushint(st,1);
+	return SCRIPT_CMD_SUCCESS;
+}
+
+/** Delete a channel
+ * channel_delete "<chname>";
+ * @author [Cydh]
+ **/
+BUILDIN_FUNC(channel_delete) {
+	struct Channel *ch = NULL;
+	const char *chname = script_getstr(st,2);
+
+	if (!(ch = channel_name2channel((char *)chname, NULL, 0))) {
+		ShowError("channel_delete: Channel name '%s' is invalid.\n", chname);
+		script_pushint(st,-1);
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	script_pushint(st,channel_delete(ch,true));
+	return SCRIPT_CMD_SUCCESS;
+}
+
 #include "../custom/script.inc"
 
 // declarations that were supposed to be exported from npc_chat.c
@@ -22640,6 +23080,19 @@ struct script_function buildin_func[] = {
 	BUILDIN_DEF(gvgon3,"s"),
 	BUILDIN_DEF(gvgoff3,"s"),
 
+	// Channel System
+	BUILDIN_DEF(channel_create,"ss?????"),
+	BUILDIN_DEF(channel_setopt,"sii"),
+	BUILDIN_DEF(channel_setcolor,"si"),
+	BUILDIN_DEF(channel_setpass,"ss"),
+	BUILDIN_DEF(channel_setgroup,"si*"),
+	BUILDIN_DEF2(channel_setgroup,"channel_setgroup2","sr"),
+	BUILDIN_DEF(channel_chat,"ss?"),
+	BUILDIN_DEF(channel_ban,"si"),
+	BUILDIN_DEF(channel_unban,"si"),
+	BUILDIN_DEF(channel_kick,"sv"),
+	BUILDIN_DEF(channel_delete,"s"),
+
 #include "../custom/script_def.inc"
 
 	{NULL,NULL,NULL},
diff --git a/src/map/script_constants.h b/src/map/script_constants.h
index b757db21620..7899134cdc7 100644
--- a/src/map/script_constants.h
+++ b/src/map/script_constants.h
@@ -3177,6 +3177,21 @@
 	export_constant(CARD0_CREATE);
 	export_constant(CARD0_PET);
 
+	/* Channel System */
+	export_constant(CHAN_TYPE_PUBLIC);
+	export_constant(CHAN_TYPE_PRIVATE);
+	export_constant(CHAN_TYPE_MAP);
+	export_constant(CHAN_TYPE_ALLY);
+	export_constant(CHAN_OPT_BASE);
+	export_constant(CHAN_OPT_ANNOUNCE_SELF);
+	export_constant(CHAN_OPT_ANNOUNCE_JOIN);
+	export_constant(CHAN_OPT_ANNOUNCE_LEAVE);
+	export_constant(CHAN_OPT_MSG_DELAY);
+	export_constant(CHAN_OPT_COLOR_OVERRIDE);
+	export_constant(CHAN_OPT_CAN_CHAT);
+	export_constant(CHAN_OPT_CAN_LEAVE);
+	export_constant(CHAN_OPT_AUTOJOIN);
+
 	export_constant(STOR_MODE_NONE);
 	export_constant(STOR_MODE_GET);
 	export_constant(STOR_MODE_PUT);