Index: src/map/atcommand.c

===================================================================

--- src/map/atcommand.c	(revision 17385)

+++ src/map/atcommand.c	(working copy)

@@ -21,6 +21,7 @@

 #include "clif.h"

 #include "chrif.h"

 #include "duel.h"

+#include "instance.h"

 #include "intif.h"

 #include "itemdb.h"

 #include "log.h"

@@ -3724,6 +3725,9 @@

 	} else if (strstr(command, "packetdb") || strncmp(message, "packetdb", 4) == 0) {

 		packetdb_readdb();

 		clif_displaymessage(fd, msg_txt(sd,1477)); // Packet database has been reloaded.

+	} else if (strstr(command, "instancedb") || strncmp(message, "instancedb", 4) == 0) {

+		instance_readdb();

+		clif_displaymessage(fd, msg_txt(sd,516)); // Instance database has been reloaded.

 	}

@@ -3945,8 +3949,6 @@

 		strcat(atcmd_output, msg_txt(sd,1097)); // GuildLock |

 	if (map[m_id].flag.loadevent)

 		strcat(atcmd_output, msg_txt(sd,1098)); // Loadevent |

-	if (map[m_id].flag.src4instance)

-		strcat(atcmd_output, msg_txt(sd,1099)); // Src4instance |

 	if (map[m_id].flag.chmautojoin)

 		strcat(atcmd_output, msg_txt(sd,1100)); // Chmautojoin |

 	if (map[m_id].flag.nousecart)

@@ -7653,7 +7655,7 @@

 		checkflag(nogo);				checkflag(nobaseexp);

 		checkflag(nojobexp);			checkflag(nomobloot);			checkflag(nomvploot);	checkflag(nightenabled);

 		checkflag(restricted);			checkflag(nodrop);				checkflag(novending);	checkflag(loadevent);

-		checkflag(nochat);				checkflag(partylock);			checkflag(guildlock);	checkflag(src4instance);

+		checkflag(nochat);				checkflag(partylock);			checkflag(guildlock);

 		clif_displaymessage(sd->fd," ");

 		clif_displaymessage(sd->fd,msg_txt(sd,1312)); // Usage: "@mapflag monster_noteleport 1" (0=Off | 1=On)

 		clif_displaymessage(sd->fd,msg_txt(sd,1313)); // Type "@mapflag available" to list the available mapflags.

@@ -7673,7 +7675,7 @@

 	setflag(nogo);				setflag(nobaseexp);

 	setflag(nojobexp);			setflag(nomobloot);			setflag(nomvploot);			setflag(nightenabled);

 	setflag(restricted);		setflag(nodrop);			setflag(novending);			setflag(loadevent);

-	setflag(nochat);			setflag(partylock);			setflag(guildlock);			setflag(src4instance);

+	setflag(nochat);			setflag(partylock);			setflag(guildlock);

 	clif_displaymessage(sd->fd,msg_txt(sd,1314)); // Invalid flag name or flag.

 	clif_displaymessage(sd->fd,msg_txt(sd,1312)); // Usage: "@mapflag monster_noteleport 1" (0=Off | 1=On)

@@ -7685,7 +7687,7 @@

 	clif_displaymessage(sd->fd,"nozenypenalty, notrade, noskill, nowarp, nowarpto, noicewall, snow, clouds, clouds2,");

 	clif_displaymessage(sd->fd,"fog, fireworks, sakura, leaves, nogo, nobaseexp, nojobexp, nomobloot,");

 	clif_displaymessage(sd->fd,"nomvploot, nightenabled, restricted, nodrop, novending, loadevent, nochat, partylock,");

-	clif_displaymessage(sd->fd,"guildlock, src4instance");

+	clif_displaymessage(sd->fd,"guildlock");

 #undef checkflag

 #undef setflag

Index: src/map/clif.c

===================================================================

--- src/map/clif.c	(revision 17385)

+++ src/map/clif.c	(working copy)

@@ -9186,10 +9186,6 @@

 	if( !(sd->sc.option&OPTION_INVISIBLE) ) { // increment the number of pvp players on the map

 		map[sd->bl.m].users_pvp++;

 	}

-	if( map[sd->bl.m].instance_id ) {

-		instance[map[sd->bl.m].instance_id].users++;

-		instance_check_idle(map[sd->bl.m].instance_id);

-	}

 	sd->state.debug_remove_map = 0; // temporary state to track double remove_map's [FlavioJS]

 	// reset the callshop flag if the player changes map

@@ -15267,102 +15263,85 @@

 /*==========================================

- * Instancing Window

+ * Notifies party members of instance change

  *------------------------------------------*/

-int clif_instance(int instance_id, int type, int flag)

+void clif_instance_create(struct map_session_data *sd, const char *name, int num, int flag)

 {

-	struct map_session_data *sd;

-	struct party_data *p;

-	unsigned char buf[255];

+#if PACKETVER >= 20071128

+	unsigned char buf[65];

-	if( (p = party_search(instance[instance_id].party_id)) == NULL || (sd = party_getavailablesd(p)) == NULL )

-		return 0;

+	nullpo_retv(sd);

-	switch( type )

-	{

-	case 1:

-		// S 0x2cb <Instance name>.61B <Standby Position>.W

-		// Required to start the instancing information window on Client

-		// This window re-appear each "refresh" of client automatically until type 4 is send to client.

-		WBUFW(buf,0) = 0x02CB;

-		memcpy(WBUFP(buf,2),instance[instance_id].name,INSTANCE_NAME_LENGTH);

-		WBUFW(buf,63) = flag;

-		clif_send(buf,packet_len(0x02CB),&sd->bl,PARTY);

-		break;

-	case 2:

-		// S 0x2cc <Standby Position>.W

-		// To announce Instancing queue creation if no maps available

-		WBUFW(buf,0) = 0x02CC;

-		WBUFW(buf,2) = flag;

-		clif_send(buf,packet_len(0x02CC),&sd->bl,PARTY);

-		break;

-	case 3:

-	case 4:

-		// S 0x2cd <Instance Name>.61B <Instance Remaining Time>.L <Instance Noplayers close time>.L

-		WBUFW(buf,0) = 0x02CD;

-		memcpy(WBUFP(buf,2),instance[instance_id].name,61);

-		if( type == 3 )

-		{

-			WBUFL(buf,63) = (uint32)instance[instance_id].progress_timeout;

-			WBUFL(buf,67) = 0;

-		}

-		else

-		{

-			WBUFL(buf,63) = 0;

-			WBUFL(buf,67) = (uint32)instance[instance_id].idle_timeout;

-		}

-		clif_send(buf,packet_len(0x02CD),&sd->bl,PARTY);

-		break;

-	case 5:

-		// S 0x2ce <Message ID>.L

-		// 0 = Notification (EnterLimitDate update?)

-		// 1 = The Memorial Dungeon expired; it has been destroyed

-		// 2 = The Memorial Dungeon's entry time limit expired; it has been destroyed

-		// 3 = The Memorial Dungeon has been removed.

-		// 4 = Create failure (removes the instance window)

-		WBUFW(buf,0) = 0x02CE;

-		WBUFL(buf,2) = flag;

-		//WBUFL(buf,6) = EnterLimitDate;

-		clif_send(buf,packet_len(0x02CE),&sd->bl,PARTY);

-		break;

-	}

-	return 0;

+	WBUFW(buf,0) = 0x2cb;

+	safestrncpy( WBUFP(buf,2), name, 62 );

+	WBUFW(buf,63) = num;

+	if(flag) // A timer has changed or been added

+		clif_send(buf,packet_len(0x2cb),&sd->bl,PARTY);

+	else	// No notification

+		clif_send(buf,packet_len(0x2cb),&sd->bl,SELF);

+#endif

+

+	return;

 }

-void clif_instance_join(int fd, int instance_id)

+void clif_instance_changewait(struct map_session_data *sd, int num, int flag)

 {

-	if( instance[instance_id].idle_timer != INVALID_TIMER ) {

-		WFIFOHEAD(fd,packet_len(0x02CD));

-		WFIFOW(fd,0) = 0x02CD;

-		memcpy(WFIFOP(fd,2),instance[instance_id].name,61);

-		WFIFOL(fd,63) = 0;

-		WFIFOL(fd,67) = (uint32)instance[instance_id].idle_timeout;

-		WFIFOSET(fd,packet_len(0x02CD));

-	} else if( instance[instance_id].progress_timer != INVALID_TIMER ) {

-		WFIFOHEAD(fd,packet_len(0x02CD));

-		WFIFOW(fd,0) = 0x02CD;

-		memcpy(WFIFOP(fd,2),instance[instance_id].name,61);

-		WFIFOL(fd,63) = (uint32)instance[instance_id].progress_timeout;;

-		WFIFOL(fd,67) = 0;

-		WFIFOSET(fd,packet_len(0x02CD));

-	} else {

-		WFIFOHEAD(fd,packet_len(0x02CB));

-		WFIFOW(fd,0) = 0x02CB;

-		memcpy(WFIFOP(fd,2),instance[instance_id].name,61);

-		WFIFOW(fd,63) = 0;

-		WFIFOSET(fd,packet_len(0x02CB));

-	}

+#if PACKETVER >= 20071128

+	unsigned char buf[4];

+

+	nullpo_retv(sd);

+

+	WBUFW(buf,0) = 0x2cc;

+	WBUFW(buf,2) = num;

+	if(flag) // A timer has changed or been added

+		clif_send(buf,packet_len(0x2cc),&sd->bl,PARTY);

+	else	// No notification

+		clif_send(buf,packet_len(0x2cc),&sd->bl,SELF);

+#endif

+

+	return;

 }

-void clif_instance_leave(int fd)

+void clif_instance_status(struct map_session_data *sd, const char *name, unsigned int limit1, unsigned int limit2, int flag)

 {

-	WFIFOHEAD(fd,packet_len(0x02CE));

-	WFIFOW(fd,0) = 0x02ce;

-	WFIFOL(fd,2) = 4;

-	WFIFOSET(fd,packet_len(0x02CE));

+#if PACKETVER >= 20071128

+	unsigned char buf[71];

+

+	nullpo_retv(sd);

+

+	WBUFW(buf,0) = 0x2cd;

+	safestrncpy( WBUFP(buf,2), name, 62 );

+	WBUFL(buf,63) = limit1;

+	WBUFL(buf,67) = limit2;

+	if(flag) // A timer has changed or been added

+		clif_send(buf,packet_len(0x2cd),&sd->bl,PARTY);

+	else	// No notification

+		clif_send(buf,packet_len(0x2cd),&sd->bl,SELF);

+#endif

+

+	return;

 }

+void clif_instance_changestatus(struct map_session_data *sd, int type, unsigned int limit, int flag)

+{

+#if PACKETVER >= 20071128

+	unsigned char buf[10];

+	nullpo_retv(sd);

+

+	WBUFW(buf,0) = 0x2ce;

+	WBUFL(buf,2) = type;

+	WBUFL(buf,6) = limit;

+	if(flag) // A timer has changed or been added

+		clif_send(buf,packet_len(0x2ce),&sd->bl,PARTY);

+	else	// No notification

+		clif_send(buf,packet_len(0x2ce),&sd->bl,SELF);

+#endif

+

+	return;

+}

+

+

 /// Notifies clients about item picked up by a party member (ZC_ITEM_PICKUP_PARTY).

 /// 02b8 <account id>.L <name id>.W <identified>.B <damaged>.B <refine>.B <card1>.W <card2>.W <card3>.W <card4>.W <equip location>.W <item type>.B

 void clif_party_show_picker(struct map_session_data * sd, struct item * item_data)

Index: src/map/clif.h

===================================================================

--- src/map/clif.h	(revision 17385)

+++ src/map/clif.h	(working copy)

@@ -570,9 +570,10 @@

 void clif_sendbgemblem_single(int fd, struct map_session_data *sd);

 // Instancing

-int clif_instance(int instance_id, int type, int flag);

-void clif_instance_join(int fd, int instance_id);

-void clif_instance_leave(int fd);

+void clif_instance_create(struct map_session_data *sd, const char *name, int num, int flag);

+void clif_instance_changewait(struct map_session_data *sd, int num, int flag);

+void clif_instance_status(struct map_session_data *sd, const char *name, unsigned int limit1, unsigned int limit2, int flag);

+void clif_instance_changestatus(struct map_session_data *sd, int type, unsigned int limit, int flag);

 // Custom Fonts

 void clif_font(struct map_session_data *sd);

Index: src/map/instance.c

===================================================================

--- src/map/instance.c	(revision 17385)

+++ src/map/instance.c	(working copy)

@@ -24,465 +24,682 @@

 #include <stdarg.h>

 #include <time.h>

+#define MAX_INSTANCE_DB		15	// Max number of instance types

+#define INSTANCE_INTERVAL	60000	// Interval used to check when an instance is to be destroyed (ms)

+#define INSTANCE_LIMIT		300000	// Idle timer before instance is destroyed (ms) : 5 Minute Default

+

 int instance_start = 0; // To keep the last index + 1 of normal map inserted in the map[ARRAY]

-struct s_instance instance[MAX_INSTANCE];

+struct instance_data instance_data[MAX_INSTANCE_DATA];

-/// Checks whether given instance id is valid or not.

-static bool instance_is_valid(int instance_id)

+static struct instance_db{

+	short type;

+	char name[61];

+	int limit;

+	struct {

+		char mapname[MAP_NAME_LENGTH_EXT];

+		short x, y;

+	} enter;

+	char mapname[MAX_MAP_PER_INSTANCE][MAP_NAME_LENGTH_EXT];

+} instance_db[MAX_INSTANCE_DB];

+

+static struct {

+	int id[MAX_INSTANCE_DATA];

+	int count;

+	int timer;

+} instance_wait;

+

+/*==========================================

+ * Searches for an instance ID in the database

+ *------------------------------------------*/

+static struct instance_db *instance_searchtype_db(short instance_type)

 {

-	if( instance_id < 1 || instance_id >= ARRAYLENGTH(instance) )

-	{// out of range

-		return false;

-	}

+	int i;

-	if( instance[instance_id].state == INSTANCE_FREE )

-	{// uninitialized/freed instance slot

-		return false;

+	for(i=0; i < MAX_INSTANCE_DB; i++) {

+		if(instance_db[i].type == instance_type)

+			return &instance_db[i];

 	}

-	return true;

+	return NULL;

 }

-

-/*--------------------------------------

- * name : instance name

- * Return value could be

- * -4 = already exists | -3 = no free instances | -2 = party not found | -1 = invalid type

- * On success return instance_id

- *--------------------------------------*/

-int instance_create(int party_id, const char *name)

+/*==========================================

+ * Searches for an instance name in the database

+ *------------------------------------------*/

+static struct instance_db *instance_searchname_db(const char *instance_name)

 {

 	int i;

-	struct party_data* p;

-	if( ( p = party_search(party_id) ) == NULL )

-	{

-		ShowError("instance_create: party %d not found for instance '%s'.\n", party_id, name);

-		return -2;

+	for(i=0; i < MAX_INSTANCE_DB; i++) {

+		if(strcmp(instance_db[i].name, instance_name) == 0)

+			return &instance_db[i];

 	}

-	if( p->instance_id )

-		return -4; // Party already instancing

+	return NULL;

+}

-	// Searching a Free Instance

-	// 0 is ignored as this mean "no instance" on maps

-	ARR_FIND(1, MAX_INSTANCE, i, instance[i].state == INSTANCE_FREE);

-	if( i == MAX_INSTANCE )

-	{

-		ShowError("instance_create: no free instances, consider increasing MAX_INSTANCE.\n");

-		return -3;

-	}

+/*==========================================

+ * Deletes an instance timer (Destroys instance)

+ *------------------------------------------*/

+static int instance_delete_timer(int tid, unsigned int tick, int id, intptr_t data)

+{

+	instance_destroy(id);

-	instance[i].state = INSTANCE_IDLE;

-	instance[i].instance_id = i;

-	instance[i].idle_timer = INVALID_TIMER;

-	instance[i].idle_timeout = instance[i].idle_timeoutval = 0;

-	instance[i].progress_timer = INVALID_TIMER;

-	instance[i].progress_timeout = 0;

-	instance[i].users = 0;

-	instance[i].party_id = party_id;

-	instance[i].vars = idb_alloc(DB_OPT_RELEASE_DATA);

-

-	safestrncpy( instance[i].name, name, sizeof(instance[i].name) );

-	memset( instance[i].map, 0x00, sizeof(instance[i].map) );

-	p->instance_id = i;

-

-	clif_instance(i, 1, 0); // Start instancing window

-	ShowInfo("[Instance] Created: %s.\n", name);

-	return i;

+	return 0;

 }

-/*--------------------------------------

- * Add a map to the instance using src map "name"

- *--------------------------------------*/

-int instance_add_map(const char *name, int instance_id, bool usebasename)

+/*==========================================

+ * Create subscription timer for party

+ *------------------------------------------*/

+static int instance_subscription_timer(int tid, unsigned int tick, int id, intptr_t data)

 {

-	int16 m = map_mapname2mapid(name);

-	int i, im = -1;

-	size_t num_cell, size;

+	int i, ret;

+	int instance_id = instance_wait.id[0];

+	struct party_data *p;

-	if( m < 0 )

-		return -1; // source map not found

+	if(instance_wait.count == 0 || instance_id <= 0)

+		return 0;

-	if( !instance_is_valid(instance_id) )

-	{

-		ShowError("instance_add_map: trying to attach '%s' map to non-existing instance %d.\n", name, instance_id);

-		return -1;

-	}

-	if( instance[instance_id].num_map >= MAX_MAP_PER_INSTANCE )

-	{

-		ShowError("instance_add_map: trying to add '%s' map to instance %d (%s) failed. Please increase MAX_MAP_PER_INSTANCE.\n", name, instance_id, instance[instance_id].name);

-		return -2;

-	}

-	if( map[m].instance_id != 0 )

-	{ // Source map already belong to a Instance.

-		ShowError("instance_add_map: trying to instance already instanced map %s.\n", name);

-		return -4;

-	}

+	// Check that maps have been added

+	ret = instance_addmap(instance_id);

-	ARR_FIND( instance_start, map_num, i, !map[i].name[0] ); // Searching for a Free Map

-	if( i < map_num ) im = i; // Unused map found (old instance)

-	else if( map_num - 1 >= MAX_MAP_PER_SERVER )

-	{ // No more free maps

-		ShowError("instance_add_map: no more free space to create maps on this server.\n");

-		return -5;

-	}

-	else im = map_num++; // Using next map index

+	// If no maps are created, tell party to wait

+	if(ret == 0 && ( p = party_search( instance_data[instance_id].party_id ) ) != NULL)

+		clif_instance_changewait( party_getavailablesd( p ), 0xffff, 1 );

-	memcpy( &map[im], &map[m], sizeof(struct map_data) ); // Copy source map

-	snprintf(map[im].name, MAP_NAME_LENGTH, (usebasename ? "%.3d#%s" : "%.3d%s"), instance_id, name); // Generate Name for Instance Map

-	map[im].index = mapindex_addmap(-1, map[im].name); // Add map index

+	instance_wait.count--;

+	memmove(&instance_wait.id[0],&instance_wait.id[1],sizeof(instance_wait.id[0])*instance_wait.count);

+	memset(&instance_wait.id[instance_wait.count], 0, sizeof(instance_wait.id[0]));

-	if( !map[im].index )

-	{

-		map[im].name[0] = '\0';

-		ShowError("instance_add_map: no more free map indexes.\n");

-		return -3; // No free map index

+	for(i = 0; i < instance_wait.count; i++) {

+		if(	instance_data[instance_wait.id[i]].state == INSTANCE_IDLE &&

+			( p = party_search( instance_data[instance_wait.id[i]].party_id ) ) != NULL

+		){

+			clif_instance_changewait( party_getavailablesd( p ), i + 1, 1 );

+		}

 	}

-	// Reallocate cells

-	num_cell = map[im].xs * map[im].ys;

-	CREATE( map[im].cell, struct mapcell, num_cell );

-	memcpy( map[im].cell, map[m].cell, num_cell * sizeof(struct mapcell) );

+	if(instance_wait.count)

+		instance_wait.timer = add_timer(gettick()+INSTANCE_INTERVAL, instance_subscription_timer, 0, 0);

+	else

+		instance_wait.timer = -1;

-	size = map[im].bxs * map[im].bys * sizeof(struct block_list*);

-	map[im].block = (struct block_list**)aCalloc(size, 1);

-	map[im].block_mob = (struct block_list**)aCalloc(size, 1);

+	return 0;

+}

-	memset(map[im].npc, 0x00, sizeof(map[i].npc));

-	map[im].npc_num = 0;

+/*==========================================

+ * Adds timer back to party entering instance

+ *------------------------------------------*/

+static int instance_startkeeptimer(struct instance_data *im, short instance_id)

+{

+	struct instance_db *db;

+	struct party_data *p;

-	memset(map[im].moblist, 0x00, sizeof(map[im].moblist));

-	map[im].mob_delete_timer = INVALID_TIMER;

+	nullpo_retr(0, im);

-	map[im].m = im;

-	map[im].instance_id = instance_id;

-	map[im].instance_src_map = m;

-	map[m].flag.src4instance = 1; // Flag this map as a src map for instances

+	// No timer

+	if(im->keep_timer != -1)

+		return 1;

-	instance[instance_id].map[instance[instance_id].num_map++] = im; // Attach to actual instance

-	map_addmap2db(&map[im]);

+	if((db = instance_searchtype_db(im->type)) == NULL)

+		return 1;

-	return im;

+	// Add timer

+	im->keep_limit = (unsigned int)time(NULL) + db->limit;

+	im->keep_timer = add_timer(gettick()+db->limit*1000, instance_delete_timer, instance_id, 0);

+

+	// Notify party of the added instance timer

+	if( ( p = party_search( im->party_id ) ) != NULL )

+		clif_instance_status( party_getavailablesd( p ), db->name, im->keep_limit, im->idle_limit, 1 );

+

+	return 0;

 }

-/*--------------------------------------

- * m : source map of this instance

- * party_id : source party of this instance

- * type : result (0 = map id | 1 = instance id)

- *--------------------------------------*/

-int instance_map2imap(int16 m, int instance_id)

+/*==========================================

+ * Creates idle timer

+ * Default before instance destroy is 5 minutes

+ *------------------------------------------*/

+static int instance_startidletimer(struct instance_data *im, short instance_id)

 {

- 	int i;

+	struct instance_db *db;

+	struct party_data *p;

-	if( !instance_is_valid(instance_id) )

-	{

-		return -1;

+	nullpo_retr(1, im);

+

+	// No current timer

+	if(im->idle_timer != -1)

+		return 1;

+

+	// Add the timer

+	im->idle_limit = (unsigned int)time(NULL) + INSTANCE_LIMIT;

+	im->idle_timer = add_timer(gettick()+INSTANCE_LIMIT, instance_delete_timer, instance_id, 0);

+

+	// Notify party of added instance timer

+	if( ( p = party_search( im->party_id ) ) != NULL &&

+		( db = instance_searchtype_db( im->type ) ) != NULL

+		){

+		clif_instance_status( party_getavailablesd( p ), db->name, im->keep_limit, im->idle_limit, 1 );

 	}

-	for( i = 0; i < instance[instance_id].num_map; i++ )

- 	{

-		if( instance[instance_id].map[i] && map[instance[instance_id].map[i]].instance_src_map == m )

-			return instance[instance_id].map[i];

- 	}

- 	return -1;

+	return 0;

 }

-/*--------------------------------------

- * m : source map

- * instance_id : where to search

- * result : mapid of map "m" in this instance

- *--------------------------------------*/

-int instance_mapid2imapid(int16 m, int instance_id)

+/*==========================================

+ * Delete the idle timer

+ *------------------------------------------*/

+static int instance_stopidletimer(struct instance_data *im)

 {

-	if( map[m].flag.src4instance == 0 )

-		return m; // not instances found for this map

-	else if( map[m].instance_id )

-	{ // This map is a instance, not a src map instance

-		ShowError("map_instance_mapid2imapid: already instanced (%d / %d)\n", m, instance_id);

-		return -1;

-	}

+	struct party_data *p;

-	if( !instance_is_valid(instance_id) )

-		return -1;

+	nullpo_retr(0, im);

+	

+	// No timer

+	if(im->idle_timer == -1)

+		return 1;

-	return instance_map2imap(m, instance_id);

+	// Delete the timer - Party has returned or instance is destroyed

+	im->idle_limit = 0;

+	delete_timer(im->idle_timer, instance_delete_timer);

+	im->idle_timer = -1;

+

+	// Notify the party

+	if( ( p = party_search( im->party_id ) ) != NULL )

+		clif_instance_changestatus( party_getavailablesd( p ), 0, im->idle_limit, 1 );

+

+	return 0;

 }

-/*--------------------------------------

- * map_instance_map_npcsub

- * Used on Init instance. Duplicates each script on source map

- *--------------------------------------*/

-int instance_map_npcsub(struct block_list* bl, va_list args)

+/*==========================================

+ * Run the OnInstanceInit events for duplicated NPCs

+ *------------------------------------------*/

+static int instance_npcinit(struct block_list *bl, va_list ap)

 {

-	struct npc_data* nd = (struct npc_data*)bl;

-	int16 m = va_arg(args, int); // Destination Map

+	struct npc_data* nd;

-	npc_duplicate4instance(nd, m);

-	return 1;

+	nullpo_retr(0, bl);

+	nullpo_retr(0, ap);

+	nullpo_retr(0, nd = (struct npc_data *)bl);

+

+	return npc_instanceinit(nd);

 }

+/*==========================================

+ * Add an NPC to an instance

+ *------------------------------------------*/

+static int instance_addnpc_sub(struct block_list *bl, va_list ap)

+{

+	struct npc_data* nd;

+

+	nullpo_retr(0, bl);

+	nullpo_retr(0, ap);

+	nullpo_retr(0, nd = (struct npc_data *)bl);

+

+	return npc_duplicate4instance(nd, va_arg(ap, int));

+}

+

+// Separate function used for reloading

+void instance_addnpc(struct instance_data *im)

+{

+	int i;

+

+	// First add the NPCs

+	for(i = 0; i < im->cnt_map; i++)

+		map_foreachinarea(instance_addnpc_sub, im->map[i].src_m, 0, 0, map[im->map[i].src_m].xs, map[im->map[i].src_m].ys, BL_NPC, im->map[i].m);

+

+	// Now run their OnInstanceInit

+	for(i = 0; i < im->cnt_map; i++)

+		map_foreachinarea(instance_npcinit, im->map[i].m, 0, 0, map[im->map[i].m].xs, map[im->map[i].m].ys, BL_NPC, im->map[i].m);

+

+}

+

 /*--------------------------------------

- * Init all map on the instance. Npcs are created here

+ * name : instance name

+ * Return value could be

+ * -4 = already exists | -3 = no free instances | -2 = party not found | -1 = invalid type

+ * On success return instance_id

  *--------------------------------------*/

-void instance_init(int instance_id)

+int instance_create(int party_id, const char *name)

 {

-	int i;

+	short i;

+	struct instance_db *db = instance_searchname_db(name);

+	struct party_data *p = party_search(party_id);

-	if( !instance_is_valid(instance_id) )

-		return; // nothing to do

+	if(db == NULL)

+		return -1;

-	for( i = 0; i < instance[instance_id].num_map; i++ )

-		map_foreachinmap(instance_map_npcsub, map[instance[instance_id].map[i]].instance_src_map, BL_NPC, instance[instance_id].map[i]);

+	if( p == NULL )

+		return -2;

-	instance[instance_id].state = INSTANCE_BUSY;

-	ShowInfo("[Instance] Initialized %s.\n", instance[instance_id].name);

+	if( p->instance_id )

+		return -3; // Party already instancing

+

+	// Searching a Free Instance

+	// 0 is ignored as this mean "no instance" on maps

+	ARR_FIND(1, MAX_INSTANCE_DB, i, instance_data[i].state == INSTANCE_FREE);

+	if( i >= MAX_INSTANCE_DB )

+		return -4;

+

+	instance_data[i].type = db->type;

+	instance_data[i].state = INSTANCE_IDLE;

+	instance_data[i].party_id = p->party.party_id;

+	instance_data[i].keep_limit = 0;

+	instance_data[i].keep_timer = -1;

+	instance_data[i].idle_limit = 0;

+	instance_data[i].idle_timer = -1;

+	instance_data[i].vars = idb_alloc(DB_OPT_RELEASE_DATA);

+	memset(instance_data[i].map, 0, sizeof(instance_data[i].map));

+

+	p->instance_id = i;

+

+	instance_wait.id[instance_wait.count++] = p->instance_id;

+

+	clif_instance_create( party_getavailablesd( p ), name, instance_wait.count, 1);

+

+	instance_subscription_timer(0,0,0,0);

+

+	ShowInfo("[Instance] Created: %s.\n", name);

+

+	return 0;

 }

 /*--------------------------------------

- * Used on instance deleting process.

- * Warps all players on each instance map to its save points.

+ * Adds maps to the instance

  *--------------------------------------*/

-int instance_del_load(struct map_session_data* sd, va_list args)

+int instance_addmap(short instance_id)

 {

-	int16 m = va_arg(args,int);

-	if( !sd || sd->bl.m != m )

+	int i, m;

+	int cnt_map = 0;

+	struct instance_data *im;

+	struct instance_db *db;

+	struct party_data *p;

+

+	if(instance_id <= 0)

 		return 0;

-	pc_setpos(sd, sd->status.save_point.map, sd->status.save_point.x, sd->status.save_point.y, CLR_OUTSIGHT);

-	return 1;

-}

+	im = &instance_data[instance_id];

-/* for npcs behave differently when being unloaded within a instance */

-int instance_cleanup_sub(struct block_list *bl, va_list ap) {

-	nullpo_ret(bl);

+	// If the instance isn't idle, we can't do anything

+	if(im->state != INSTANCE_IDLE)

+		return 0;

-	switch(bl->type) {

-		case BL_PC:

-			map_quit((struct map_session_data *) bl);

-			break;

-		case BL_NPC:

-			npc_unload((struct npc_data *)bl,true);

-			break;

-		case BL_MOB:

-			unit_free(bl,CLR_OUTSIGHT);

-			break;

-		case BL_PET:

-			//There is no need for this, the pet is removed together with the player. [Skotlex]

-			break;

-		case BL_ITEM:

-			map_clearflooritem(bl);

-			break;

-		case BL_SKILL:

-			skill_delunit((struct skill_unit *) bl);

-			break;

+	if((db = instance_searchtype_db(im->type)) == NULL)

+		return 0;

+

+	// Set to busy, update timers

+	im->state = INSTANCE_BUSY;

+	im->idle_limit = (unsigned int)time(NULL) + INSTANCE_LIMIT;

+	im->idle_timer = add_timer(gettick()+INSTANCE_LIMIT, instance_delete_timer, instance_id, 0);

+

+	// Add the maps

+	for(i = 0; i < MAX_MAP_PER_INSTANCE; i++) {

+		if(strlen(db->mapname[i]) < 1)

+			continue;

+		else if( (m = map_addinstancemap(db->mapname[i], instance_id)) < 0) {

+			// An error occured adding a map

+			ShowError("instance_addmap: No maps added to instance %d.\n",instance_id);

+			return 0;

+		} else {

+			im->map[cnt_map].m = m;

+			im->map[cnt_map].src_m = map_mapname2mapid(db->mapname[i]);

+			cnt_map++;

+		}

 	}

-	return 1;

+	im->cnt_map = cnt_map;

+

+	// Create NPCs on all maps

+	instance_addnpc(im);

+

+	// Inform party members of the created instance

+	if( (p = party_search( im->party_id ) ) != NULL )

+		clif_instance_status( party_getavailablesd( p ), db->name, im->keep_limit, im->idle_limit, 1);

+

+	return cnt_map;

 }

-/*--------------------------------------

- * Removes a simple instance map

- *--------------------------------------*/

-void instance_del_map(int16 m)

+

+/*==========================================

+ * Returns an instance map ID using a map name

+ * name : source map

+ * instance_id : where to search

+ * result : mapid of map "name" in this instance

+ *------------------------------------------*/

+int instance_mapname2mapid(const char *name, short instance_id)

 {

+	struct instance_data *im;

+	int m = map_mapname2mapid(name);

+	char iname[12];

 	int i;

-	if( m <= 0 || !map[m].instance_id )

-	{

-		ShowError("Tried to remove non-existing instance map (%d)\n", m);

-		return;

+

+	if(m < 0) {

+		ShowError("instance_mapname2mapid: map name %s does not exist.\n",name);

+		return m;

 	}

-	map_foreachpc(instance_del_load, m);

-	map_foreachinmap(instance_cleanup_sub, m, BL_ALL);

+	if(instance_id <= 0 || instance_id > MAX_INSTANCE_DATA)

+		return m;

-	if( map[m].mob_delete_timer != INVALID_TIMER )

-		delete_timer(map[m].mob_delete_timer, map_removemobs_timer);

+	im = &instance_data[instance_id];

+	if(im->state != INSTANCE_BUSY)

+		return m;

-	mapindex_removemap( map[m].index );

+	for(i = 0; i < MAX_MAP_PER_INSTANCE; i++)

+		if(im->map[i].src_m == m) {

+			snprintf(iname, sizeof(iname), ((strchr(name,'@') == NULL)?"%.3d#%s":"%.3d%s"), instance_id, name);

+			return mapindex_name2id(iname);

+		}

-	// Free memory

-	aFree(map[m].cell);

-	aFree(map[m].block);

-	aFree(map[m].block_mob);

+	return m;

+}

-	// Remove from instance

-	for( i = 0; i < instance[map[m].instance_id].num_map; i++ )

-	{

-		if( instance[map[m].instance_id].map[i] == m )

-		{

-			instance[map[m].instance_id].num_map--;

-			for( ; i < instance[map[m].instance_id].num_map; i++ )

-				instance[map[m].instance_id].map[i] = instance[map[m].instance_id].map[i+1];

-			i = -1;

-			break;

+/*==========================================

+ * Removes a instance, all its maps and npcs.

+ *------------------------------------------*/

+int instance_destroy(short instance_id)

+{

+	struct instance_data *im;

+	struct party_data *p;

+	int i, type = 0, count = 0;

+	unsigned int now = (unsigned int)time(NULL);

+

+	if(instance_id <= 0 || instance_id > MAX_INSTANCE_DATA)

+		return 1;

+

+	im = &instance_data[instance_id];

+

+	if(im->state == INSTANCE_FREE)

+		return 1;

+

+	if(im->state == INSTANCE_IDLE) {

+		for(i = 0; i < instance_wait.count; i++) {

+			if(instance_wait.id[i] == instance_id) {

+				instance_wait.count--;

+				memmove(&instance_wait.id[i],&instance_wait.id[i+1],sizeof(instance_wait.id[0])*(instance_wait.count-i));

+				memset(&instance_wait.id[instance_wait.count], 0, sizeof(instance_wait.id[0]));

+

+				for(i = 0; i < instance_wait.count; i++)

+					if(instance_data[instance_wait.id[i]].state == INSTANCE_IDLE)

+						if((p = party_search(instance_data[instance_wait.id[i]].party_id)) != NULL)

+							clif_instance_changewait( party_getavailablesd( p ), i+1, 1);

+

+				if(instance_wait.count)

+					instance_wait.timer = add_timer(gettick()+INSTANCE_INTERVAL, instance_subscription_timer, 0, 0);

+				else

+					instance_wait.timer = -1;

+				type = 0;

+				break;

+			}

 		}

+	} else {

+		if(im->keep_limit && im->keep_limit <= now)

+			type = 1;

+		else if(im->idle_limit && im->idle_limit <= now)

+			type = 2;

+		else

+			type = 3;

+

+		for(i = 0; i < MAX_MAP_PER_INSTANCE; i++)

+			count += map_delinstancemap(im->map[i].m);

 	}

-	if( i == instance[map[m].instance_id].num_map )

-		ShowError("map_instance_del: failed to remove %s from instance list (%s): %d\n", map[m].name, instance[map[m].instance_id].name, m);

-	map_removemapdb(&map[m]);

-	memset(&map[m], 0x00, sizeof(map[0]));

+	if(im->keep_timer != -1) {

+		delete_timer(im->keep_timer, instance_delete_timer);

+		im->keep_timer = -1;

+	}

+	if(im->idle_timer != -1) {

+		delete_timer(im->idle_timer, instance_delete_timer);

+		im->idle_timer = -1;

+	}

-	/* for it is default and makes it not try to delete a non-existent timer since we did not delete this entry. */

-	map[m].mob_delete_timer = INVALID_TIMER;

+	if((p = party_search(im->party_id))) {

+		p->instance_id = 0;

+

+		if(type)

+			clif_instance_changestatus( party_getavailablesd( p ), type, 0, 1 );

+		else

+			clif_instance_changewait( party_getavailablesd( p ), 0xffff, 1 );

+	}

+

+	if( im->vars ) {

+		db_destroy(im->vars);

+		im->vars = NULL;

+	}

+

+	im->type = 0;

+	im->state = INSTANCE_FREE;

+	im->party_id = 0;

+	im->keep_limit = 0;

+	im->idle_limit = 0;

+	ShowInfo("[Instance] Destroyed %d.\n", instance_data[i].map);

+

+	memset(instance_data[i].map, 0, sizeof(instance_data[i].map));

+

+	return 0;

 }

-/*--------------------------------------

- * Timer to destroy instance by process or idle

- *--------------------------------------*/

-int instance_destroy_timer(int tid, unsigned int tick, int id, intptr_t data)

+/*==========================================

+ * Allows a user to enter an instance

+ *------------------------------------------*/

+int instance_enter(struct map_session_data *sd, const char *name)

 {

-	instance_destroy(id);

+	struct instance_data *im;

+	struct instance_db *db = instance_searchname_db(name);

+	struct party_data *p;

+	int m;

+

+	nullpo_retr(-1, sd);

+

+	if(db == NULL)

+		return 1;

+

+	// Character must be in instance party

+	if(sd->status.party_id == 0)

+		return 2;

+	if((p = party_search(sd->status.party_id)) == NULL)

+		return 2;

+

+	// Party must have an instance

+	if(p->instance_id == 0)

+		return 3;

+

+	im = &instance_data[p->instance_id];

+	if(im->party_id != p->party.party_id)

+		return 3;

+	if(im->state != INSTANCE_BUSY)

+		return 3;

+	if(im->type != db->type)

+		return 3;

+

+	// Does the instance match?

+	if((m = instance_mapname2mapid(db->enter.mapname, p->instance_id)) < 0)

+		return 4;

+

+	if(pc_setpos(sd, m, db->enter.x, db->enter.y, 0))

+		return 4;

+

+	// If there was an idle timer, let's stop it

+	instance_stopidletimer(im);

+

+	// Now we start the instance timer

+	instance_startkeeptimer(im, p->instance_id);

+

 	return 0;

 }

-/*--------------------------------------

- * Removes a instance, all its maps and npcs.

- *--------------------------------------*/

-void instance_destroy(int instance_id)

+/*==========================================

+ * Request some info about the instance

+ *------------------------------------------*/

+int instance_reqinfo(struct map_session_data *sd, short instance_id)

 {

-	int last = 0, type;

-	struct party_data *p;

-	time_t now = time(NULL);

+	struct instance_data *im;

+	struct instance_db *db;

+	int i;

-	if( !instance_is_valid(instance_id) )

-		return; // nothing to do

+	nullpo_retr(1, sd);

-	if( instance[instance_id].progress_timeout && instance[instance_id].progress_timeout <= now )

-		type = 1;

-	else if( instance[instance_id].idle_timeout && instance[instance_id].idle_timeout <= now )

-		type = 2;

-	else

-		type = 3;

+	if(instance_id <= 0 || instance_id > MAX_INSTANCE_DATA)

+		return 1;

-	clif_instance(instance_id, 5, type); // Report users this instance has been destroyed

+	im = &instance_data[instance_id];

-	while( instance[instance_id].num_map && last != instance[instance_id].map[0] )

-	{ // Remove all maps from instance

-		last = instance[instance_id].map[0];

-		instance_del_map( instance[instance_id].map[0] );

-	}

+	if((db = instance_searchtype_db(im->type)) == NULL)

+		return 1;

-	if( instance[instance_id].vars )

-		db_destroy(instance[instance_id].vars);

+	// Say it's created if instance is not busy

+	if(im->state == INSTANCE_IDLE) {

+		for(i = 0; i < instance_wait.count; i++) {

+			if(instance_wait.id[i] == instance_id) {

+				clif_instance_create(sd, db->name, i+1, 0);

+				break;

+			}

+		}

+	} else if(im->state == INSTANCE_BUSY) // Give info on the instance if busy

+		clif_instance_status(sd, db->name, im->keep_limit, im->idle_limit, 0);

-	if( instance[instance_id].progress_timer != INVALID_TIMER )

-		delete_timer( instance[instance_id].progress_timer, instance_destroy_timer);

-	if( instance[instance_id].idle_timer != INVALID_TIMER )

-		delete_timer( instance[instance_id].idle_timer, instance_destroy_timer);

+	return 0;

+}

-	instance[instance_id].vars = NULL;

+/*==========================================

+ * Add players to the instance (for timers)

+ *------------------------------------------*/

+int instance_addusers(short instance_id)

+{

+	struct instance_data *im;

-	if( instance[instance_id].party_id && (p = party_search(instance[instance_id].party_id)) != NULL )

-		p->instance_id = 0; // Update Party information

+	if(instance_id <= 0 || instance_id > MAX_INSTANCE_DATA)

+		return 1;

-	ShowInfo("[Instance] Destroyed %s.\n", instance[instance_id].name);

-	memset( &instance[instance_id], 0x00, sizeof(instance[0]) );

+	im = &instance_data[instance_id];

+	if(im->state != INSTANCE_BUSY)

+		return 1;

-	instance[instance_id].state = INSTANCE_FREE;

+	// Stop the idle timer if we had one

+	instance_stopidletimer(im);

+

+	// Start the instance keep timer

+	instance_startkeeptimer(im, instance_id);

+

+	return 0;

 }

-/*--------------------------------------

- * Checks if there are users in the instance or not to start idle timer

- *--------------------------------------*/

-void instance_check_idle(int instance_id)

+/*==========================================

+ * Delete players from the instance (for timers)

+ *------------------------------------------*/

+int instance_delusers(short instance_id)

 {

-	bool idle = true;

-	time_t now = time(NULL);

+	struct instance_data *im;

+	int i, idle = 0;

-	if( !instance_is_valid(instance_id) || instance[instance_id].idle_timeoutval == 0 )

-		return;

+	if(instance_id <= 0 || instance_id > MAX_INSTANCE_DATA)

+		return 1;

-	if( instance[instance_id].users )

-		idle = false;

+	im = &instance_data[instance_id];

+	if(im->state != INSTANCE_BUSY)

+		return 1;

-	if( instance[instance_id].idle_timer != INVALID_TIMER && !idle )

-	{

-		delete_timer(instance[instance_id].idle_timer, instance_destroy_timer);

-		instance[instance_id].idle_timer = INVALID_TIMER;

-		instance[instance_id].idle_timeout = 0;

-		clif_instance(instance_id, 3, 0); // Notify instance users normal instance expiration

-	}

-	else if( instance[instance_id].idle_timer == INVALID_TIMER && idle )

-	{

-		instance[instance_id].idle_timeout = now + instance[instance_id].idle_timeoutval;

-		instance[instance_id].idle_timer = add_timer( gettick() + (unsigned int)instance[instance_id].idle_timeoutval * 1000, instance_destroy_timer, instance_id, 0);

-		clif_instance(instance_id, 4, 0); // Notify instance users it will be destroyed of no user join it again in "X" time

-	}

+	// If no one is in the instance, start the idle timer

+	for(i = 0; im->map[i].m && i < MAX_MAP_PER_INSTANCE; i++)

+		if(map[im->map[i].m].users > 1) // We check this before the actual map.users are updated, hence the 1

+			idle++;

+

+	if(!idle) // If idle wasn't added to, we know no one was in the instance

+		instance_startidletimer(im, instance_id);

+

+	return 0;

 }

-/*--------------------------------------

- * Set instance Timers

- *--------------------------------------*/

-void instance_set_timeout(int instance_id, unsigned int progress_timeout, unsigned int idle_timeout)

+/*==========================================

+ * Read the instance_db.txt file

+ *------------------------------------------*/

+static bool instance_readdb_sub(char* str[], int columns, int current)

 {

-	time_t now = time(0);

+	int i, type, k=0;

-	if( !instance_is_valid(instance_id) )

-		return;

+	type=atoi(str[0]);

-	if( instance[instance_id].progress_timer != INVALID_TIMER )

-		delete_timer( instance[instance_id].progress_timer, instance_destroy_timer);

-	if( instance[instance_id].idle_timer != INVALID_TIMER )

-		delete_timer( instance[instance_id].idle_timer, instance_destroy_timer);

+	instance_db[type].type=type;

+	safestrncpy(instance_db[type].name, str[1], 24);

+	instance_db[type].limit=atoi(str[2]);

+	safestrncpy(instance_db[type].enter.mapname, str[3], MAP_NAME_LENGTH);

+	instance_db[type].enter.x=atoi(str[4]);

+	instance_db[type].enter.y=atoi(str[5]);

-	if( progress_timeout )

-	{

-		instance[instance_id].progress_timeout = now + progress_timeout;

-		instance[instance_id].progress_timer = add_timer( gettick() + progress_timeout * 1000, instance_destroy_timer, instance_id, 0);

-	}

-	else

-	{

-		instance[instance_id].progress_timeout = 0;

-		instance[instance_id].progress_timer = INVALID_TIMER;

-	}

+	//Instance maps

+	for(i=6; i<columns; i++)

+		if(strlen(str[i])) {

+			safestrncpy(instance_db[type].mapname[k], str[i], MAP_NAME_LENGTH);

+			k++;

+		}

-	if( idle_timeout )

-	{

-		instance[instance_id].idle_timeoutval = idle_timeout;

-		instance[instance_id].idle_timer = INVALID_TIMER;

-		instance_check_idle(instance_id);

-	}

-	else

-	{

-		instance[instance_id].idle_timeoutval = 0;

-		instance[instance_id].idle_timeout = 0;

-		instance[instance_id].idle_timer = INVALID_TIMER;

-	}

+	return true;

+}

-	if( instance[instance_id].idle_timer == INVALID_TIMER && instance[instance_id].progress_timer != INVALID_TIMER )

-		clif_instance(instance_id, 3, 0);

+void instance_readdb(void)

+{

+

+	memset(&instance_db, 0, sizeof(instance_db));

+	sv_readdb(db_path, DBPATH"instance_db.txt", ',', 7, 7+MAX_MAP_PER_INSTANCE, MAX_INSTANCE_DB, &instance_readdb_sub);

+

 }

-/*--------------------------------------

- * Checks if sd in on a instance and should be kicked from it

- *--------------------------------------*/

-void instance_check_kick(struct map_session_data *sd)

+/*==========================================

+ * Reloads the instance in runtime (reloadscript)

+ *------------------------------------------*/

+void do_reload_instance(void)

 {

-	int16 m = sd->bl.m;

+	struct instance_data *im;

+	struct instance_db *db;

+	struct s_mapiterator* iter;

+	struct map_session_data *sd;

+	int i;

-	clif_instance_leave(sd->fd);

-	if( map[m].instance_id )

-	{ // User was on the instance map

-		if( map[m].save.map )

-			pc_setpos(sd, map[m].save.map, map[m].save.x, map[m].save.y, CLR_TELEPORT);

-		else

-			pc_setpos(sd, sd->status.save_point.map, sd->status.save_point.x, sd->status.save_point.y, CLR_TELEPORT);

+	for( i = 1; i < MAX_INSTANCE_DATA; i++ ) {

+		im = &instance_data[i];

+		if(!im->cnt_map)

+			continue;

+		else {

+			// First we load the NPCs again

+			instance_addnpc(im);

+

+			// Create new keep timer

+			if((db = instance_searchtype_db(im->type)) != NULL)

+				im->keep_limit = (unsigned int)time(NULL) + db->limit;

+		}

 	}

+

+	// Reset player to instance beginning

+	iter = mapit_getallusers();

+	for( sd = (TBL_PC*)mapit_first(iter); mapit_exists(iter); sd = (TBL_PC*)mapit_next(iter) )

+		if(sd && map[sd->bl.m].instance_id) {

+			struct party_data *p;

+			if(!(p = party_search(sd->status.party_id)) || p->instance_id != map[sd->bl.m].instance_id) // Someone not in party is on instance map

+				continue;

+			im = &instance_data[p->instance_id];

+			if((db = instance_searchtype_db(im->type)) != NULL && !instance_enter(sd,db->name)) { // All good

+				clif_displaymessage(sd->fd, msg_txt(sd,515)); // Instance has been reloaded

+				instance_reqinfo(sd,p->instance_id);

+			} else // Something went wrong

+				ShowError("do_reload_instance: Error setting character at instance start: character_id=%d instance=%s.\n",sd->status.char_id,db->name);

+		}

+	mapit_free(iter);

 }

+void do_init_instance(void)

+{

+	instance_readdb();

+	memset(instance_data, 0, sizeof(instance_data));

+	memset(&instance_wait, 0, sizeof(instance_wait));

+	instance_wait.timer = -1;

+

+	add_timer_func_list(instance_delete_timer,"instance_delete_timer");

+	add_timer_func_list(instance_subscription_timer,"instance_subscription_timer");

+}

+

 void do_final_instance(void)

 {

 	int i;

-	for( i = 1; i < MAX_INSTANCE; i++ )

+	for( i = 1; i < MAX_INSTANCE_DATA; i++ )

 		instance_destroy(i);

 }

-

-void do_init_instance(void)

-{

-	memset(instance, 0x00, sizeof(instance));

-	add_timer_func_list(instance_destroy_timer, "instance_destroy_timer");

-}

Index: src/map/instance.h

===================================================================

--- src/map/instance.h	(revision 17385)

+++ src/map/instance.h	(working copy)

@@ -4,48 +4,45 @@

 #ifndef _INSTANCE_H_

 #define _INSTANCE_H_

-#define MAX_MAP_PER_INSTANCE 10

-#define MAX_INSTANCE 500

+#define MAX_INSTANCE_DATA	300	// Essentially how many instances we can create, but instance creation is primarily decided by MAX_MAP_PER_SERVER	

+#define MAX_MAP_PER_INSTANCE 	10	// Max number of maps per instance

 #define INSTANCE_NAME_LENGTH (60+1)

 typedef enum instance_state { INSTANCE_FREE, INSTANCE_IDLE, INSTANCE_BUSY } instance_state;

-struct s_instance {

-	char name[INSTANCE_NAME_LENGTH]; // Instance Name - required for clif functions.

-	instance_state state;

-	short instance_id;

+struct instance_data {

+	short type, cnt_map;

+	int state;

 	int party_id;

+	unsigned int keep_limit;

+	int keep_timer;

+	unsigned int idle_limit;

+	int idle_timer;

-	int map[MAX_MAP_PER_INSTANCE];

-	int num_map;

-	int users;

-

 	struct DBMap* vars; // Instance Variable for scripts

-

-	int progress_timer;

-	time_t progress_timeout;

-

-	int idle_timer;

-	time_t idle_timeout, idle_timeoutval;

+	struct {

+		int m;

+		int src_m;

+	} map[MAX_MAP_PER_INSTANCE];

 };

 extern int instance_start;

-extern struct s_instance instance[MAX_INSTANCE];

+extern struct instance_data instance_data[MAX_INSTANCE_DATA];

 int instance_create(int party_id, const char *name);

-int instance_add_map(const char *name, int instance_id, bool usebasename);

-void instance_del_map(int16 m);

-int instance_map2imap(int16 m, int instance_id);

-int instance_mapid2imapid(int16 m, int instance_id);

-void instance_destroy(int instance_id);

-void instance_init(int instance_id);

+int instance_destroy(short instance_id);

+int instance_enter(struct map_session_data *sd, const char *name);

+int instance_reqinfo(struct map_session_data *sd, short instance_id);

+int instance_addusers(short instance_id);

+int instance_delusers(short instance_id);

+int instance_mapname2mapid(const char *name, short instance_id);

+int instance_addmap(short instance_id);

-void instance_check_idle(int instance_id);

-void instance_check_kick(struct map_session_data *sd);

-void instance_set_timeout(int instance_id, unsigned int progress_timeout, unsigned int idle_timeout);

-

+void instance_addnpc(struct instance_data *im);

+void instance_readdb(void);

+void do_reload_instance(void);

+void do_init_instance(void);

 void do_final_instance(void);

-void do_init_instance(void);

 #endif

Index: src/map/map.c

===================================================================

--- src/map/map.c	(revision 17385)

+++ src/map/map.c	(working copy)

@@ -1700,6 +1700,9 @@

 	if (sd->state.permanent_speed == 1) sd->state.permanent_speed = 0; // Remove lock so speed is set back to normal at login.

+	if( map[sd->bl.m].instance_id )

+		instance_delusers(map[sd->bl.m].instance_id);

+

 	if( sd->ed ) {

 		elemental_clean_effect(sd->ed);

 		unit_remove_map(&sd->ed->bl,CLR_TELEPORT);

@@ -2171,6 +2174,142 @@

 	return true;

 }

+/*==========================================

+ * Add an instance map

+ *------------------------------------------*/

+int map_addinstancemap(const char *name, int id)

+{

+	int src_m = map_mapname2mapid(name);

+	int dst_m = -1, i;

+	size_t size;

+

+	if(src_m < 0)

+		return -1;

+

+	if(strlen(name) > 20) {

+		// against buffer overflow

+		ShowError("map_addisntancemap: can't add long map name \"%s\"\n", name);

+		return -2;

+	}

+

+	for(i = instance_start; i < MAX_MAP_PER_SERVER; i++) {

+		if(!map[i].name[0])

+			break;

+	}

+	if(i < map_num) // Destination map value overwrites another

+		dst_m = i;

+	else if(i < MAX_MAP_PER_SERVER) // Destination map value increments to new map

+		dst_m = map_num++;

+	else {

+		// Out of bounds

+		ShowError("map_addinstancemap failed. map_num(%d) > map_max(%d)\n",map_num, MAX_MAP_PER_SERVER);

+		return -3;

+	}

+

+	// Copy the map

+	memcpy(&map[dst_m], &map[src_m], sizeof(struct map_data));

+

+	// Alter the name

+	snprintf(map[dst_m].name, sizeof(map[dst_m].name), ((strchr(name,'@') == NULL)?"%.3d#%s":"%.3d%s"), id, name);

+	map[dst_m].name[MAP_NAME_LENGTH-1] = '\0';

+

+	map[dst_m].m = dst_m;

+	map[dst_m].instance_id = id;

+	map[dst_m].users = 0;

+

+	memset(map[dst_m].npc, 0, sizeof(map[dst_m].npc));

+	map[dst_m].npc_num = 0;

+

+	size = map[dst_m].bxs * map[dst_m].bys * sizeof(struct block_list*);

+	map[dst_m].block = (struct block_list **)aCalloc(1,size);

+	map[dst_m].block_mob = (struct block_list **)aCalloc(1,size);

+

+	map[dst_m].index = mapindex_addmap(-1, map[dst_m].name);

+

+	map_addmap2db(&map[dst_m]);

+

+	return dst_m;

+}

+

+/*==========================================

+ * Set player to save point when they leave

+ *------------------------------------------*/

+static int map_instancemap_leave(struct block_list *bl, va_list ap)

+{

+	struct map_session_data* sd;

+

+	nullpo_retr(0, bl);

+	nullpo_retr(0, sd = (struct map_session_data *)bl);

+

+	pc_setpos(sd, sd->status.save_point.map, sd->status.save_point.x, sd->status.save_point.y, 3);

+

+	return 1;

+}

+

+/*==========================================

+ * Remove all units from instance

+ *------------------------------------------*/

+static int map_instancemap_clean(struct block_list *bl, va_list ap)

+{

+	nullpo_retr(0, bl);

+	switch(bl->type) {

+		case BL_PC:

+			map_quit((struct map_session_data *) bl);

+			break;

+		case BL_NPC:

+			npc_unload((struct npc_data *)bl,true);

+			break;

+		case BL_MOB:

+			unit_free(bl,CLR_OUTSIGHT);

+			break;

+		case BL_PET:

+			//There is no need for this, the pet is removed together with the player. [Skotlex]

+			break;

+		case BL_ITEM:

+			map_clearflooritem(bl);

+			break;

+		case BL_SKILL:

+			skill_delunit((struct skill_unit *) bl);

+			break;

+	}

+

+	return 1;

+}

+

+/*==========================================

+ * Deleting an instance map

+ *------------------------------------------*/

+int map_delinstancemap(int m)

+{

+	if(m < 0)

+		return 0;

+	if(map[m].instance_id == 0)

+		return 0;

+

+	// Kick everyone out

+	map_foreachinmap(map_instancemap_leave, m, BL_PC);

+

+	// Do the unit cleanup

+	map_foreachinmap(map_instancemap_clean, m, BL_ALL);

+

+	if( map[m].mob_delete_timer != INVALID_TIMER )

+		delete_timer(map[m].mob_delete_timer, map_removemobs_timer);

+

+	mapindex_removemap( map[m].index );

+

+	// Free memory

+	aFree(map[m].block);

+	aFree(map[m].block_mob);

+

+	map_removemapdb(&map[m]);

+	memset(&map[m], 0x00, sizeof(map[0]));

+

+	// Make delete timers invalid to avoid errors

+	map[m].mob_delete_timer = INVALID_TIMER;

+

+	return 1;

+}

+

 /*=========================================

  * Dynamic Mobs [Wizputer]

  *-----------------------------------------*/

@@ -3086,7 +3225,7 @@

 	// finished map loading

 	ShowInfo("Successfully loaded '"CL_WHITE"%d"CL_RESET"' maps."CL_CLL"\n",map_num);

-	instance_start = map_num; // Next Map Index will be instances

+	instance_start = map_num + 1; // Next Map Index will be instances

 	if (maps_removed)

 		ShowNotice("Maps removed: '"CL_WHITE"%d"CL_RESET"'\n",maps_removed);

Index: src/map/map.h

===================================================================

--- src/map/map.h	(revision 17385)

+++ src/map/map.h	(working copy)

@@ -37,7 +37,7 @@

 #define AREA_SIZE battle_config.area_size

 #define DAMAGELOG_SIZE 30

 #define LOOTITEM_SIZE 10

-#define MAX_MOBSKILL 50	//Max 128, see mob skill_idx type if need this higher

+#define MAX_MOBSKILL 50		//Max 128, see mob skill_idx type if need this higher

 #define MAX_MOB_LIST_PER_MAP 128

 #define MAX_EVENTQUEUE 2

 #define MAX_EVENTTIMER 32

@@ -46,9 +46,9 @@

 #define MAX_FLOORITEM START_ACCOUNT_NUM

 #define MAX_LEVEL 160

 #define MAX_DROP_PER_MAP 48

-#define MAX_IGNORE_LIST 20 // official is 14

+#define MAX_IGNORE_LIST 20 	// official is 14

 #define MAX_VENDING 12

-#define MAX_MAP_SIZE 512*512 // Wasn't there something like this already? Can't find it.. [Shinryo]

+#define MAX_MAP_SIZE 512*512 	// Wasn't there something like this already? Can't find it.. [Shinryo]

 // Added definitions for WoESE objects. [L0ne_W0lf]

 enum MOBID {

@@ -573,7 +573,6 @@

 		unsigned nochat :1;

 		unsigned partylock :1;

 		unsigned guildlock :1;

-		unsigned src4instance : 1; // To flag this map when it's used as a src map for instances

 		unsigned reset :1; // [Daegaladh]

 		unsigned chmautojoin : 1; //prevent to auto join map channel

 		unsigned nousecart : 1;	//prevent open up cart @FIXME client side only atm

@@ -684,6 +683,10 @@

 void map_clearflooritem(struct block_list* bl);

 int map_addflooritem(struct item *item_data,int amount,int16 m,int16 x,int16 y,int first_charid,int second_charid,int third_charid,int flags);

+// instances

+int map_addinstancemap(const char*,int);

+int map_delinstancemap(int);

+

 // player to map session

 void map_addnickdb(int charid, const char* nick);

 void map_delnickdb(int charid, const char* nick);

Index: src/map/npc.c

===================================================================

--- src/map/npc.c	(revision 17385)

+++ src/map/npc.c	(working copy)

@@ -2579,15 +2579,11 @@

 	type = dnd->subtype;

 	// get placement

-	if( (type==SHOP || type==CASHSHOP || type==SCRIPT) && strcmp(w1, "-") == 0 )

-	{// floating shop/chashshop/script

+	if( (type==SHOP || type==CASHSHOP || type==SCRIPT) && strcmp(w1, "-") == 0 ) {// floating shop/chashshop/script

 		x = y = dir = 0;

 		m = -1;

-	}

-	else

-	{

-		if( sscanf(w1, "%31[^,],%d,%d,%d", mapname, &x, &y, &dir) != 4 )// <map name>,<x>,<y>,<facing>

-		{

+	} else {

+		if( sscanf(w1, "%31[^,],%d,%d,%d", mapname, &x, &y, &dir) != 4 ) { // <map name>,<x>,<y>,<facing>

 			ShowError("npc_parse_duplicate: Invalid placement format for duplicate in file '%s', line '%d'. Skipping line...\n * w1=%s\n * w2=%s\n * w3=%s\n * w4=%s\n", filepath, strline(buffer,start-buffer), w1, w2, w3, w4);

 			return end;// next line, try to continue

 		}

@@ -2601,8 +2597,7 @@

 	if( type == WARP && sscanf(w4, "%d,%d", &xs, &ys) == 2 );// <spanx>,<spany>

 	else if( type == SCRIPT && sscanf(w4, "%d,%d,%d", &class_, &xs, &ys) == 3);// <sprite id>,<triggerX>,<triggerY>

 	else if( type != WARP ) class_ = atoi(w4);// <sprite id>

-	else

-	{

+	else {

 		ShowError("npc_parse_duplicate: Invalid span format for duplicate warp in file '%s', line '%d'. Skipping line...\n * w1=%s\n * w2=%s\n * w3=%s\n * w4=%s\n", filepath, strline(buffer,start-buffer), w1, w2, w3, w4);

 		return end;// next line, try to continue

 	}

@@ -2620,56 +2615,51 @@

 	nd->src_id = src_id;

 	nd->bl.type = BL_NPC;

 	nd->subtype = (enum npc_subtype)type;

-	switch( type )

-	{

-	case SCRIPT:

-		++npc_script;

-		nd->u.scr.xs = xs;

-		nd->u.scr.ys = ys;

-		nd->u.scr.script = dnd->u.scr.script;

-		nd->u.scr.label_list = dnd->u.scr.label_list;

-		nd->u.scr.label_list_num = dnd->u.scr.label_list_num;

-		break;

+	switch( type ) {

+		case SCRIPT:

+			++npc_script;

+			nd->u.scr.xs = xs;

+			nd->u.scr.ys = ys;

+			nd->u.scr.script = dnd->u.scr.script;

+			nd->u.scr.label_list = dnd->u.scr.label_list;

+			nd->u.scr.label_list_num = dnd->u.scr.label_list_num;

+			break;

-	case SHOP:

-	case CASHSHOP:

-		++npc_shop;

-		nd->u.shop.shop_item = dnd->u.shop.shop_item;

-		nd->u.shop.count = dnd->u.shop.count;

-		break;

+		case SHOP:

+		case CASHSHOP:

+			++npc_shop;

+			nd->u.shop.shop_item = dnd->u.shop.shop_item;

+			nd->u.shop.count = dnd->u.shop.count;

+			break;

-	case WARP:

-		++npc_warp;

-		if( !battle_config.warp_point_debug )

-			nd->class_ = WARP_CLASS;

-		else

-			nd->class_ = WARP_DEBUG_CLASS;

-		nd->u.warp.xs = xs;

-		nd->u.warp.ys = ys;

-		nd->u.warp.mapindex = dnd->u.warp.mapindex;

-		nd->u.warp.x = dnd->u.warp.x;

-		nd->u.warp.y = dnd->u.warp.y;

-		break;

+		case WARP:

+			++npc_warp;

+			if( !battle_config.warp_point_debug )

+				nd->class_ = WARP_CLASS;

+			else

+				nd->class_ = WARP_DEBUG_CLASS;

+			nd->u.warp.xs = xs;

+			nd->u.warp.ys = ys;

+			nd->u.warp.mapindex = dnd->u.warp.mapindex;

+			nd->u.warp.x = dnd->u.warp.x;

+			nd->u.warp.y = dnd->u.warp.y;

+			break;

 	}

 	//Add the npc to its location

-	if( m >= 0 )

-	{

+	if( m >= 0 ) {

 		map_addnpc(m, nd);

 		status_change_init(&nd->bl);

 		unit_dataset(&nd->bl);

 		nd->ud.dir = dir;

 		npc_setcells(nd);

 		map_addblock(&nd->bl);

-		if( class_ >= 0 )

-		{

+		if( class_ >= 0 ) {

 			status_set_viewdata(&nd->bl, nd->class_);

 			if( map[nd->bl.m].users )

 				clif_spawn(&nd->bl);

 		}

-	}

-	else

-	{

+	} else {

 		// we skip map_addnpc, but still add it to the list of ID's

 		map_addiddb(&nd->bl);

 	}

@@ -2688,6 +2678,9 @@

 		npc_timerevent_export(nd, i);

 	}

+	if(!strcmp(filepath,"INSTANCING")) //Instance NPCs will use this for commands

+		nd->instance_id = map[m].instance_id;

+

 	nd->u.scr.timerid = INVALID_TIMER;

 	return end;

@@ -2700,21 +2693,27 @@

 		return 1;

 	snprintf(newname, ARRAYLENGTH(newname), "dup_%d_%d", map[m].instance_id, snd->bl.id);

-	if( npc_name2id(newname) != NULL )

-	{ // Name already in use

+	if( npc_name2id(newname) != NULL ) { // Name already in use

 		ShowError("npc_duplicate4instance: the npcname (%s) is already in use while trying to duplicate npc %s in instance %d.\n", newname, snd->exname, map[m].instance_id);

 		return 1;

 	}

-	if( snd->subtype == WARP )

-	{ // Adjust destination, if instanced

+	if( snd->subtype == WARP ) { // Adjust destination, if instanced

 		struct npc_data *wnd = NULL; // New NPC

-		int dm = map_mapindex2mapid(snd->u.warp.mapindex), im;

+		struct instance_data *im = &instance_data[map[m].instance_id];

+		int dm = map_mapindex2mapid(snd->u.warp.mapindex), imap = 0, i;

 		if( dm < 0 ) return 1;

-		im = instance_mapid2imapid(dm, map[m].instance_id);

-		if( im == -1 )

-		{

+		for(i = 0; i < MAX_MAP_PER_INSTANCE; i++)

+			if(im->map[i].m && map_mapname2mapid(map[im->map[i].src_m].name) == dm) {

+				imap = map_mapname2mapid(map[m].name);

+				break; // Instance map matches destination, update to instance map

+			}

+

+		if(!imap)

+			imap = map_mapname2mapid(map[dm].name);

+	

+		if( imap == -1 ) {

 			ShowError("npc_duplicate4instance: warp (%s) leading to instanced map (%s), but instance map is not attached to current instance.\n", map[dm].name, snd->exname);

 			return 1;

 		}

@@ -2730,7 +2729,7 @@

 		safestrncpy(wnd->exname, newname, ARRAYLENGTH(wnd->exname));