Renamed iTimer interface to timer.

Also removed duplicate mentions of timer within calls to shorten.

37 files changed, 596 insertions, 594 deletions

diff --git a/src/char/char.c b/src/char/char.c
index 943d1f52e..f618320e1 100644
--- a/src/char/char.c
+++ b/src/char/char.c
@@ -212,7 +212,7 @@ void set_char_charselect(int account_id)
 		character->pincode_enable = *pincode->charselect + *pincode->enabled;
 
 	if(character->waiting_disconnect != INVALID_TIMER) {
-		iTimer->delete_timer(character->waiting_disconnect, chardb_waiting_disconnect);
+		timer->delete(character->waiting_disconnect, chardb_waiting_disconnect);
 		character->waiting_disconnect = INVALID_TIMER;
 	}
 
@@ -253,7 +253,7 @@ void set_char_online(int map_id, int char_id, int account_id)
 
 	//Get rid of disconnect timer
 	if(character->waiting_disconnect != INVALID_TIMER) {
-		iTimer->delete_timer(character->waiting_disconnect, chardb_waiting_disconnect);
+		timer->delete(character->waiting_disconnect, chardb_waiting_disconnect);
 		character->waiting_disconnect = INVALID_TIMER;
 	}
 
@@ -298,7 +298,7 @@ void set_char_offline(int char_id, int account_id)
 				server[character->server].users--;
 
 		if(character->waiting_disconnect != INVALID_TIMER){
-			iTimer->delete_timer(character->waiting_disconnect, chardb_waiting_disconnect);
+			timer->delete(character->waiting_disconnect, chardb_waiting_disconnect);
 			character->waiting_disconnect = INVALID_TIMER;
 		}
 
@@ -333,7 +333,7 @@ static int char_db_setoffline(DBKey key, DBData *data, va_list ap)
 		character->char_id = -1;
 		character->server = -1;
 		if(character->waiting_disconnect != INVALID_TIMER){
-			iTimer->delete_timer(character->waiting_disconnect, chardb_waiting_disconnect);
+			timer->delete(character->waiting_disconnect, chardb_waiting_disconnect);
 			character->waiting_disconnect = INVALID_TIMER;
 		}
 	} else if (character->server == server)
@@ -2036,7 +2036,7 @@ static void char_auth_ok(int fd, struct char_session_data *sd)
 		{	//Character already online. KICK KICK KICK
 			mapif_disconnectplayer(server[character->server].fd, character->account_id, character->char_id, 2);
 			if (character->waiting_disconnect == INVALID_TIMER)
-				character->waiting_disconnect = iTimer->add_timer(iTimer->gettick()+20000, chardb_waiting_disconnect, character->account_id, 0);
+				character->waiting_disconnect = timer->add(timer->gettick()+20000, chardb_waiting_disconnect, character->account_id, 0);
 			if (character)
 				character->pincode_enable = -1;
 			WFIFOHEAD(fd,3);
@@ -2115,7 +2115,7 @@ void loginif_on_ready(void)
 	loginif_check_shutdown();
 
 	//Send online accounts to login server.
-	send_accounts_tologin(INVALID_TIMER, iTimer->gettick(), 0, 0);
+	send_accounts_tologin(INVALID_TIMER, timer->gettick(), 0, 0);
 
 	// if no map-server already connected, display a message...
 	ARR_FIND( 0, ARRAYLENGTH(server), i, server[i].fd > 0 && server[i].map[0] );
@@ -2404,7 +2404,7 @@ int parse_fromlogin(int fd) {
 					{	//Kick it from the map server it is on.
 						mapif_disconnectplayer(server[character->server].fd, character->account_id, character->char_id, 2);
 						if (character->waiting_disconnect == INVALID_TIMER)
-							character->waiting_disconnect = iTimer->add_timer(iTimer->gettick()+AUTH_TIMEOUT, chardb_waiting_disconnect, character->account_id, 0);
+							character->waiting_disconnect = timer->add(timer->gettick()+AUTH_TIMEOUT, chardb_waiting_disconnect, character->account_id, 0);
 					}
 					else
 					{// Manual kick from char server.
@@ -2473,12 +2473,12 @@ int send_accounts_tologin(int tid, unsigned int tick, int id, intptr_t data);
 void do_init_loginif(void)
 {
 	// establish char-login connection if not present
-	iTimer->add_timer_func_list(check_connect_login_server, "check_connect_login_server");
-	iTimer->add_timer_interval(iTimer->gettick() + 1000, check_connect_login_server, 0, 0, 10 * 1000);
+	timer->add_func_list(check_connect_login_server, "check_connect_login_server");
+	timer->add_interval(timer->gettick() + 1000, check_connect_login_server, 0, 0, 10 * 1000);
 
 	// send a list of all online account IDs to login server
-	iTimer->add_timer_func_list(send_accounts_tologin, "send_accounts_tologin");
-	iTimer->add_timer_interval(iTimer->gettick() + 1000, send_accounts_tologin, 0, 0, 3600 * 1000); //Sync online accounts every hour
+	timer->add_func_list(send_accounts_tologin, "send_accounts_tologin");
+	timer->add_interval(timer->gettick() + 1000, send_accounts_tologin, 0, 0, 3600 * 1000); //Sync online accounts every hour
 }
 
 void do_final_loginif(void)
@@ -5030,15 +5030,15 @@ int do_init(int argc, char **argv) {
 	do_init_mapif();
 
 	// periodically update the overall user count on all mapservers + login server
-	iTimer->add_timer_func_list(broadcast_user_count, "broadcast_user_count");
-	iTimer->add_timer_interval(iTimer->gettick() + 1000, broadcast_user_count, 0, 0, 5 * 1000);
+	timer->add_func_list(broadcast_user_count, "broadcast_user_count");
+	timer->add_interval(timer->gettick() + 1000, broadcast_user_count, 0, 0, 5 * 1000);
 
 	// Timer to clear (online_char_db)
-	iTimer->add_timer_func_list(chardb_waiting_disconnect, "chardb_waiting_disconnect");
+	timer->add_func_list(chardb_waiting_disconnect, "chardb_waiting_disconnect");
 
 	// Online Data timers (checking if char still connected)
-	iTimer->add_timer_func_list(online_data_cleanup, "online_data_cleanup");
-	iTimer->add_timer_interval(iTimer->gettick() + 1000, online_data_cleanup, 0, 0, 600 * 1000);
+	timer->add_func_list(online_data_cleanup, "online_data_cleanup");
+	timer->add_interval(timer->gettick() + 1000, online_data_cleanup, 0, 0, 600 * 1000);
 
 	//Cleaning the tables for NULL entrys @ startup [Sirius]
 	//Chardb clean
diff --git a/src/char/int_auction.c b/src/char/int_auction.c
index bf5ea1700..0dad9d2de 100644
--- a/src/char/int_auction.c
+++ b/src/char/int_auction.c
@@ -115,7 +115,7 @@ unsigned int auction_create(struct auction_data *auction)
 		auction->item.expire_time = 0;
 
 		auction->auction_id = (unsigned int)SQL->StmtLastInsertId(stmt);
-		auction->auction_end_timer = iTimer->add_timer( iTimer->gettick() + tick , auction_end_timer, auction->auction_id, 0);
+		auction->auction_end_timer = timer->add( timer->gettick() + tick , auction_end_timer, auction->auction_id, 0);
 		ShowInfo("New Auction %u | time left %u ms | By %s.\n", auction->auction_id, tick, auction->seller_name);
 
 		CREATE(auction_, struct auction_data, 1);
@@ -170,7 +170,7 @@ void auction_delete(struct auction_data *auction)
 		Sql_ShowDebug(sql_handle);
 
 	if( auction->auction_end_timer != INVALID_TIMER )
-		iTimer->delete_timer(auction->auction_end_timer, auction_end_timer);
+		timer->delete(auction->auction_end_timer, auction_end_timer);
 
 	idb_remove(auction_db_, auction_id);
 }
@@ -182,7 +182,7 @@ void inter_auctions_fromsql(void)
 	struct item *item;
 	char *data;
 	StringBuf buf;
-	unsigned int tick = iTimer->gettick(), endtick;
+	unsigned int tick = timer->gettick(), endtick;
 	time_t now = time(NULL);
 
 	StrBuf->Init(&buf);
@@ -234,7 +234,7 @@ void inter_auctions_fromsql(void)
 		else
 			endtick = tick + 10000; // 10 Second's to process ended auctions
 
-		auction->auction_end_timer = iTimer->add_timer(endtick, auction_end_timer, auction->auction_id, 0);
+		auction->auction_end_timer = timer->add(endtick, auction_end_timer, auction->auction_id, 0);
 		idb_put(auction_db_, auction->auction_id, auction);
 	}
 
diff --git a/src/char/int_guild.c b/src/char/int_guild.c
index a9bce9cbe..fab63894e 100644
--- a/src/char/int_guild.c
+++ b/src/char/int_guild.c
@@ -86,7 +86,7 @@ static int guild_save_timer(int tid, unsigned int tick, int id, intptr_t data)
 
 	state = guild_db_->size(guild_db_);
 	if( state < 1 ) state = 1; //Calculate the time slot for the next save.
-	iTimer->add_timer(tick  + autosave_interval/state, guild_save_timer, 0, 0);
+	timer->add(tick  + autosave_interval/state, guild_save_timer, 0, 0);
 	return 0;
 }
 
@@ -729,8 +729,8 @@ int inter_guild_sql_init(void)
 	//Read exp file
 	sv->readdb("db", DBPATH"exp_guild.txt", ',', 1, 1, 100, exp_guild_parse_row);
 
-	iTimer->add_timer_func_list(guild_save_timer, "guild_save_timer");
-	iTimer->add_timer(iTimer->gettick() + 10000, guild_save_timer, 0, 0);
+	timer->add_func_list(guild_save_timer, "guild_save_timer");
+	timer->add(timer->gettick() + 10000, guild_save_timer, 0, 0);
 	return 0;
 }
 
diff --git a/src/char/inter.c b/src/char/inter.c
index 1ff2bca61..23f400ee9 100644
--- a/src/char/inter.c
+++ b/src/char/inter.c
@@ -946,7 +946,7 @@ int check_ttl_wisdata_sub(DBKey key, DBData *data, va_list ap)
 
 int check_ttl_wisdata(void)
 {
-	unsigned long tick = iTimer->gettick();
+	unsigned long tick = timer->gettick();
 	int i;
 
 	do {
@@ -1039,7 +1039,7 @@ int mapif_parse_WisRequest(int fd)
 			memcpy(wd->src, RFIFOP(fd, 4), NAME_LENGTH);
 			memcpy(wd->dst, RFIFOP(fd,28), NAME_LENGTH);
 			memcpy(wd->msg, RFIFOP(fd,52), wd->len);
-			wd->tick = iTimer->gettick();
+			wd->tick = timer->gettick();
 			idb_put(wis_db, wd->id, wd);
 			mapif_wis_message(wd);
 		}
diff --git a/src/common/HPM.c b/src/common/HPM.c
index 3b79febd7..9895ae95d 100644
--- a/src/common/HPM.c
+++ b/src/common/HPM.c
@@ -470,7 +470,7 @@ void hplugins_share_defaults(void) {
 	/* sql */
 	HPM->share(SQL,"SQL");
 	/* timer */
-	HPM->share(iTimer,"iTimer");
+	HPM->share(timer,"timer");
 	
 }
 
diff --git a/src/common/console.c b/src/common/console.c
index c9772ecfd..75b6eaea4 100644
--- a/src/common/console.c
+++ b/src/common/console.c
@@ -362,7 +362,7 @@ void console_parse_final(void) {
 		
 		/* wait for thread to close */
 		rathread_wait(console->pthread, NULL);
-		
+
 		racond_destroy(console->ptcond);
 		ramutex_destroy(console->ptmutex);
 	}
@@ -382,8 +382,8 @@ void console_parse_init(void) {
 		exit(EXIT_FAILURE);
 	}
 	
-	iTimer->add_timer_func_list(console->parse_timer, "console_parse_timer");
-	iTimer->add_timer_interval(iTimer->gettick() + 1000, console->parse_timer, 0, 0, 500);/* start listening in 1s; re-try every 0.5s */
+	timer->add_func_list(console->parse_timer, "console_parse_timer");
+	timer->add_interval(timer->gettick() + 1000, console->parse_timer, 0, 0, 500);/* start listening in 1s; re-try every 0.5s */
 	
 }
 void console_setSQL(Sql *SQL) {
diff --git a/src/common/core.c b/src/common/core.c
index 1e5179448..6a73d2d39 100644
--- a/src/common/core.c
+++ b/src/common/core.c
@@ -325,7 +325,7 @@ int main (int argc, char **argv) {
 	cevents_init();
 #endif
 
-	iTimer->init();
+	timer->init();
 
 	console->init();
 	
@@ -341,7 +341,7 @@ int main (int argc, char **argv) {
 	{// Main runtime cycle
 		int next;
 		while (runflag != CORE_ST_STOP) {
-			next = iTimer->do_timer(iTimer->gettick_nocache());
+			next = timer->do_timer(timer->gettick_nocache());
 			do_sockets(next);
 		}
 	}
@@ -352,7 +352,7 @@ int main (int argc, char **argv) {
 #ifndef MINICORE
 	HPM->final();
 #endif
-	iTimer->final();
+	timer->final();
 	socket_final();
 	DB->final();
 	mempool_final();
diff --git a/src/common/mutex.c b/src/common/mutex.c
index 6bb1efdab..0668dbc41 100644
--- a/src/common/mutex.c
+++ b/src/common/mutex.c
@@ -201,7 +201,7 @@ void racond_wait( racond c,  ramutex m,  sysint timeout_ticks){
 		pthread_cond_wait( &c->hCond,  &m->hMutex );
 	}else{
 		struct timespec wtime;
-		int64 exact_timeout = iTimer->gettick() + timeout_ticks;
+		int64 exact_timeout = timer->gettick() + timeout_ticks;
 	
 		wtime.tv_sec = exact_timeout/1000;
 		wtime.tv_nsec = (exact_timeout%1000)*1000000;
diff --git a/src/common/random.c b/src/common/random.c
index a7d432e34..2f1b62934 100644
--- a/src/common/random.c
+++ b/src/common/random.c
@@ -17,7 +17,7 @@
 /// Initializes the random number generator with an appropriate seed.
 void rnd_init(void)
 {
-	uint32 seed = iTimer->gettick();
+	uint32 seed = timer->gettick();
 	seed += (uint32)time(NULL);
 #if defined(WIN32)
 	seed += GetCurrentProcessId();
diff --git a/src/common/socket.c b/src/common/socket.c
index 4f2e386ec..7c8b3738b 100644
--- a/src/common/socket.c
+++ b/src/common/socket.c
@@ -1012,9 +1012,9 @@ static int connect_check_(uint32 ip)
 			if( hist->ddos )
 			{// flagged as DDoS
 				return (connect_ok == 2 ? 1 : 0);
-			} else if( DIFF_TICK(iTimer->gettick(),hist->tick) < ddos_interval )
+			} else if( DIFF_TICK(timer->gettick(),hist->tick) < ddos_interval )
 			{// connection within ddos_interval
-				hist->tick = iTimer->gettick();
+				hist->tick = timer->gettick();
 				if( hist->count++ >= ddos_count )
 				{// DDoS attack detected
 					hist->ddos = 1;
@@ -1024,7 +1024,7 @@ static int connect_check_(uint32 ip)
 				return connect_ok;
 			} else
 			{// not within ddos_interval, clear data
-				hist->tick  = iTimer->gettick();
+				hist->tick  = timer->gettick();
 				hist->count = 0;
 				return connect_ok;
 			}
@@ -1035,7 +1035,7 @@ static int connect_check_(uint32 ip)
 	CREATE(hist, ConnectHistory, 1);
 	memset(hist, 0, sizeof(ConnectHistory));
 	hist->ip   = ip;
-	hist->tick = iTimer->gettick();
+	hist->tick = timer->gettick();
 	hist->next = connect_history[ip&0xFFFF];
 	connect_history[ip&0xFFFF] = hist;
 	return connect_ok;
@@ -1400,8 +1400,8 @@ void socket_init(void)
 #ifndef MINICORE
 	// Delete old connection history every 5 minutes
 	memset(connect_history, 0, sizeof(connect_history));
-	iTimer->add_timer_func_list(connect_check_clear, "connect_check_clear");
-	iTimer->add_timer_interval(iTimer->gettick()+1000, connect_check_clear, 0, 0, 5*60*1000);
+	timer->add_func_list(connect_check_clear, "connect_check_clear");
+	timer->add_interval(timer->gettick()+1000, connect_check_clear, 0, 0, 5*60*1000);
 #endif
 
 	ShowInfo("Server supports up to '"CL_WHITE"%u"CL_RESET"' concurrent connections.\n", rlim_cur);
diff --git a/src/common/sql.c b/src/common/sql.c
index 579346001..9b7fe4108 100644
--- a/src/common/sql.c
+++ b/src/common/sql.c
@@ -210,7 +210,7 @@ static int Sql_P_Keepalive(Sql* self)
 	// establish keepalive
 	ping_interval = timeout - 30; // 30-second reserve
 	//add_timer_func_list(Sql_P_KeepaliveTimer, "Sql_P_KeepaliveTimer");
-	return iTimer->add_timer_interval(iTimer->gettick() + ping_interval*1000, Sql_P_KeepaliveTimer, 0, (intptr_t)self, ping_interval*1000);
+	return timer->add_interval(timer->gettick() + ping_interval*1000, Sql_P_KeepaliveTimer, 0, (intptr_t)self, ping_interval*1000);
 }
 
 
@@ -404,7 +404,7 @@ void Sql_Free(Sql* self)
 	{
 		SQL->FreeResult(self);
 		StrBuf->Destroy(&self->buf);
-		if( self->keepalive != INVALID_TIMER ) iTimer->delete_timer(self->keepalive, Sql_P_KeepaliveTimer);
+		if( self->keepalive != INVALID_TIMER ) timer->delete(self->keepalive, Sql_P_KeepaliveTimer);
 		aFree(self);
 	}
 }
diff --git a/src/common/timer.c b/src/common/timer.c
index f019c6927..a2378a5aa 100644
--- a/src/common/timer.c
+++ b/src/common/timer.c
@@ -21,6 +21,8 @@
 #include <sys/time.h> // struct timeval, gettimeofday()
 #endif
 
+struct timer_interface timer_s;
+
 // If the server can't handle processing thousands of monsters
 // or many connected clients, please increase TIMER_MIN_INTERVAL.
 #define TIMER_MIN_INTERVAL 50
@@ -257,7 +259,7 @@ int timer_add_interval(unsigned int tick, TimerFunc func, int id, intptr_t data,
 	int tid;
 
 	if( interval < 1 ) {
-		ShowError("timer_add_interval: invalid interval (tick=%u %p[%s] id=%d data=%d diff_tick=%d)\n", tick, func, search_timer_func_list(func), id, data, DIFF_TICK(tick, iTimer->gettick()));
+		ShowError("timer_add_interval: invalid interval (tick=%u %p[%s] id=%d data=%d diff_tick=%d)\n", tick, func, search_timer_func_list(func), id, data, DIFF_TICK(tick, timer->gettick()));
 		return INVALID_TIMER;
 	}
 	
@@ -300,7 +302,7 @@ int timer_do_delete(int tid, TimerFunc func) {
 /// Adjusts a timer's expiration time.
 /// Returns the new tick value, or -1 if it fails.
 int timer_addtick(int tid, unsigned int tick) {
-	return iTimer->settick_timer(tid, timer_data[tid].tick+tick);
+	return timer->settick(tid, timer_data[tid].tick+tick);
 }
 
 /// Modifies a timer's expiration time (an alternative to deleting a timer and starting a new one).
@@ -415,20 +417,20 @@ void timer_final(void) {
 * created by Susu
 *-------------------------------------*/
 void timer_defaults(void) {
-	iTimer = &iTimer_s;
+	timer = &timer_s;
 
 	/* funcs */
-	iTimer->gettick = timer_gettick;
-	iTimer->gettick_nocache = timer_gettick_nocache;
-	iTimer->add_timer = timer_add;
-	iTimer->add_timer_interval = timer_add_interval;
-	iTimer->add_timer_func_list = timer_add_func_list;
-	iTimer->get_timer = timer_get;
-	iTimer->delete_timer = timer_do_delete;
-	iTimer->addtick_timer = timer_addtick;
-	iTimer->settick_timer = timer_settick;
-	iTimer->get_uptime = timer_get_uptime;
-	iTimer->do_timer = do_timer;
-	iTimer->init = timer_init;
-	iTimer->final = timer_final;
+	timer->gettick = timer_gettick;
+	timer->gettick_nocache = timer_gettick_nocache;
+	timer->add = timer_add;
+	timer->add_interval = timer_add_interval;
+	timer->add_func_list = timer_add_func_list;
+	timer->get = timer_get;
+	timer->delete = timer_do_delete;
+	timer->addtick = timer_addtick;
+	timer->settick = timer_settick;
+	timer->get_uptime = timer_get_uptime;
+	timer->do_timer = do_timer;
+	timer->init = timer_init;
+	timer->final = timer_final;
 }
diff --git a/src/common/timer.h b/src/common/timer.h
index 50f1c354b..3146a2e66 100644
--- a/src/common/timer.h
+++ b/src/common/timer.h
@@ -44,24 +44,24 @@ struct timer_interface {
 	unsigned int (*gettick) (void);
 	unsigned int (*gettick_nocache) (void);
 
-	int (*add_timer) (unsigned int tick, TimerFunc func, int id, intptr_t data);
-	int (*add_timer_interval) (unsigned int tick, TimerFunc func, int id, intptr_t data, int interval);
-	const struct TimerData *(*get_timer) (int tid);
-	int (*delete_timer) (int tid, TimerFunc func);
+	int (*add) (unsigned int tick, TimerFunc func, int id, intptr_t data);
+	int (*add_interval) (unsigned int tick, TimerFunc func, int id, intptr_t data, int interval);
+	const struct TimerData *(*get) (int tid);
+	int (*delete) (int tid, TimerFunc func);
 
-	int (*addtick_timer) (int tid, unsigned int tick);
-	int (*settick_timer) (int tid, unsigned int tick);
+	int (*addtick) (int tid, unsigned int tick);
+	int (*settick) (int tid, unsigned int tick);
 
-	int (*add_timer_func_list) (TimerFunc func, char* name);
+	int (*add_func_list) (TimerFunc func, char* name);
 
 	unsigned long (*get_uptime) (void);
 
 	int (*do_timer) (unsigned int tick);
 	void (*init) (void);
 	void (*final) (void);
-} iTimer_s;
+};
 
-struct timer_interface *iTimer;
+struct timer_interface *timer;
 
 void timer_defaults(void);
 
diff --git a/src/login/ipban_sql.c b/src/login/ipban_sql.c
index fd9f1a4a1..df516a3f6 100644
--- a/src/login/ipban_sql.c
+++ b/src/login/ipban_sql.c
@@ -86,8 +86,8 @@ void ipban_init(void)
 
 	if( login_config.ipban_cleanup_interval > 0 )
 	{ // set up periodic cleanup of connection history and active bans
-		iTimer->add_timer_func_list(ipban_cleanup, "ipban_cleanup");
-		cleanup_timer_id = iTimer->add_timer_interval(iTimer->gettick()+10, ipban_cleanup, 0, 0, login_config.ipban_cleanup_interval*1000);
+		timer->add_func_list(ipban_cleanup, "ipban_cleanup");
+		cleanup_timer_id = timer->add_interval(timer->gettick()+10, ipban_cleanup, 0, 0, login_config.ipban_cleanup_interval*1000);
 	} else // make sure it gets cleaned up on login-server start regardless of interval-based cleanups
 		ipban_cleanup(0,0,0,0);
 }
@@ -100,7 +100,7 @@ void ipban_final(void)
 
 	if( login_config.ipban_cleanup_interval > 0 )
 		// release data
-		iTimer->delete_timer(cleanup_timer_id, ipban_cleanup);
+		timer->delete(cleanup_timer_id, ipban_cleanup);
 	
 	ipban_cleanup(0,0,0,0); // always clean up on login-server stop
 
diff --git a/src/login/login.c b/src/login/login.c
index f92f0094d..b603117e4 100644
--- a/src/login/login.c
+++ b/src/login/login.c
@@ -103,7 +103,7 @@ struct online_login_data* add_online_user(int char_server, int account_id)
 	p->char_server = char_server;
 	if( p->waiting_disconnect != INVALID_TIMER )
 	{
-		iTimer->delete_timer(p->waiting_disconnect, waiting_disconnect_timer);
+		timer->delete(p->waiting_disconnect, waiting_disconnect_timer);
 		p->waiting_disconnect = INVALID_TIMER;
 	}
 	return p;
@@ -116,7 +116,7 @@ void remove_online_user(int account_id)
 	if( p == NULL )
 		return;
 	if( p->waiting_disconnect != INVALID_TIMER )
-		iTimer->delete_timer(p->waiting_disconnect, waiting_disconnect_timer);
+		timer->delete(p->waiting_disconnect, waiting_disconnect_timer);
 
 	idb_remove(online_db, account_id);
 }
@@ -145,7 +145,7 @@ static int online_db_setoffline(DBKey key, DBData *data, va_list ap)
 		p->char_server = -1;
 		if( p->waiting_disconnect != INVALID_TIMER )
 		{
-			iTimer->delete_timer(p->waiting_disconnect, waiting_disconnect_timer);
+			timer->delete(p->waiting_disconnect, waiting_disconnect_timer);
 			p->waiting_disconnect = INVALID_TIMER;
 		}
 	}
@@ -793,7 +793,7 @@ int parse_fromchar(int fd)
 					p->char_server = id;
 					if (p->waiting_disconnect != INVALID_TIMER)
 					{
-						iTimer->delete_timer(p->waiting_disconnect, waiting_disconnect_timer);
+						timer->delete(p->waiting_disconnect, waiting_disconnect_timer);
 						p->waiting_disconnect = INVALID_TIMER;
 					}
 				}
@@ -902,12 +902,12 @@ int parse_fromchar(int fd)
 int mmo_auth_new(const char* userid, const char* pass, const char sex, const char* last_ip) {
 	static int num_regs = 0; // registration counter
 	static unsigned int new_reg_tick = 0;
-	unsigned int tick = iTimer->gettick();
+	unsigned int tick = timer->gettick();
 	struct mmo_account acc;
 
 	//Account Registration Flood Protection by [Kevin]
 	if( new_reg_tick == 0 )
-		new_reg_tick = iTimer->gettick();
+		new_reg_tick = timer->gettick();
 	if( DIFF_TICK(tick, new_reg_tick) < 0 && num_regs >= allowed_regs ) {
 		ShowNotice("Account registration denied (registration limit exceeded)\n");
 		return 3;
@@ -1151,7 +1151,7 @@ void login_auth_ok(struct login_session_data* sd)
 				WBUFL(buf,2) = sd->account_id;
 				charif_sendallwos(-1, buf, 6);
 				if( data->waiting_disconnect == INVALID_TIMER )
-					data->waiting_disconnect = iTimer->add_timer(iTimer->gettick()+AUTH_TIMEOUT, waiting_disconnect_timer, sd->account_id, 0);
+					data->waiting_disconnect = timer->add(timer->gettick()+AUTH_TIMEOUT, waiting_disconnect_timer, sd->account_id, 0);
 
 				WFIFOHEAD(fd,3);
 				WFIFOW(fd,0) = 0x81;
@@ -1218,7 +1218,7 @@ void login_auth_ok(struct login_session_data* sd)
 		data = add_online_user(-1, sd->account_id);
 
 		// schedule deletion of this node
-		data->waiting_disconnect = iTimer->add_timer(iTimer->gettick()+AUTH_TIMEOUT, waiting_disconnect_timer, sd->account_id, 0);
+		data->waiting_disconnect = timer->add(timer->gettick()+AUTH_TIMEOUT, waiting_disconnect_timer, sd->account_id, 0);
 	}
 }
 
@@ -1796,7 +1796,7 @@ int do_init(int argc, char** argv)
 	
 	// Online user database init
 	online_db = idb_alloc(DB_OPT_RELEASE_DATA);
-	iTimer->add_timer_func_list(waiting_disconnect_timer, "waiting_disconnect_timer");
+	timer->add_func_list(waiting_disconnect_timer, "waiting_disconnect_timer");
 
 	// Interserver auth init
 	auth_db = idb_alloc(DB_OPT_RELEASE_DATA);
@@ -1805,13 +1805,13 @@ int do_init(int argc, char** argv)
 	set_defaultparse(parse_login);
 
 	// every 10 minutes cleanup online account db.
-	iTimer->add_timer_func_list(online_data_cleanup, "online_data_cleanup");
-	iTimer->add_timer_interval(iTimer->gettick() + 600*1000, online_data_cleanup, 0, 0, 600*1000);
+	timer->add_func_list(online_data_cleanup, "online_data_cleanup");
+	timer->add_interval(timer->gettick() + 600*1000, online_data_cleanup, 0, 0, 600*1000);
 
 	// add timer to detect ip address change and perform update
 	if (login_config.ip_sync_interval) {
-		iTimer->add_timer_func_list(sync_ip_addresses, "sync_ip_addresses");
-		iTimer->add_timer_interval(iTimer->gettick() + login_config.ip_sync_interval, sync_ip_addresses, 0, 0, login_config.ip_sync_interval);
+		timer->add_func_list(sync_ip_addresses, "sync_ip_addresses");
+		timer->add_interval(timer->gettick() + login_config.ip_sync_interval, sync_ip_addresses, 0, 0, login_config.ip_sync_interval);
 	}
 
 	// Account database init
diff --git a/src/map/atcommand.c b/src/map/atcommand.c
index 2466c2cca..23653f803 100644
--- a/src/map/atcommand.c
+++ b/src/map/atcommand.c
@@ -912,7 +912,7 @@ ACMD(hide)
 		
 		if( map[sd->bl.m].flag.pvp && !map[sd->bl.m].flag.pvp_nocalcrank )
 		{// register the player for ranking calculations
-			sd->pvp_timer = iTimer->add_timer( iTimer->gettick() + 200, pc->calc_pvprank_timer, sd->bl.id, 0 );
+			sd->pvp_timer = timer->add( timer->gettick() + 200, pc->calc_pvprank_timer, sd->bl.id, 0 );
 		}
 		//bugreport:2266
 		iMap->foreachinmovearea(clif->insight, &sd->bl, AREA_SIZE, sd->bl.x, sd->bl.y, BL_ALL, &sd->bl);
@@ -926,7 +926,7 @@ ACMD(hide)
 		
 		if( map[sd->bl.m].flag.pvp && !map[sd->bl.m].flag.pvp_nocalcrank && sd->pvp_timer != INVALID_TIMER )
 		{// unregister the player for ranking
-			iTimer->delete_timer( sd->pvp_timer, pc->calc_pvprank_timer );
+			timer->delete( sd->pvp_timer, pc->calc_pvprank_timer );
 			sd->pvp_timer = INVALID_TIMER;
 		}
 	}
@@ -1096,7 +1096,7 @@ ACMD(heal)
 	
 	if ( hp < 0 && sp <= 0 ) {
 		iStatus->damage(NULL, &sd->bl, -hp, -sp, 0, 0);
-		clif->damage(&sd->bl,&sd->bl, iTimer->gettick(), 0, 0, -hp, 0, 4, 0);
+		clif->damage(&sd->bl,&sd->bl, timer->gettick(), 0, 0, -hp, 0, 4, 0);
 		clif->message(fd, msg_txt(156)); // HP or/and SP modified.
 		return true;
 	}
@@ -1107,7 +1107,7 @@ ACMD(heal)
 			iStatus->heal(&sd->bl, hp, 0, 0);
 		else {
 			iStatus->damage(NULL, &sd->bl, -hp, 0, 0, 0);
-			clif->damage(&sd->bl,&sd->bl, iTimer->gettick(), 0, 0, -hp, 0, 4, 0);
+			clif->damage(&sd->bl,&sd->bl, timer->gettick(), 0, 0, -hp, 0, 4, 0);
 		}
 	}
 	
@@ -1470,7 +1470,7 @@ static int atcommand_pvpoff_sub(struct block_list *bl,va_list ap)
 	TBL_PC* sd = (TBL_PC*)bl;
 	clif->pvpset(sd, 0, 0, 2);
 	if (sd->pvp_timer != INVALID_TIMER) {
-		iTimer->delete_timer(sd->pvp_timer, pc->calc_pvprank_timer);
+		timer->delete(sd->pvp_timer, pc->calc_pvprank_timer);
 		sd->pvp_timer = INVALID_TIMER;
 	}
 	return 0;
@@ -1505,7 +1505,7 @@ static int atcommand_pvpon_sub(struct block_list *bl,va_list ap)
 {
 	TBL_PC* sd = (TBL_PC*)bl;
 	if (sd->pvp_timer == INVALID_TIMER) {
-		sd->pvp_timer = iTimer->add_timer(iTimer->gettick() + 200, pc->calc_pvprank_timer, sd->bl.id, 0);
+		sd->pvp_timer = timer->add(timer->gettick() + 200, pc->calc_pvprank_timer, sd->bl.id, 0);
 		sd->pvp_rank = 0;
 		sd->pvp_lastusers = 0;
 		sd->pvp_point = 5;
@@ -4206,7 +4206,7 @@ ACMD(nuke)
 	
 	if ((pl_sd = iMap->nick2sd(atcmd_player_name)) != NULL) {
 		if (pc->get_group_level(sd) >= pc->get_group_level(pl_sd)) { // you can kill only lower or same GM level
-			skill->castend_nodamage_id(&pl_sd->bl, &pl_sd->bl, NPC_SELFDESTRUCTION, 99, iTimer->gettick(), 0);
+			skill->castend_nodamage_id(&pl_sd->bl, &pl_sd->bl, NPC_SELFDESTRUCTION, 99, timer->gettick(), 0);
 			clif->message(fd, msg_txt(109)); // Player has been nuked!
 		} else {
 			clif->message(fd, msg_txt(81)); // Your GM level don't authorise you to do this action on this player.
@@ -4419,25 +4419,25 @@ ACMD(servertime)
 			clif->message(fd, msg_txt(232)); // Game time: The game is in permanent night.
 	} else if (battle_config.night_duration == 0)
 		if (iMap->night_flag == 1) { // we start with night
-			timer_data = iTimer->get_timer(pc->day_timer_tid);
-			sprintf(temp, msg_txt(233), txt_time(DIFF_TICK(timer_data->tick,iTimer->gettick())/1000)); // Game time: The game is actualy in night for %s.
+			timer_data = timer->get(pc->day_timer_tid);
+			sprintf(temp, msg_txt(233), txt_time(DIFF_TICK(timer_data->tick,timer->gettick())/1000)); // Game time: The game is actualy in night for %s.
 			clif->message(fd, temp);
 			clif->message(fd, msg_txt(234)); // Game time: After, the game will be in permanent daylight.
 		} else
 			clif->message(fd, msg_txt(231)); // Game time: The game is in permanent daylight.
 		else if (battle_config.day_duration == 0)
 			if (iMap->night_flag == 0) { // we start with day
-				timer_data = iTimer->get_timer(pc->night_timer_tid);
-				sprintf(temp, msg_txt(235), txt_time(DIFF_TICK(timer_data->tick,iTimer->gettick())/1000)); // Game time: The game is actualy in daylight for %s.
+				timer_data = timer->get(pc->night_timer_tid);
+				sprintf(temp, msg_txt(235), txt_time(DIFF_TICK(timer_data->tick,timer->gettick())/1000)); // Game time: The game is actualy in daylight for %s.
 				clif->message(fd, temp);
 				clif->message(fd, msg_txt(236)); // Game time: After, the game will be in permanent night.
 			} else
 				clif->message(fd, msg_txt(232)); // Game time: The game is in permanent night.
 			else {
 				if (iMap->night_flag == 0) {
-					timer_data = iTimer->get_timer(pc->night_timer_tid);
-					timer_data2 = iTimer->get_timer(pc->day_timer_tid);
-					sprintf(temp, msg_txt(235), txt_time(DIFF_TICK(timer_data->tick,iTimer->gettick())/1000)); // Game time: The game is actualy in daylight for %s.
+					timer_data = timer->get(pc->night_timer_tid);
+					timer_data2 = timer->get(pc->day_timer_tid);
+					sprintf(temp, msg_txt(235), txt_time(DIFF_TICK(timer_data->tick,timer->gettick())/1000)); // Game time: The game is actualy in daylight for %s.
 					clif->message(fd, temp);
 					if (DIFF_TICK(timer_data->tick, timer_data2->tick) > 0)
 						sprintf(temp, msg_txt(237), txt_time(DIFF_TICK(timer_data->interval,DIFF_TICK(timer_data->tick,timer_data2->tick)) / 1000)); // Game time: After, the game will be in night for %s.
@@ -4447,9 +4447,9 @@ ACMD(servertime)
 					sprintf(temp, msg_txt(238), txt_time(timer_data->interval / 1000)); // Game time: A day cycle has a normal duration of %s.
 					clif->message(fd, temp);
 				} else {
-					timer_data = iTimer->get_timer(pc->day_timer_tid);
-					timer_data2 = iTimer->get_timer(pc->night_timer_tid);
-					sprintf(temp, msg_txt(233), txt_time(DIFF_TICK(timer_data->tick,iTimer->gettick()) / 1000)); // Game time: The game is actualy in night for %s.
+					timer_data = timer->get(pc->day_timer_tid);
+					timer_data2 = timer->get(pc->night_timer_tid);
+					sprintf(temp, msg_txt(233), txt_time(DIFF_TICK(timer_data->tick,timer->gettick()) / 1000)); // Game time: The game is actualy in night for %s.
 					clif->message(fd, temp);
 					if (DIFF_TICK(timer_data->tick,timer_data2->tick) > 0)
 						sprintf(temp, msg_txt(239), txt_time((timer_data->interval - DIFF_TICK(timer_data->tick, timer_data2->tick)) / 1000)); // Game time: After, the game will be in daylight for %s.
@@ -5131,7 +5131,7 @@ ACMD(npcmove)
 	x = cap_value(x, 0, map[m].xs-1);
 	y = cap_value(y, 0, map[m].ys-1);
 	iMap->foreachinrange(clif->outsight, &nd->bl, AREA_SIZE, BL_PC, &nd->bl);
-	iMap->moveblock(&nd->bl, x, y, iTimer->gettick());
+	iMap->moveblock(&nd->bl, x, y, timer->gettick());
 	iMap->foreachinrange(clif->insight, &nd->bl, AREA_SIZE, BL_PC, &nd->bl);
 	clif->message(fd, msg_txt(1155)); // NPC moved.
 	
@@ -5455,7 +5455,7 @@ ACMD(displayskill)
 		return false;
 	}
 	status = iStatus->get_status_data(&sd->bl);
-	tick = iTimer->gettick();
+	tick = timer->gettick();
 	clif->skill_damage(&sd->bl,&sd->bl, tick, status->amotion, status->dmotion, 1, 1, skill_id, skill_lv, 5);
 	clif->skill_nodamage(&sd->bl, &sd->bl, skill_id, skill_lv, 1);
 	clif->skill_poseffect(&sd->bl, skill_id, skill_lv, sd->bl.x, sd->bl.y, tick);
@@ -6216,9 +6216,9 @@ ACMD(pettalk)
 	nullpo_retr(-1, sd);
 	
 	if ( battle_config.min_chat_delay ) {
-		if( DIFF_TICK(sd->cantalk_tick, iTimer->gettick()) > 0 )
+		if( DIFF_TICK(sd->cantalk_tick, timer->gettick()) > 0 )
 			return true;
-		sd->cantalk_tick = iTimer->gettick() + battle_config.min_chat_delay;
+		sd->cantalk_tick = timer->gettick() + battle_config.min_chat_delay;
 	}
 	
 	if(!sd->status.pet_id || !(pd=sd->pd))
@@ -6339,7 +6339,7 @@ ACMD(summon)
 	int mob_id = 0;
 	int duration = 0;
 	struct mob_data *md;
-	unsigned int tick=iTimer->gettick();
+	unsigned int tick=timer->gettick();
 	
 	nullpo_retr(-1, sd);
 	
@@ -6369,7 +6369,7 @@ ACMD(summon)
 	
 	md->master_id=sd->bl.id;
 	md->special_state.ai=1;
-	md->deletetimer=iTimer->add_timer(tick+(duration*60000),mob->timer_delete,md->bl.id,0);
+	md->deletetimer=timer->add(tick+(duration*60000),mob->timer_delete,md->bl.id,0);
 	clif->specialeffect(&md->bl,344,AREA);
 	mob->spawn(md);
 	sc_start4(&md->bl, SC_MODECHANGE, 100, 1, 0, MD_AGGRESSIVE, 0, 60000);
@@ -6492,7 +6492,7 @@ ACMD(uptime)
 	minute = 60, days = 0, hours = 0, minutes = 0;
 	nullpo_retr(-1, sd);
 	
-	seconds = iTimer->get_uptime();
+	seconds = timer->get_uptime();
 	days = seconds/day;
 	seconds -= (seconds/day>0)?(seconds/day)*day:0;
 	hours = seconds/hour;
@@ -7044,9 +7044,9 @@ ACMD(homtalk)
 	nullpo_retr(-1, sd);
 	
 	if ( battle_config.min_chat_delay ) {
-		if( DIFF_TICK(sd->cantalk_tick, iTimer->gettick()) > 0 )
+		if( DIFF_TICK(sd->cantalk_tick, timer->gettick()) > 0 )
 			return true;
-		sd->cantalk_tick = iTimer->gettick() + battle_config.min_chat_delay;
+		sd->cantalk_tick = timer->gettick() + battle_config.min_chat_delay;
 	}
 	
 	if (sd->sc.count && //no "chatting" while muted.
diff --git a/src/map/battle.c b/src/map/battle.c
index 85fa2cb98..a8022ea84 100644
--- a/src/map/battle.c
+++ b/src/map/battle.c
@@ -277,9 +277,9 @@ int battle_delay_damage (unsigned int tick, int amotion, struct block_list *src,
 		iMap->freeblock_lock();
 		status_fix_damage(src, target, damage, ddelay); // We have to seperate here between reflect damage and others [icescope]
 		if( attack_type && !iStatus->isdead(target) && additional_effects )
-			skill->additional_effect(src, target, skill_id, skill_lv, attack_type, dmg_lv, iTimer->gettick());
+			skill->additional_effect(src, target, skill_id, skill_lv, attack_type, dmg_lv, timer->gettick());
 		if( dmg_lv > ATK_BLOCK && attack_type )
-			skill->counter_additional_effect(src, target, skill_id, skill_lv, attack_type, iTimer->gettick());
+			skill->counter_additional_effect(src, target, skill_id, skill_lv, attack_type, timer->gettick());
 		iMap->freeblock_unlock();
 		return 0;
 	}
@@ -302,7 +302,7 @@ int battle_delay_damage (unsigned int tick, int amotion, struct block_list *src,
 		((TBL_PC*)src)->delayed_damage++;
 	}
 	
-	iTimer->add_timer(tick+amotion, battle->delay_damage_sub, 0, (intptr_t)dat);
+	timer->add(tick+amotion, battle->delay_damage_sub, 0, (intptr_t)dat);
 
 	return 0;
 }
@@ -365,7 +365,7 @@ int64 battle_attr_fix(struct block_list *src, struct block_list *target, int64 d
 				y = sg->val3 & 0xffff;
 				skill->unitsetting(src,su->group->skill_id,su->group->skill_lv,x,y,1);
 				sg->val3 = -1;
-				sg->limit = DIFF_TICK(iTimer->gettick(),sg->tick)+300;
+				sg->limit = DIFF_TICK(timer->gettick(),sg->tick)+300;
 			}
 		}
 	}
@@ -2664,7 +2664,7 @@ int64 battle_calc_damage(struct block_list *src,struct block_list *bl,struct Dam
 				delay = 200;
 			else
 				delay = 100;
-			unit->set_walkdelay(bl, iTimer->gettick(), delay, 1);
+			unit->set_walkdelay(bl, timer->gettick(), delay, 1);
 
 			if(sc->data[SC_CR_SHRINK] && rnd()%100<5*sce->val1)
 				skill->blown(bl,src,skill->get_blewcount(CR_SHRINK,1),-1,0);
@@ -2734,9 +2734,9 @@ int64 battle_calc_damage(struct block_list *src,struct block_list *bl,struct Dam
 		if (((sce=sc->data[SC_NJ_UTSUSEMI]) || sc->data[SC_NJ_BUNSINJYUTSU])
 		&& flag&BF_WEAPON && !(skill->get_nk(skill_id)&NK_NO_CARDFIX_ATK)) {
 
-			skill->additional_effect (src, bl, skill_id, skill_lv, flag, ATK_BLOCK, iTimer->gettick() );
+			skill->additional_effect (src, bl, skill_id, skill_lv, flag, ATK_BLOCK, timer->gettick() );
 			if( !iStatus->isdead(src) )
-				skill->counter_additional_effect( src, bl, skill_id, skill_lv, flag, iTimer->gettick() );
+				skill->counter_additional_effect( src, bl, skill_id, skill_lv, flag, timer->gettick() );
 			if (sce) {
 				clif->specialeffect(bl, 462, AREA);
 				skill->blown(src,bl,sce->val3,-1,0);
@@ -2873,7 +2873,7 @@ int64 battle_calc_damage(struct block_list *src,struct block_list *bl,struct Dam
 			damage -= damage * sc->data[SC_PAIN_KILLER]->val3 / 100;
 		}
 		if((sce=sc->data[SC_MAGMA_FLOW]) && (rnd()%100 <= sce->val2) ){
-			skill->castend_damage_id(bl,src,MH_MAGMA_FLOW,sce->val1,iTimer->gettick(),0);
+			skill->castend_damage_id(bl,src,MH_MAGMA_FLOW,sce->val1,timer->gettick(),0);
 		}
 
 		if( (sce = sc->data[SC_STONEHARDSKIN]) && flag&(BF_SHORT|BF_WEAPON) && damage > 0 ) {
@@ -2970,7 +2970,7 @@ int64 battle_calc_damage(struct block_list *src,struct block_list *bl,struct Dam
 					if( s_bl->type == BL_PC )
 						((TBL_PC*)s_bl)->shadowform_id = 0;
 				} else {
-					iStatus->damage(bl, s_bl, damage, 0, clif->damage(s_bl, s_bl, iTimer->gettick(), 500, 500, damage, -1, 0, 0), 0);
+					iStatus->damage(bl, s_bl, damage, 0, clif->damage(s_bl, s_bl, timer->gettick(), 500, 500, damage, -1, 0, 0), 0);
 					return ATK_NONE;
 				}
 			}
@@ -3052,9 +3052,9 @@ int64 battle_calc_damage(struct block_list *src,struct block_list *bl,struct Dam
 
 	if( bl->type == BL_MOB && !iStatus->isdead(bl) && src != bl) {
 	  if (damage > 0 )
-			mob->skill_event((TBL_MOB*)bl,src,iTimer->gettick(),flag);
+			mob->skill_event((TBL_MOB*)bl,src,timer->gettick(),flag);
 	  if (skill_id)
-			mob->skill_event((TBL_MOB*)bl,src,iTimer->gettick(),MSC_SKILLUSED|(skill_id<<16));
+			mob->skill_event((TBL_MOB*)bl,src,timer->gettick(),MSC_SKILLUSED|(skill_id<<16));
 	}
 	if( sd ) {
 		if( pc_ismadogear(sd) && rnd()%100 < 50 ) {
@@ -5054,7 +5054,7 @@ struct Damage battle_calc_weapon_attack(struct block_list *src,struct block_list
 								change = true;
 							if( change )
 								sd->state.autocast = 1;
-							iMap->foreachinshootrange(battle->damage_area,target,skill->get_splash(LG_REFLECTDAMAGE,1),BL_CHAR,iTimer->gettick(),target,wd.amotion,sstatus->dmotion,rdamage,tstatus->race);
+							iMap->foreachinshootrange(battle->damage_area,target,skill->get_splash(LG_REFLECTDAMAGE,1),BL_CHAR,timer->gettick(),target,wd.amotion,sstatus->dmotion,rdamage,tstatus->race);
 							if( change )
 								sd->state.autocast = 0;
 						}
@@ -5062,8 +5062,8 @@ struct Damage battle_calc_weapon_attack(struct block_list *src,struct block_list
 						//Use Reflect Shield to signal this kind of skill trigger. [Skotlex]
 						if( tsd && src != target )
 							battle->drain(tsd, src, rdamage, rdamage, sstatus->race, is_boss(src));
-						battle->delay_damage(iTimer->gettick(), wd.amotion,target,src,0,CR_REFLECTSHIELD,0,rdamage,ATK_DEF,rdelay,true);
-						skill->additional_effect(target, src, CR_REFLECTSHIELD, 1, BF_WEAPON|BF_SHORT|BF_NORMAL,ATK_DEF,iTimer->gettick());
+						battle->delay_damage(timer->gettick(), wd.amotion,target,src,0,CR_REFLECTSHIELD,0,rdamage,ATK_DEF,rdelay,true);
+						skill->additional_effect(target, src, CR_REFLECTSHIELD, 1, BF_WEAPON|BF_SHORT|BF_NORMAL,ATK_DEF,timer->gettick());
 					}
 				}
 		}
@@ -5113,7 +5113,7 @@ struct Damage battle_calc_weapon_attack(struct block_list *src,struct block_list
 		rnd()%100 < tsc->data[SC_SWORDREJECT]->val2
 		) {
 		ATK_RATER(50)
-		status_fix_damage(target,src,wd.damage,clif->damage(target,src,iTimer->gettick(),0,0,wd.damage,0,0,0));
+		status_fix_damage(target,src,wd.damage,clif->damage(target,src,timer->gettick(),0,0,wd.damage,0,0,0));
 		clif->skill_nodamage(target,target,ST_REJECTSWORD,tsc->data[SC_SWORDREJECT]->val1,1);
 		if( --(tsc->data[SC_SWORDREJECT]->val3) <= 0 )
 			status_change_end(target, SC_SWORDREJECT, INVALID_TIMER);
@@ -5200,9 +5200,9 @@ int64 battle_calc_return_damage(struct block_list* bl, struct block_list *src, i
 		if (ratio > 5000) ratio = 5000; // Maximum of 5000% ATK
 		rdamage = rdamage * ratio / 100 + (*dmg) * (10 + sc->data[SC_CRESCENTELBOW]->val1 * 20 / 10) / 10;
 		skill->blown(bl, src, skill->get_blewcount(SR_CRESCENTELBOW_AUTOSPELL, sc->data[SC_CRESCENTELBOW]->val1), unit->getdir(src), 0);
-		clif->skill_damage(bl, src, iTimer->gettick(), status_get_amotion(src), 0, rdamage,
+		clif->skill_damage(bl, src, timer->gettick(), status_get_amotion(src), 0, rdamage,
 			1, SR_CRESCENTELBOW_AUTOSPELL, sc->data[SC_CRESCENTELBOW]->val1, 6); // This is how official does
-		clif->damage(src, bl, iTimer->gettick(), status_get_amotion(src)+1000, 0, rdamage/10, 1, 0, 0);
+		clif->damage(src, bl, timer->gettick(), status_get_amotion(src)+1000, 0, rdamage/10, 1, 0, 0);
 		iStatus->damage(src, bl, iStatus->damage(bl, src, rdamage, 0, 0, 1)/10, 0, 0, 1);
 		status_change_end(bl, SC_CRESCENTELBOW, INVALID_TIMER);
 		return 0; // Just put here to minimize redundancy
@@ -5210,18 +5210,18 @@ int64 battle_calc_return_damage(struct block_list* bl, struct block_list *src, i
 	if( flag & BF_SHORT) {//Bounces back part of the damage.
 		if ( sd && sd->bonus.short_weapon_damage_return ){
 			NORMALIZE_RDAMAGE(damage * sd->bonus.short_weapon_damage_return / 100);
-			*delay = clif->damage(src, src, iTimer->gettick(), status_get_amotion(src), status_get_dmotion(src), rdamage, 1, 4, 0);
+			*delay = clif->damage(src, src, timer->gettick(), status_get_amotion(src), status_get_dmotion(src), rdamage, 1, 4, 0);
 		}
 		if( sc && sc->count ) {
 			if( sc->data[SC_REFLECTSHIELD] && skill_id != WS_CARTTERMINATION ){
 				NORMALIZE_RDAMAGE(damage * sc->data[SC_REFLECTSHIELD]->val2 / 100);
-				*delay = clif->skill_damage(src, src, iTimer->gettick(), status_get_amotion(src), status_get_dmotion(src), rdamage, 1, CR_REFLECTSHIELD, 1, 4);
+				*delay = clif->skill_damage(src, src, timer->gettick(), status_get_amotion(src), status_get_dmotion(src), rdamage, 1, CR_REFLECTSHIELD, 1, 4);
 			}
 			if( sc->data[SC_LG_REFLECTDAMAGE] && rand()%100 < (30 + 10*sc->data[SC_LG_REFLECTDAMAGE]->val1) ) {
 				if( skill_id != HT_LANDMINE && skill_id  != HT_CLAYMORETRAP
 					&& skill_id  != RA_CLUSTERBOMB && (skill_id <= RA_VERDURETRAP || skill_id  > RA_ICEBOUNDTRAP) && skill_id != MA_LANDMINE ){
 					NORMALIZE_RDAMAGE((*dmg) * sc->data[SC_LG_REFLECTDAMAGE]->val2 / 100);
-					*delay = clif->damage(src, src, iTimer->gettick(), status_get_amotion(src), status_get_dmotion(src), rdamage, 1, 4, 0);
+					*delay = clif->damage(src, src, timer->gettick(), status_get_amotion(src), status_get_dmotion(src), rdamage, 1, 4, 0);
 				}
 			}
 			if( sc->data[SC_DEATHBOUND] && skill_id != WS_CARTTERMINATION && !is_boss(src) ) {
@@ -5231,22 +5231,22 @@ int64 battle_calc_return_damage(struct block_list* bl, struct block_list *src, i
 				if( !iMap->check_dir(dir,t_dir) ) {
 					int64 rd1 = damage * sc->data[SC_DEATHBOUND]->val2 / 100; // Amplify damage.
 					trdamage += rdamage = rd1 - (*dmg = rd1 * 30 / 100); // not normalized as intended.
-					clif->skill_damage(src, bl, iTimer->gettick(), status_get_amotion(src), 0, -3000, 1, RK_DEATHBOUND, sc->data[SC_DEATHBOUND]->val1, 6);
+					clif->skill_damage(src, bl, timer->gettick(), status_get_amotion(src), 0, -3000, 1, RK_DEATHBOUND, sc->data[SC_DEATHBOUND]->val1, 6);
 					skill->blown(bl, src, skill->get_blewcount(RK_DEATHBOUND, sc->data[SC_DEATHBOUND]->val1), unit->getdir(src), 0);
 					if( skill_id )
 						status_change_end(bl, SC_DEATHBOUND, INVALID_TIMER);
-					*delay = clif->damage(src, src, iTimer->gettick(), status_get_amotion(src), status_get_dmotion(src), rdamage, 1, 4, 0);
+					*delay = clif->damage(src, src, timer->gettick(), status_get_amotion(src), status_get_dmotion(src), rdamage, 1, 4, 0);
 				}
 			}
 			if( sc->data[SC_SHIELDSPELL_DEF] && sc->data[SC_SHIELDSPELL_DEF]->val1 == 2 && !is_boss(src) ){
 				NORMALIZE_RDAMAGE(damage * sc->data[SC_SHIELDSPELL_DEF]->val2 / 100);
-				*delay = clif->damage(src, src, iTimer->gettick(), status_get_amotion(src), status_get_dmotion(src), rdamage, 1, 4, 0);
+				*delay = clif->damage(src, src, timer->gettick(), status_get_amotion(src), status_get_dmotion(src), rdamage, 1, 4, 0);
 			}
 		}
 	} else {
 		if (sd && sd->bonus.long_weapon_damage_return){ 
 			NORMALIZE_RDAMAGE(damage * sd->bonus.long_weapon_damage_return / 100);
-			*delay = clif->damage(src, src, iTimer->gettick(), status_get_amotion(src), status_get_dmotion(src), rdamage, 1, 4, 0);
+			*delay = clif->damage(src, src, timer->gettick(), status_get_amotion(src), status_get_dmotion(src), rdamage, 1, 4, 0);
 		}
 	}
 		
@@ -5503,7 +5503,7 @@ enum damage_lv battle_weapon_attack(struct block_list* src, struct block_list* t
 	}
 
 	if(tsc && tsc->data[SC_KAAHI] && tsc->data[SC_KAAHI]->val4 == INVALID_TIMER && tstatus->hp < tstatus->max_hp)
-		tsc->data[SC_KAAHI]->val4 = iTimer->add_timer(tick + skill->get_time2(SL_KAAHI,tsc->data[SC_KAAHI]->val1), iStatus->kaahi_heal_timer, target->id, SC_KAAHI); //Activate heal.
+		tsc->data[SC_KAAHI]->val4 = timer->add(tick + skill->get_time2(SL_KAAHI,tsc->data[SC_KAAHI]->val1), iStatus->kaahi_heal_timer, target->id, SC_KAAHI); //Activate heal.
 
 	wd = battle->calc_attack(BF_WEAPON, src, target, 0, 0, flag);
 
@@ -5563,7 +5563,7 @@ enum damage_lv battle_weapon_attack(struct block_list* src, struct block_list* t
 				(d_bl->type == BL_PC && ((TBL_PC*)d_bl)->devotion[sce->val2] == target->id)
 				) && check_distance_bl(target, d_bl, sce->val3) )
 			{
-				clif->damage(d_bl, d_bl, iTimer->gettick(), 0, 0, damage, 0, 0, 0);
+				clif->damage(d_bl, d_bl, timer->gettick(), 0, 0, damage, 0, 0, 0);
 				status_fix_damage(NULL, d_bl, damage, 0);
 			}
 			else
@@ -6774,11 +6774,11 @@ int battle_config_read(const char* cfgName)
 
 void do_init_battle(void) {
 	delay_damage_ers = ers_new(sizeof(struct delay_damage),"battle.c::delay_damage_ers",ERS_OPT_CLEAR);
-	iTimer->add_timer_func_list(battle_delay_damage_sub, "battle_delay_damage_sub");
+	timer->add_func_list(battle_delay_damage_sub, "battle_delay_damage_sub");
 
 #ifndef STATS_OPT_OUT
-	iTimer->add_timer_func_list(Hercules_report_timer, "Hercules_report_timer");
-	iTimer->add_timer_interval(iTimer->gettick()+30000, Hercules_report_timer, 0, 0, 60000 * 30);
+	timer->add_func_list(Hercules_report_timer, "Hercules_report_timer");
+	timer->add_interval(timer->gettick()+30000, Hercules_report_timer, 0, 0, 60000 * 30);
 #endif
 
 }
diff --git a/src/map/battleground.c b/src/map/battleground.c
index e72683880..1bc142b7f 100644
--- a/src/map/battleground.c
+++ b/src/map/battleground.c
@@ -460,7 +460,7 @@ void bg_queue_ready_ack (struct bg_arena *arena, struct map_session_data *sd, bo
 		}
 		/* check if all are ready then cancell timer, and start game  */
 		if( count == queue->items ) {
-			iTimer->delete_timer(arena->begin_timer,bg->begin_timer);
+			timer->delete(arena->begin_timer,bg->begin_timer);
 			arena->begin_timer = INVALID_TIMER;
 			bg->begin(arena);
 		}
@@ -556,7 +556,7 @@ void bg_queue_pregame(struct bg_arena *arena) {
 			clif->bgqueue_battlebegins(sd,arena->id,SELF);
 		}
 	}
-	arena->begin_timer = iTimer->add_timer( iTimer->gettick() + (arena->pregame_duration*1000), bg->begin_timer, arena->id, 0 );
+	arena->begin_timer = timer->add( timer->gettick() + (arena->pregame_duration*1000), bg->begin_timer, arena->id, 0 );
 }
 int bg_fillup_timer(int tid, unsigned int tick, int id, intptr_t data) {
 	bg->queue_pregame(bg->arena[id]);
@@ -568,12 +568,12 @@ void bg_queue_check(struct bg_arena *arena) {
 	int count = script->hq[arena->queue_id].items;
 	if( count == arena->max_players ) {
 		if( arena->fillup_timer != INVALID_TIMER ) {
-			iTimer->delete_timer(arena->fillup_timer,bg->fillup_timer);
+			timer->delete(arena->fillup_timer,bg->fillup_timer);
 			arena->fillup_timer = INVALID_TIMER;
 		}
 		bg->queue_pregame(arena);
 	} else if( count >= arena->min_players && arena->fillup_timer == INVALID_TIMER ) {
-		arena->fillup_timer = iTimer->add_timer( iTimer->gettick() + (arena->fillup_duration*1000), bg->fillup_timer, arena->id, 0 );
+		arena->fillup_timer = timer->add( timer->gettick() + (arena->fillup_duration*1000), bg->fillup_timer, arena->id, 0 );
 	}
 }
 void bg_queue_add(struct map_session_data *sd, struct bg_arena *arena, enum bg_queue_types type) {
@@ -764,8 +764,8 @@ enum BATTLEGROUNDS_QUEUE_ACK bg_canqueue(struct map_session_data *sd, struct bg_
 }
 void do_init_battleground(void) {
 	bg->team_db = idb_alloc(DB_OPT_RELEASE_DATA);
-	iTimer->add_timer_func_list(bg->send_xy_timer, "bg_send_xy_timer");
-	iTimer->add_timer_interval(iTimer->gettick() + battle_config.bg_update_interval, bg->send_xy_timer, 0, 0, battle_config.bg_update_interval);
+	timer->add_func_list(bg->send_xy_timer, "bg_send_xy_timer");
+	timer->add_interval(timer->gettick() + battle_config.bg_update_interval, bg->send_xy_timer, 0, 0, battle_config.bg_update_interval);
 	bg->config_read();
 }
 
diff --git a/src/map/chrif.c b/src/map/chrif.c
index 524286da1..dcca72cc8 100644
--- a/src/map/chrif.c
+++ b/src/map/chrif.c
@@ -186,7 +186,7 @@ static bool chrif_sd_to_auth(TBL_PC* sd, enum sd_state state) {
 	node->sex = sd->status.sex;
 	node->fd = sd->fd;
 	node->sd = sd;	//Data from logged on char.
-	node->node_created = iTimer->gettick(); //timestamp for node timeouts
+	node->node_created = timer->gettick(); //timestamp for node timeouts
 	node->state = state;
 
 	sd->state.active = 0;
@@ -691,11 +691,11 @@ int auth_db_cleanup_sub(DBKey key, DBData *data, va_list ap) {
 	struct auth_node *node = DB->data2ptr(data);
 	const char* states[] = { "Login", "Logout", "Map change" };
 	
-	if(DIFF_TICK(iTimer->gettick(),node->node_created)>60000) {
+	if(DIFF_TICK(timer->gettick(),node->node_created)>60000) {
 		switch (node->state) {
 			case ST_LOGOUT:
 				//Re-save attempt (->sd should never be null here).
-				node->node_created = iTimer->gettick(); //Refresh tick (avoid char-server load if connection is really bad)
+				node->node_created = timer->gettick(); //Refresh tick (avoid char-server load if connection is really bad)
 				chrif->save(node->sd, 1);
 				break;
 			default:
@@ -1170,10 +1170,10 @@ int chrif_save_scdata(struct map_session_data *sd) { //parses the sc_data of the
 	unsigned int tick;
 	struct status_change_data data;
 	struct status_change *sc = &sd->sc;
-	const struct TimerData *timer;
+	const struct TimerData *td;
 
 	chrif_check(-1);
-	tick = iTimer->gettick();
+	tick = timer->gettick();
 	
 	WFIFOHEAD(char_fd, 14 + SC_MAX*sizeof(struct status_change_data));
 	WFIFOW(char_fd,0) = 0x2b1c;
@@ -1184,10 +1184,10 @@ int chrif_save_scdata(struct map_session_data *sd) { //parses the sc_data of the
 		if (!sc->data[i])
 			continue;
 		if (sc->data[i]->timer != INVALID_TIMER) {
-			timer = iTimer->get_timer(sc->data[i]->timer);
-			if (timer == NULL || timer->func != iStatus->change_timer || DIFF_TICK(timer->tick,tick) < 0)
+			td = timer->get(sc->data[i]->timer);
+			if (td == NULL || td->func != iStatus->change_timer || DIFF_TICK(td->tick,tick) < 0)
 				continue;
-			data.tick = DIFF_TICK(timer->tick,tick); //Duration that is left before ending.
+			data.tick = DIFF_TICK(td->tick,tick); //Duration that is left before ending.
 		} else
 			data.tick = -1; //Infinite duration
 		data.type = i;
@@ -1342,7 +1342,7 @@ void chrif_on_disconnect(void) {
 	iMap->eraseallipport();
 
 	//Attempt to reconnect in a second. [Skotlex]
-	iTimer->add_timer(iTimer->gettick() + 1000, check_connect_char_server, 0, 0);
+	timer->add(timer->gettick() + 1000, check_connect_char_server, 0, 0);
 }
 
 
@@ -1643,17 +1643,17 @@ int do_init_chrif(void) {
 	auth_db = idb_alloc(DB_OPT_BASE);
 	auth_db_ers = ers_new(sizeof(struct auth_node),"chrif.c::auth_db_ers",ERS_OPT_NONE);
 
-	iTimer->add_timer_func_list(check_connect_char_server, "check_connect_char_server");
-	iTimer->add_timer_func_list(auth_db_cleanup, "auth_db_cleanup");
+	timer->add_func_list(check_connect_char_server, "check_connect_char_server");
+	timer->add_func_list(auth_db_cleanup, "auth_db_cleanup");
 
 	// establish map-char connection if not present
-	iTimer->add_timer_interval(iTimer->gettick() + 1000, check_connect_char_server, 0, 0, 10 * 1000);
+	timer->add_interval(timer->gettick() + 1000, check_connect_char_server, 0, 0, 10 * 1000);
 
 	// wipe stale data for timed-out client connection requests
-	iTimer->add_timer_interval(iTimer->gettick() + 1000, auth_db_cleanup, 0, 0, 30 * 1000);
+	timer->add_interval(timer->gettick() + 1000, auth_db_cleanup, 0, 0, 30 * 1000);
 
 	// send the user count every 10 seconds, to hide the charserver's online counting problem
-	iTimer->add_timer_interval(iTimer->gettick() + 1000, send_usercount_tochar, 0, 0, UPDATE_INTERVAL);
+	timer->add_interval(timer->gettick() + 1000, send_usercount_tochar, 0, 0, UPDATE_INTERVAL);
 
 	return 0;
 }
diff --git a/src/map/clif.c b/src/map/clif.c
index c61630bb5..74d827847 100644
--- a/src/map/clif.c
+++ b/src/map/clif.c
@@ -594,7 +594,7 @@ void clif_authok(struct map_session_data *sd)
 	struct packet_authok p;
 	
 	p.PacketType = authokType;
-	p.startTime = iTimer->gettick();
+	p.startTime = timer->gettick();
 	WBUFPOS(&p.PosDir[0],0,sd->bl.x,sd->bl.y,sd->ud.dir); /* do the stupid client math */
 	p.xSize = p.ySize = 5; /* not-used */
 	
@@ -797,7 +797,7 @@ void clif_clearunit_delayed(struct block_list* bl, clr_type type, unsigned int t
 {
 	struct block_list *tbl = ers_alloc(clif->delay_clearunit_ers, struct block_list);
 	memcpy (tbl, bl, sizeof (struct block_list));
-	iTimer->add_timer(tick, clif->clearunit_delayed_sub, (int)type, (intptr_t)tbl);
+	timer->add(tick, clif->clearunit_delayed_sub, (int)type, (intptr_t)tbl);
 }
 
 void clif_get_weapon_view(struct map_session_data* sd, unsigned short *rhand, unsigned short *lhand)
@@ -1152,7 +1152,7 @@ void clif_set_unit_walking(struct block_list* bl, struct map_session_data *tsd,
 	p.head = vd->hair_style;
 	p.weapon = vd->weapon;
 	p.accessory = vd->head_bottom;
-	p.moveStartTime = iTimer->gettick();
+	p.moveStartTime = timer->gettick();
 #if PACKETVER < 7
 	p.shield = vd->shield;
 #endif
@@ -1530,7 +1530,7 @@ void clif_walkok(struct map_session_data *sd)
 
 	WFIFOHEAD(fd, packet_len(0x87));
 	WFIFOW(fd,0)=0x87;
-	WFIFOL(fd,2)=iTimer->gettick();
+	WFIFOL(fd,2)=timer->gettick();
 	WFIFOPOS2(fd,6,sd->bl.x,sd->bl.y,sd->ud.to_x,sd->ud.to_y,8,8);
 	WFIFOSET(fd,packet_len(0x87));
 }
@@ -1601,7 +1601,7 @@ void clif_move(struct unit_data *ud)
 	WBUFW(buf,0)=0x86;
 	WBUFL(buf,2)=bl->id;
 	WBUFPOS2(buf,6,bl->x,bl->y,ud->to_x,ud->to_y,8,8);
-	WBUFL(buf,12)=iTimer->gettick();
+	WBUFL(buf,12)=timer->gettick();
 	clif->send(buf, packet_len(0x86), bl, AREA_WOS);
 	if (disguised(bl)) {
 		WBUFL(buf,2)=-bl->id;
@@ -1627,14 +1627,14 @@ int clif_delayquit(int tid, unsigned int tick, int id, intptr_t data) {
  *------------------------------------------*/
 void clif_quitsave(int fd,struct map_session_data *sd) {
 	if (!battle_config.prevent_logout ||
-		DIFF_TICK(iTimer->gettick(), sd->canlog_tick) > battle_config.prevent_logout)
+		DIFF_TICK(timer->gettick(), sd->canlog_tick) > battle_config.prevent_logout)
 		iMap->quit(sd);
 	else if (sd->fd) {
 		//Disassociate session from player (session is deleted after this function was called)
 		//And set a timer to make him quit later.
 		session[sd->fd]->session_data = NULL;
 		sd->fd = 0;
-		iTimer->add_timer(iTimer->gettick() + 10000, clif->delayquit, sd->bl.id, 0);
+		timer->add(timer->gettick() + 10000, clif->delayquit, sd->bl.id, 0);
 	}
 }
 
@@ -3730,7 +3730,7 @@ void clif_useitemack(struct map_session_data *sd,int index,int amount,bool ok)
 }
 
 void clif_hercules_chsys_send(struct hChSysCh *channel, struct map_session_data *sd, const char *msg) {
-	if( channel->msg_delay != 0 && DIFF_TICK(sd->hchsysch_tick + ( channel->msg_delay * 1000 ), iTimer->gettick()) > 0 && !pc->has_permission(sd, PC_PERM_HCHSYS_ADMIN) ) {
+	if( channel->msg_delay != 0 && DIFF_TICK(sd->hchsysch_tick + ( channel->msg_delay * 1000 ), timer->gettick()) > 0 && !pc->has_permission(sd, PC_PERM_HCHSYS_ADMIN) ) {
 		clif->colormes(sd->fd,COLOR_RED,msg_txt(1455));
 		return;
 	} else {
@@ -3740,7 +3740,7 @@ void clif_hercules_chsys_send(struct hChSysCh *channel, struct map_session_data
 		if( channel->type == hChSys_IRC )
 			ircbot->relay(sd->status.name,msg);
 		if( channel->msg_delay != 0 )
-			sd->hchsysch_tick = iTimer->gettick();
+			sd->hchsysch_tick = timer->gettick();
 	}
 }
 
@@ -9417,7 +9417,7 @@ void clif_parse_LoadEndAck(int fd,struct map_session_data *sd) {
 	if(map[sd->bl.m].flag.pvp && !(sd->sc.option&OPTION_INVISIBLE)) {
 		if(!battle_config.pk_mode) { // remove pvp stuff for pk_mode [Valaris]
 			if (!map[sd->bl.m].flag.pvp_nocalcrank)
-				sd->pvp_timer = iTimer->add_timer(iTimer->gettick()+200, pc->calc_pvprank_timer, sd->bl.id, 0);
+				sd->pvp_timer = timer->add(timer->gettick()+200, pc->calc_pvprank_timer, sd->bl.id, 0);
 			sd->pvp_rank = 0;
 			sd->pvp_lastusers = 0;
 			sd->pvp_point = 5;
@@ -9465,7 +9465,7 @@ void clif_parse_LoadEndAck(int fd,struct map_session_data *sd) {
 		if( battle_config.hom_setting&0x8 )
 			status_calc_bl(&sd->hd->bl, SCB_SPEED); //Homunc mimic their master's speed on each map change
 		if( !(battle_config.hom_setting&0x2) )
-			skill->unit_move(&sd->hd->bl,iTimer->gettick(),1); // apply land skills immediately
+			skill->unit_move(&sd->hd->bl,timer->gettick(),1); // apply land skills immediately
 	}
 
 	if( sd->md ) {
@@ -9641,7 +9641,7 @@ void clif_parse_LoadEndAck(int fd,struct map_session_data *sd) {
 
 // Trigger skill effects if you appear standing on them
 	if(!battle_config.pc_invincible_time)
-		skill->unit_move(&sd->bl,iTimer->gettick(),1);
+		skill->unit_move(&sd->bl,timer->gettick(),1);
 	
 }
 
@@ -9666,7 +9666,7 @@ void clif_parse_TickSend(int fd, struct map_session_data *sd)
 {
 	sd->client_tick = RFIFOL(fd,packet_db[RFIFOW(fd,0)].pos[0]);
 
-	clif->notify_time(sd, iTimer->gettick());
+	clif->notify_time(sd, timer->gettick());
 }
 
 
@@ -9746,7 +9746,7 @@ void clif_parse_progressbar(int fd, struct map_session_data * sd)
 {
 	int npc_id = sd->progressbar.npc_id;
 
-	if( iTimer->gettick() < sd->progressbar.timeout && sd->st )
+	if( timer->gettick() < sd->progressbar.timeout && sd->st )
 		sd->st->state = END;
 
 	sd->state.workinprogress = sd->progressbar.npc_id = sd->progressbar.timeout = 0;
@@ -9813,7 +9813,7 @@ void clif_parse_QuitGame(int fd, struct map_session_data *sd)
 {
 	/*	Rovert's prevent logout option fixed [Valaris]	*/
 	if( !sd->sc.data[SC_CLOAKING] && !sd->sc.data[SC_HIDING] && !sd->sc.data[SC_CHASEWALK] && !sd->sc.data[SC_CLOAKINGEXCEED] &&
-		(!battle_config.prevent_logout || DIFF_TICK(iTimer->gettick(), sd->canlog_tick) > battle_config.prevent_logout) )
+		(!battle_config.prevent_logout || DIFF_TICK(timer->gettick(), sd->canlog_tick) > battle_config.prevent_logout) )
 	{
 		set_eof(fd);
 
@@ -9896,9 +9896,9 @@ void clif_parse_GlobalMessage(int fd, struct map_session_data* sd)
 		return;
 
 	if( battle_config.min_chat_delay ) { //[Skotlex]
-		if (DIFF_TICK(sd->cantalk_tick, iTimer->gettick()) > 0)
+		if (DIFF_TICK(sd->cantalk_tick, timer->gettick()) > 0)
 			return;
-		sd->cantalk_tick = iTimer->gettick() + battle_config.min_chat_delay;
+		sd->cantalk_tick = timer->gettick() + battle_config.min_chat_delay;
 	}
 
 	if( (sd->class_&MAPID_UPPERMASK) == MAPID_SUPER_NOVICE ) {
@@ -9941,16 +9941,16 @@ void clif_parse_GlobalMessage(int fd, struct map_session_data* sd)
 		unsigned char mylen = 1;
 
 		if( sd->disguise == -1 ) {
-			sd->fontcolor_tid = iTimer->add_timer(iTimer->gettick()+5000, clif->undisguise_timer, sd->bl.id, 0);
+			sd->fontcolor_tid = timer->add(timer->gettick()+5000, clif->undisguise_timer, sd->bl.id, 0);
 			pc->disguise(sd,sd->status.class_);
 			if( pc_isdead(sd) )
 				clif_clearunit_single(-sd->bl.id, CLR_DEAD, sd->fd);
 			if( unit->is_walking(&sd->bl) )
 				clif->move(&sd->ud);
 		} else if ( sd->disguise == sd->status.class_ && sd->fontcolor_tid != INVALID_TIMER ) {
-			const struct TimerData *timer;
-			if( (timer = iTimer->get_timer(sd->fontcolor_tid)) ) {
-				iTimer->settick_timer(sd->fontcolor_tid, timer->tick+5000);
+			const struct TimerData *td;
+			if( (td = timer->get(sd->fontcolor_tid)) ) {
+				timer->settick(sd->fontcolor_tid, td->tick+5000);
 			}
 		}
 		
@@ -10337,7 +10337,7 @@ void clif_parse_ActionRequest(int fd, struct map_session_data *sd)
 	clif->pActionRequest_sub(sd,
 		RFIFOB(fd,packet_db[RFIFOW(fd,0)].pos[1]),
 		RFIFOL(fd,packet_db[RFIFOW(fd,0)].pos[0]),
-		iTimer->gettick()
+		timer->gettick()
 	);
 }
 
@@ -10355,7 +10355,7 @@ void clif_parse_Restart(int fd, struct map_session_data *sd) {
 		case 0x01:
 			/*	Rovert's Prevent logout option - Fixed [Valaris]	*/
 			if( !sd->sc.data[SC_CLOAKING] && !sd->sc.data[SC_HIDING] && !sd->sc.data[SC_CHASEWALK] && !sd->sc.data[SC_CLOAKINGEXCEED] &&
-				(!battle_config.prevent_logout || DIFF_TICK(iTimer->gettick(), sd->canlog_tick) > battle_config.prevent_logout) )
+				(!battle_config.prevent_logout || DIFF_TICK(timer->gettick(), sd->canlog_tick) > battle_config.prevent_logout) )
 			{	//Send to char-server for character selection.
 				chrif->charselectreq(sd, session[fd]->client_addr);
 			} else {
@@ -10387,10 +10387,10 @@ void clif_parse_WisMessage(int fd, struct map_session_data* sd)
 		return;
 
 	if (battle_config.min_chat_delay) { //[Skotlex]
-		if (DIFF_TICK(sd->cantalk_tick, iTimer->gettick()) > 0) {
+		if (DIFF_TICK(sd->cantalk_tick, timer->gettick()) > 0) {
 			return;
 		}
-		sd->cantalk_tick = iTimer->gettick() + battle_config.min_chat_delay;
+		sd->cantalk_tick = timer->gettick() + battle_config.min_chat_delay;
 	}
 
 	// Chat logging type 'W' / Whisper
@@ -10827,7 +10827,7 @@ void clif_parse_NpcClicked(int fd,struct map_session_data *sd)
 	switch (bl->type) {
 		case BL_MOB:
 		case BL_PC:
-			clif->pActionRequest_sub(sd, 0x07, bl->id, iTimer->gettick());
+			clif->pActionRequest_sub(sd, 0x07, bl->id, timer->gettick());
 			break;
 		case BL_NPC:
 			if( sd->ud.skill_id < RK_ENCHANTBLADE && sd->ud.skilltimer != INVALID_TIMER ) {// TODO: should only work with none 3rd job skills
@@ -11326,7 +11326,7 @@ void clif_parse_UseSkillToId(int fd, struct map_session_data *sd)
 {
 	uint16 skill_id, skill_lv;
 	int tmp, target_id;
-	unsigned int tick = iTimer->gettick();
+	unsigned int tick = timer->gettick();
 
 	skill_lv = RFIFOW(fd,packet_db[RFIFOW(fd,0)].pos[0]);
 	skill_id = RFIFOW(fd,packet_db[RFIFOW(fd,0)].pos[1]);
@@ -11426,7 +11426,7 @@ void clif_parse_UseSkillToId(int fd, struct map_session_data *sd)
  *------------------------------------------*/
 void clif_parse_UseSkillToPosSub(int fd, struct map_session_data *sd, uint16 skill_lv, uint16 skill_id, short x, short y, int skillmoreinfo)
 {
-	unsigned int tick = iTimer->gettick();
+	unsigned int tick = timer->gettick();
 
 	if( !(skill->get_inf(skill_id)&INF_GROUND_SKILL) )
 		return; //Using a target skill on the ground? WRONG.
@@ -12200,9 +12200,9 @@ void clif_parse_PartyMessage(int fd, struct map_session_data* sd)
 
 	if( battle_config.min_chat_delay )
 	{	//[Skotlex]
-		if (DIFF_TICK(sd->cantalk_tick, iTimer->gettick()) > 0)
+		if (DIFF_TICK(sd->cantalk_tick, timer->gettick()) > 0)
 			return;
-		sd->cantalk_tick = iTimer->gettick() + battle_config.min_chat_delay;
+		sd->cantalk_tick = timer->gettick() + battle_config.min_chat_delay;
 	}
 
 	party->send_message(sd, text, textlen);
@@ -13041,9 +13041,9 @@ void clif_parse_GuildMessage(int fd, struct map_session_data* sd)
 
 	if( battle_config.min_chat_delay )
 	{	//[Skotlex]
-		if (DIFF_TICK(sd->cantalk_tick, iTimer->gettick()) > 0)
+		if (DIFF_TICK(sd->cantalk_tick, timer->gettick()) > 0)
 			return;
-		sd->cantalk_tick = iTimer->gettick() + battle_config.min_chat_delay;
+		sd->cantalk_tick = timer->gettick() + battle_config.min_chat_delay;
 	}
 
 	if( sd->bg_id )
@@ -14834,7 +14834,7 @@ void clif_parse_Mail_send(int fd, struct map_session_data *sd)
 		return;
 	}
 
-	if( DIFF_TICK(sd->cansendmail_tick, iTimer->gettick()) > 0 ) {
+	if( DIFF_TICK(sd->cansendmail_tick, timer->gettick()) > 0 ) {
 		clif->message(sd->fd,msg_txt(675)); //"Cannot send mails too fast!!."
 		clif->mail_send(fd, true); // fail
 		return;
@@ -14872,7 +14872,7 @@ void clif_parse_Mail_send(int fd, struct map_session_data *sd)
 	if( !intif->Mail_send(sd->status.account_id, &msg) )
 		mail->deliveryfail(sd, &msg);
 
-	sd->cansendmail_tick = iTimer->gettick() + 1000; // 1 Second flood Protection
+	sd->cansendmail_tick = timer->gettick() + 1000; // 1 Second flood Protection
 }
 
 
@@ -15411,11 +15411,11 @@ void clif_bossmapinfo(int fd, struct mob_data *md, short flag)
 			} else
 				WFIFOB(fd,2) = 2; // First Time
 		} else if (md->spawn_timer != INVALID_TIMER) { // Boss is Dead
-			const struct TimerData * timer_data = iTimer->get_timer(md->spawn_timer);
+			const struct TimerData * timer_data = timer->get(md->spawn_timer);
 			unsigned int seconds;
 			int hours, minutes;
 
-			seconds = DIFF_TICK(timer_data->tick, iTimer->gettick()) / 1000 + 60;
+			seconds = DIFF_TICK(timer_data->tick, timer->gettick()) / 1000 + 60;
 			hours = seconds / (60 * 60);
 			seconds = seconds - (60 * 60 * hours);
 			minutes = seconds / 60;
@@ -15961,9 +15961,9 @@ void clif_parse_BattleChat(int fd, struct map_session_data* sd)
 		return;
 
 	if( battle_config.min_chat_delay ) {
-		if( DIFF_TICK(sd->cantalk_tick, iTimer->gettick()) > 0 )
+		if( DIFF_TICK(sd->cantalk_tick, timer->gettick()) > 0 )
 			return;
-		sd->cantalk_tick = iTimer->gettick() + battle_config.min_chat_delay;
+		sd->cantalk_tick = timer->gettick() + battle_config.min_chat_delay;
 	}
 
 	bg->send_message(sd, text, textlen);
@@ -17397,11 +17397,11 @@ void clif_maptypeproperty2(struct block_list *bl,enum send_target t) {
 	p.flag.guild = 1;
 	p.flag.siege = map_flag_gvg2(bl->m) ? 1: 0;
 	p.flag.mineffect = 1;
-	p.flag.nolockon = 0;
+	p.flag.nolockon = 1;
 	p.flag.countpk = map[bl->m].flag.pvp ? 1 : 0;
 	p.flag.nopartyformation = 0;
-	p.flag.noitemconsumption = 0;
-	p.flag.summonstarmiracle = 0;
+	p.flag.noitemconsumption = 1;
+	p.flag.summonstarmiracle = 1;
 	p.flag.bg = map[bl->m].flag.battleground ? 1 : 0;
 	
 	clif->send(&p,sizeof(p),bl,t);
@@ -17909,8 +17909,8 @@ int do_init_clif(void) {
 		exit(EXIT_FAILURE);
 	}
 
-	iTimer->add_timer_func_list(clif->clearunit_delayed_sub, "clif_clearunit_delayed_sub");
-	iTimer->add_timer_func_list(clif->delayquit, "clif_delayquit");
+	timer->add_func_list(clif->clearunit_delayed_sub, "clif_clearunit_delayed_sub");
+	timer->add_func_list(clif->delayquit, "clif_delayquit");
 
 	clif->delay_clearunit_ers = ers_new(sizeof(struct block_list),"clif.c::delay_clearunit_ers",ERS_OPT_CLEAR);
 
diff --git a/src/map/elemental.c b/src/map/elemental.c
index 855d9e2c6..3a6ab2105 100644
--- a/src/map/elemental.c
+++ b/src/map/elemental.c
@@ -145,8 +145,8 @@ int elemental_get_lifetime(struct elemental_data *ed) {
 	if( ed == NULL || ed->summon_timer == INVALID_TIMER )
 		return 0;
 
-	td = iTimer->get_timer(ed->summon_timer);
-	return (td != NULL) ? DIFF_TICK(td->tick, iTimer->gettick()) : 0;
+	td = timer->get(ed->summon_timer);
+	return (td != NULL) ? DIFF_TICK(td->tick, timer->gettick()) : 0;
 }
 
 int elemental_save(struct elemental_data *ed) {
@@ -190,7 +190,7 @@ static int elemental_summon_end(int tid, unsigned int tick, int id, intptr_t dat
 void elemental_summon_stop(struct elemental_data *ed) {
 	nullpo_retv(ed);
 	if( ed->summon_timer != INVALID_TIMER )
-		iTimer->delete_timer(ed->summon_timer, elemental_summon_end);
+		timer->delete(ed->summon_timer, elemental_summon_end);
 	ed->summon_timer = INVALID_TIMER;
 }
 
@@ -215,7 +215,7 @@ int elemental_delete(struct elemental_data *ed, int reply) {
 
 void elemental_summon_init(struct elemental_data *ed) {
 	if( ed->summon_timer == INVALID_TIMER )
-		ed->summon_timer = iTimer->add_timer(iTimer->gettick() + ed->elemental.life_time, elemental_summon_end, ed->master->bl.id, 0);
+		ed->summon_timer = timer->add(timer->gettick() + ed->elemental.life_time, elemental_summon_end, ed->master->bl.id, 0);
 
 	ed->regen.state.block = 0;
 }
@@ -257,7 +257,7 @@ int elemental_data_received(struct s_elemental *ele, bool flag) {
 
 		iMap->addiddb(&ed->bl);
 		status_calc_elemental(ed,1);
-		ed->last_spdrain_time = ed->last_thinktime = iTimer->gettick();
+		ed->last_spdrain_time = ed->last_thinktime = timer->gettick();
 		ed->summon_timer = INVALID_TIMER;
 		elemental_summon_init(ed);
 	} else {
@@ -430,9 +430,9 @@ int elemental_action(struct elemental_data *ed, struct block_list *bl, unsigned
 			ed->ud.skill_lv = skill_lv;
 
 			if( skill->get_inf(skill_id) & INF_GROUND_SKILL )
-				ed->ud.skilltimer = iTimer->add_timer( tick+iStatus->get_speed(&ed->bl)*walk_dist, skill->castend_pos, ed->bl.id, 0 );
+				ed->ud.skilltimer = timer->add( tick+iStatus->get_speed(&ed->bl)*walk_dist, skill->castend_pos, ed->bl.id, 0 );
 			else
-				ed->ud.skilltimer = iTimer->add_timer( tick+iStatus->get_speed(&ed->bl)*walk_dist, skill->castend_id, ed->bl.id, 0 );
+				ed->ud.skilltimer = timer->add( tick+iStatus->get_speed(&ed->bl)*walk_dist, skill->castend_id, ed->bl.id, 0 );
 		}
 		return 1;
 
@@ -490,11 +490,11 @@ int elemental_change_mode_ack(struct elemental_data *ed, int mode) {
 
 	if( ed->ud.skilltimer != INVALID_TIMER )
 		return 0;
-	else if( DIFF_TICK(iTimer->gettick(), ed->ud.canact_tick) < 0 )
+	else if( DIFF_TICK(timer->gettick(), ed->ud.canact_tick) < 0 )
 		return 0;
 
 	ed->target_id = bl->id;	// Set new target
-	ed->last_thinktime = iTimer->gettick();
+	ed->last_thinktime = timer->gettick();
 
 	if( skill->get_inf(skill_id) & INF_GROUND_SKILL )
 		unit->skilluse_pos(&ed->bl, bl->x, bl->y, skill_id, skill_lv);
@@ -931,8 +931,8 @@ int do_init_elemental(void) {
 	read_elementaldb();
 	elemental->read_skilldb();
 
-	iTimer->add_timer_func_list(elemental_ai_timer,"elemental_ai_timer");
-	iTimer->add_timer_interval(iTimer->gettick()+MIN_ELETHINKTIME,elemental_ai_timer,0,0,MIN_ELETHINKTIME);
+	timer->add_func_list(elemental_ai_timer,"elemental_ai_timer");
+	timer->add_interval(timer->gettick()+MIN_ELETHINKTIME,elemental_ai_timer,0,0,MIN_ELETHINKTIME);
 
 	return 0;
 }
diff --git a/src/map/guild.c b/src/map/guild.c
index 6219fc770..b6dde5700 100644
--- a/src/map/guild.c
+++ b/src/map/guild.c
@@ -2235,10 +2235,10 @@ void do_init_guild(void) {
 	memset(guild_skill_tree,0,sizeof(guild_skill_tree));
 	sv->readdb(iMap->db_path, "guild_skill_tree.txt", ',', 2+MAX_GUILD_SKILL_REQUIRE*2, 2+MAX_GUILD_SKILL_REQUIRE*2, -1, &guild_read_guildskill_tree_db); //guild skill tree [Komurka]
 
-	iTimer->add_timer_func_list(guild_payexp_timer,"guild_payexp_timer");
-	iTimer->add_timer_func_list(guild_send_xy_timer, "guild_send_xy_timer");
-	iTimer->add_timer_interval(iTimer->gettick()+GUILD_PAYEXP_INVERVAL,guild_payexp_timer,0,0,GUILD_PAYEXP_INVERVAL);
-	iTimer->add_timer_interval(iTimer->gettick()+GUILD_SEND_XY_INVERVAL,guild_send_xy_timer,0,0,GUILD_SEND_XY_INVERVAL);
+	timer->add_func_list(guild_payexp_timer,"guild_payexp_timer");
+	timer->add_func_list(guild_send_xy_timer, "guild_send_xy_timer");
+	timer->add_interval(timer->gettick()+GUILD_PAYEXP_INVERVAL,guild_payexp_timer,0,0,GUILD_PAYEXP_INVERVAL);
+	timer->add_interval(timer->gettick()+GUILD_SEND_XY_INVERVAL,guild_send_xy_timer,0,0,GUILD_SEND_XY_INVERVAL);
 }
 
 void do_final_guild(void) {
diff --git a/src/map/homunculus.c b/src/map/homunculus.c
index 81971ebef..92b92106d 100644
--- a/src/map/homunculus.c
+++ b/src/map/homunculus.c
@@ -416,7 +416,7 @@ bool homunculus_evolve(struct homun_data *hd) {
 	status_calc_homunculus(hd,1);
 
 	if (!(battle_config.hom_setting&0x2))
-		skill->unit_move(&sd->hd->bl,iTimer->gettick(),1); // apply land skills immediately
+		skill->unit_move(&sd->hd->bl,timer->gettick(),1); // apply land skills immediately
 
 	return true;
 }
@@ -463,7 +463,7 @@ bool homunculus_mutate(struct homun_data *hd, int homun_id) {
 	status_calc_homunculus(hd,1);
 
 	if (!(battle_config.hom_setting&0x2))
-		skill->unit_move(&sd->hd->bl,iTimer->gettick(),1); // apply land skills immediately
+		skill->unit_move(&sd->hd->bl,timer->gettick(),1); // apply land skills immediately
 
 	return true;
 }
@@ -647,14 +647,14 @@ int homunculus_hunger_timer(int tid, unsigned int tick, int id, intptr_t data) {
 	}
 
 	clif->send_homdata(sd,SP_HUNGRY,hd->homunculus.hunger);
-	hd->hungry_timer = iTimer->add_timer(tick+hd->homunculusDB->hungryDelay,homun->hunger_timer,sd->bl.id,0); //simple Fix albator
+	hd->hungry_timer = timer->add(tick+hd->homunculusDB->hungryDelay,homun->hunger_timer,sd->bl.id,0); //simple Fix albator
 	return 0;
 }
 
 void homunculus_hunger_timer_delete(struct homun_data *hd) {
 	nullpo_retv(hd);
 	if(hd->hungry_timer != INVALID_TIMER) {
-		iTimer->delete_timer(hd->hungry_timer,homun->hunger_timer);
+		timer->delete(hd->hungry_timer,homun->hunger_timer);
 		hd->hungry_timer = INVALID_TIMER;
 	}
 }
@@ -765,7 +765,7 @@ bool homunculus_create(struct map_session_data *sd, struct s_homunculus *hom) {
 
 void homunculus_init_timers(struct homun_data * hd) {
 	if (hd->hungry_timer == INVALID_TIMER)
-		hd->hungry_timer = iTimer->add_timer(iTimer->gettick()+hd->homunculusDB->hungryDelay,homun->hunger_timer,hd->master->bl.id,0);
+		hd->hungry_timer = timer->add(timer->gettick()+hd->homunculusDB->hungryDelay,homun->hunger_timer,hd->master->bl.id,0);
 	hd->regen.state.block = 0; //Restore HP/SP block.
 }
 
@@ -1235,7 +1235,7 @@ void do_init_homunculus(void) {
 	homun->exp_db_read();
 	homun->skill_db_read();
 	// Add homunc timer function to timer func list [Toms]
-	iTimer->add_timer_func_list(homun->hunger_timer, "homunculus_hunger_timer");
+	timer->add_func_list(homun->hunger_timer, "homunculus_hunger_timer");
 
 	//Stock view data for homuncs
 	memset(&homun->viewdb, 0, sizeof(homun->viewdb));
diff --git a/src/map/instance.c b/src/map/instance.c
index 98a0dfc8f..563c4326f 100644
--- a/src/map/instance.c
+++ b/src/map/instance.c
@@ -375,7 +375,7 @@ void instance_del_map(int16 m) {
 	iMap->foreachinmap(instance_cleanup_sub, m, BL_ALL);
 
 	if( map[m].mob_delete_timer != INVALID_TIMER )
-		iTimer->delete_timer(map[m].mob_delete_timer, iMap->removemobs_timer);
+		timer->delete(map[m].mob_delete_timer, iMap->removemobs_timer);
 	
 	mapindex_removemap( map[m].index );
 
@@ -508,9 +508,9 @@ void instance_destroy(int instance_id) {
 		db_destroy(instances[instance_id].vars);
 
 	if( instances[instance_id].progress_timer != INVALID_TIMER )
-		iTimer->delete_timer( instances[instance_id].progress_timer, instance_destroy_timer);
+		timer->delete( instances[instance_id].progress_timer, instance_destroy_timer);
 	if( instances[instance_id].idle_timer != INVALID_TIMER )
-		iTimer->delete_timer( instances[instance_id].idle_timer, instance_destroy_timer);
+		timer->delete( instances[instance_id].idle_timer, instance_destroy_timer);
 
 	instances[instance_id].vars = NULL;
 
@@ -536,13 +536,13 @@ void instance_check_idle(int instance_id) {
 		idle = false;
 
 	if( instances[instance_id].idle_timer != INVALID_TIMER && !idle ) {
-		iTimer->delete_timer(instances[instance_id].idle_timer, instance_destroy_timer);
+		timer->delete(instances[instance_id].idle_timer, instance_destroy_timer);
 		instances[instance_id].idle_timer = INVALID_TIMER;
 		instances[instance_id].idle_timeout = 0;
 		clif->instance(instance_id, 3, 0); // Notify instance users normal instance expiration
 	} else if( instances[instance_id].idle_timer == INVALID_TIMER && idle ) {
 		instances[instance_id].idle_timeout = now + instances[instance_id].idle_timeoutval;
-		instances[instance_id].idle_timer = iTimer->add_timer( iTimer->gettick() + instances[instance_id].idle_timeoutval * 1000, instance_destroy_timer, instance_id, 0);
+		instances[instance_id].idle_timer = timer->add( timer->gettick() + instances[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
 	}
 }
@@ -558,13 +558,13 @@ void instance_set_timeout(int instance_id, unsigned int progress_timeout, unsign
 		return;
 
 	if( instances[instance_id].progress_timer != INVALID_TIMER )
-		iTimer->delete_timer( instances[instance_id].progress_timer, instance_destroy_timer);
+		timer->delete( instances[instance_id].progress_timer, instance_destroy_timer);
 	if( instances[instance_id].idle_timer != INVALID_TIMER )
-		iTimer->delete_timer( instances[instance_id].idle_timer, instance_destroy_timer);
+		timer->delete( instances[instance_id].idle_timer, instance_destroy_timer);
 
 	if( progress_timeout ) {
 		instances[instance_id].progress_timeout = now + progress_timeout;
-		instances[instance_id].progress_timer = iTimer->add_timer( iTimer->gettick() + progress_timeout * 1000, instance_destroy_timer, instance_id, 0);
+		instances[instance_id].progress_timer = timer->add( timer->gettick() + progress_timeout * 1000, instance_destroy_timer, instance_id, 0);
 	} else {
 		instances[instance_id].progress_timeout = 0;
 		instances[instance_id].progress_timer = INVALID_TIMER;
@@ -613,7 +613,7 @@ void do_final_instance(void) {
 }
 
 void do_init_instance(void) {
-	iTimer->add_timer_func_list(instance_destroy_timer, "instance_destroy_timer");
+	timer->add_func_list(instance_destroy_timer, "instance_destroy_timer");
 }
 
 void instance_defaults(void) {
diff --git a/src/map/irc-bot.c b/src/map/irc-bot.c
index b17015b66..5225672af 100644
--- a/src/map/irc-bot.c
+++ b/src/map/irc-bot.c
@@ -27,7 +27,7 @@ char send_string[IRC_MESSAGE_LENGTH];
 
 /**
  * Timer callback to (re-)connect to an IRC server
- * @see iTimer->do_timer
+ * @see timer->do_timer
  */
 int irc_connect_timer(int tid, unsigned int tick, int id, intptr_t data) {
 	struct hSockOpt opt;
@@ -37,12 +37,12 @@ int irc_connect_timer(int tid, unsigned int tick, int id, intptr_t data) {
 	opt.silent = 1;
 	opt.setTimeo = 0;
 	
-	ircbot->last_try = iTimer->gettick();
+	ircbot->last_try = timer->gettick();
 
 	if( ( ircbot->fd = make_connection(ircbot->ip,hChSys.irc_server_port,&opt) ) > 0 ){
 		session[ircbot->fd]->func_parse = ircbot->parse;
 		session[ircbot->fd]->flag.server = 1;
-		iTimer->add_timer(iTimer->gettick() + 3000, ircbot->identify_timer, 0, 0);
+		timer->add(timer->gettick() + 3000, ircbot->identify_timer, 0, 0);
 		ircbot->isOn = true;
 	}
 	return 0;
@@ -50,7 +50,7 @@ int irc_connect_timer(int tid, unsigned int tick, int id, intptr_t data) {
 
 /**
  * Timer callback to send identification commands to an IRC server
- * @see iTimer->do_timer
+ * @see timer->do_timer
  */
 int irc_identify_timer(int tid, unsigned int tick, int id, intptr_t data) {
 	if( !ircbot->isOn )
@@ -61,14 +61,14 @@ int irc_identify_timer(int tid, unsigned int tick, int id, intptr_t data) {
 	sprintf(send_string, "NICK %s", hChSys.irc_nick);
 	ircbot->send(send_string);
 
-	iTimer->add_timer(iTimer->gettick() + 3000, ircbot->join_timer, 0, 0);
+	timer->add(timer->gettick() + 3000, ircbot->join_timer, 0, 0);
 	
 	return 0;
 }
 
 /**
  * Timer callback to join channels (and optionally send NickServ commands)
- * @see iTimer->do_timer
+ * @see timer->do_timer
  */
 int irc_join_timer(int tid, unsigned int tick, int id, intptr_t data) {
 	if( !ircbot->isOn )
@@ -119,7 +119,7 @@ int irc_parse(int fd) {
 		ircbot->isIn = false;
 		ircbot->fails = 0;
 		ircbot->ip = host2ip(hChSys.irc_server);
-		iTimer->add_timer(iTimer->gettick() + 120000, ircbot->connect_timer, 0, 0);
+		timer->add(timer->gettick() + 120000, ircbot->connect_timer, 0, 0);
       	return 0;
 	}
 	
@@ -427,8 +427,8 @@ void irc_bot_init(void) {
 	ircbot->isIn = false;
 	ircbot->isOn = false;
 	
-	iTimer->add_timer_func_list(ircbot->connect_timer, "irc_connect_timer");
-	iTimer->add_timer(iTimer->gettick() + 7000, ircbot->connect_timer, 0, 0);
+	timer->add_func_list(ircbot->connect_timer, "irc_connect_timer");
+	timer->add(timer->gettick() + 7000, ircbot->connect_timer, 0, 0);
 }
 
 /**
diff --git a/src/map/map.c b/src/map/map.c
index d4568766a..aff696f06 100644
--- a/src/map/map.c
+++ b/src/map/map.c
@@ -1204,7 +1204,7 @@ void map_clearflooritem(struct block_list *bl) {
 	struct flooritem_data* fitem = (struct flooritem_data*)bl;
 
 	if( fitem->cleartimer )
-		iTimer->delete_timer(fitem->cleartimer,iMap->clearflooritem_timer);
+		timer->delete(fitem->cleartimer,iMap->clearflooritem_timer);
 
 	clif->clearflooritem(fitem, 0);
 	iMap->deliddb(&fitem->bl);
@@ -1359,7 +1359,7 @@ int map_addflooritem(struct item *item_data,int amount,int16 m,int16 x,int16 y,i
 	}
 
 	fitem->first_get_charid = first_charid;
-	fitem->first_get_tick = iTimer->gettick() + (flags&1 ? battle_config.mvp_item_first_get_time : battle_config.item_first_get_time);
+	fitem->first_get_tick = timer->gettick() + (flags&1 ? battle_config.mvp_item_first_get_time : battle_config.item_first_get_time);
 	fitem->second_get_charid = second_charid;
 	fitem->second_get_tick = fitem->first_get_tick + (flags&1 ? battle_config.mvp_item_second_get_time : battle_config.item_second_get_time);
 	fitem->third_get_charid = third_charid;
@@ -1369,7 +1369,7 @@ int map_addflooritem(struct item *item_data,int amount,int16 m,int16 x,int16 y,i
 	fitem->item_data.amount=amount;
 	fitem->subx=(r&3)*3+3;
 	fitem->suby=((r>>2)&3)*3+3;
-	fitem->cleartimer=iTimer->add_timer(iTimer->gettick()+battle_config.flooritem_lifetime,iMap->clearflooritem_timer,fitem->bl.id,0);
+	fitem->cleartimer=timer->add(timer->gettick()+battle_config.flooritem_lifetime,iMap->clearflooritem_timer,fitem->bl.id,0);
 
 	iMap->addiddb(&fitem->bl);
 	iMap->addblock(&fitem->bl);
@@ -2096,7 +2096,7 @@ void map_spawnmobs(int16 m)
 	int i, k=0;
 	if (map[m].mob_delete_timer != INVALID_TIMER)
 	{	//Mobs have not been removed yet [Skotlex]
-		iTimer->delete_timer(map[m].mob_delete_timer, iMap->removemobs_timer);
+		timer->delete(map[m].mob_delete_timer, iMap->removemobs_timer);
 		map[m].mob_delete_timer = INVALID_TIMER;
 		return;
 	}
@@ -2170,7 +2170,7 @@ void map_removemobs(int16 m)
 	if (map[m].mob_delete_timer != INVALID_TIMER) // should never happen
 		return; //Mobs are already scheduled for removal
 
-	map[m].mob_delete_timer = iTimer->add_timer(iTimer->gettick()+battle_config.mob_remove_delay, iMap->removemobs_timer, m, 0);
+	map[m].mob_delete_timer = timer->add(timer->gettick()+battle_config.mob_remove_delay, iMap->removemobs_timer, m, 0);
 }
 
 /*==========================================
@@ -2867,7 +2867,7 @@ void map_clean(int i) {
 	if(battle_config.dynamic_mobs) { //Dynamic mobs flag by [random]
 		int j;
 		if(map[i].mob_delete_timer != INVALID_TIMER)
-			iTimer->delete_timer(map[i].mob_delete_timer, iMap->removemobs_timer);
+			timer->delete(map[i].mob_delete_timer, iMap->removemobs_timer);
 		for (j=0; j<MAX_MOB_LIST_PER_MAP; j++)
 			if (map[i].moblist[j]) aFree(map[i].moblist[j]);
 	}
@@ -2920,7 +2920,7 @@ void do_final_maps(void) {
 		if(battle_config.dynamic_mobs) { //Dynamic mobs flag by [random]
 			int j;
 			if(map[i].mob_delete_timer != INVALID_TIMER)
-				iTimer->delete_timer(map[i].mob_delete_timer, iMap->removemobs_timer);
+				timer->delete(map[i].mob_delete_timer, iMap->removemobs_timer);
 			for (j=0; j<MAX_MOB_LIST_PER_MAP; j++)
 				if (map[i].moblist[j]) aFree(map[i].moblist[j]);
 		}
@@ -5399,10 +5399,10 @@ int do_init(int argc, char *argv[])
 
 	map_readallmaps();
 
-	iTimer->add_timer_func_list(map_freeblock_timer, "map_freeblock_timer");
-	iTimer->add_timer_func_list(map_clearflooritem_timer, "map_clearflooritem_timer");
-	iTimer->add_timer_func_list(map_removemobs_timer, "map_removemobs_timer");
-	iTimer->add_timer_interval(iTimer->gettick()+1000, map_freeblock_timer, 0, 0, 60*1000);
+	timer->add_func_list(map_freeblock_timer, "map_freeblock_timer");
+	timer->add_func_list(map_clearflooritem_timer, "map_clearflooritem_timer");
+	timer->add_func_list(map_removemobs_timer, "map_removemobs_timer");
+	timer->add_interval(timer->gettick()+1000, map_freeblock_timer, 0, 0, 60*1000);
 
 	HPM->load_sub = HPM_map_plugin_load_sub;
 	HPM->symbol_defaults_sub = map_hp_symbols;
diff --git a/src/map/mapreg_sql.c b/src/map/mapreg_sql.c
index c0bfeb987..0a0b8f75f 100644
--- a/src/map/mapreg_sql.c
+++ b/src/map/mapreg_sql.c
@@ -295,8 +295,8 @@ void mapreg_init(void) {
 
 	mapreg->load();
 
-	iTimer->add_timer_func_list(mapreg->save_timer, "mapreg_script_autosave_mapreg");
-	iTimer->add_timer_interval(iTimer->gettick() + MAPREG_AUTOSAVE_INTERVAL, mapreg->save_timer, 0, 0, MAPREG_AUTOSAVE_INTERVAL);
+	timer->add_func_list(mapreg->save_timer, "mapreg_script_autosave_mapreg");
+	timer->add_interval(timer->gettick() + MAPREG_AUTOSAVE_INTERVAL, mapreg->save_timer, 0, 0, MAPREG_AUTOSAVE_INTERVAL);
 }
 
 bool mapreg_config_read(const char* w1, const char* w2) {
diff --git a/src/map/mercenary.c b/src/map/mercenary.c
index bf802c643..0e89d62a9 100644
--- a/src/map/mercenary.c
+++ b/src/map/mercenary.c
@@ -93,8 +93,8 @@ int mercenary_get_lifetime(struct mercenary_data *md)
 	if( md == NULL || md->contract_timer == INVALID_TIMER )
 		return 0;
 
-	td = iTimer->get_timer(md->contract_timer);
-	return (td != NULL) ? DIFF_TICK(td->tick, iTimer->gettick()) : 0;
+	td = timer->get(md->contract_timer);
+	return (td != NULL) ? DIFF_TICK(td->tick, timer->gettick()) : 0;
 }
 
 int mercenary_get_guild(struct mercenary_data *md)
@@ -269,14 +269,14 @@ void merc_contract_stop(struct mercenary_data *md)
 {
 	nullpo_retv(md);
 	if( md->contract_timer != INVALID_TIMER )
-		iTimer->delete_timer(md->contract_timer, merc_contract_end);
+		timer->delete(md->contract_timer, merc_contract_end);
 	md->contract_timer = INVALID_TIMER;
 }
 
 void merc_contract_init(struct mercenary_data *md)
 {
 	if( md->contract_timer == INVALID_TIMER )
-		md->contract_timer = iTimer->add_timer(iTimer->gettick() + md->mercenary.life_time, merc_contract_end, md->master->bl.id, 0);
+		md->contract_timer = timer->add(timer->gettick() + md->mercenary.life_time, merc_contract_end, md->master->bl.id, 0);
 
 	md->regen.state.block = 0;
 }
diff --git a/src/map/mob.c b/src/map/mob.c
index 146f82239..4506ca242 100644
--- a/src/map/mob.c
+++ b/src/map/mob.c
@@ -341,7 +341,7 @@ bool mob_ksprotected (struct block_list *src, struct block_list *target)
 		*t_sd;  // Mob Target
 	struct status_change_entry *sce;
 	struct mob_data *md;
-	unsigned int tick = iTimer->gettick();
+	unsigned int tick = timer->gettick();
 	char output[128];
 
 	if( !battle_config.ksprotection )
@@ -491,7 +491,7 @@ int mob_once_spawn(struct map_session_data* sd, int16 m, int16 x, int16 y, const
 					memcpy(md->guardian_data->guild_name, g->name, NAME_LENGTH);
 				}
 				else if (gc->guild_id) //Guild not yet available, retry in 5.
-					iTimer->add_timer(iTimer->gettick()+5000,mob->spawn_guardian_sub,md->bl.id,md->guardian_data->guild_id);
+					timer->add(timer->gettick()+5000,mob->spawn_guardian_sub,md->bl.id,md->guardian_data->guild_id);
 			}
 		}	// end addition [Valaris]
 
@@ -709,7 +709,7 @@ int mob_spawn_guardian(const char* mapname, short x, short y, const char* mobnam
 		memcpy (md->guardian_data->guild_name, g->name, NAME_LENGTH);
 		md->guardian_data->guardup_lv = guild->checkskill(g,GD_GUARDUP);
 	} else if (md->guardian_data->guild_id)
-		iTimer->add_timer(iTimer->gettick()+5000,mob->spawn_guardian_sub,md->bl.id,md->guardian_data->guild_id);
+		timer->add(timer->gettick()+5000,mob->spawn_guardian_sub,md->bl.id,md->guardian_data->guild_id);
 	mob->spawn(md);
 
 	return md->bl.id;
@@ -873,8 +873,8 @@ int mob_setdelayspawn(struct mob_data *md)
 		spawntime = 5000;
 
 	if( md->spawn_timer != INVALID_TIMER )
-		iTimer->delete_timer(md->spawn_timer, mob->delayspawn);
-	md->spawn_timer = iTimer->add_timer(iTimer->gettick()+spawntime, mob->delayspawn, md->bl.id, 0);
+		timer->delete(md->spawn_timer, mob->delayspawn);
+	md->spawn_timer = timer->add(timer->gettick()+spawntime, mob->delayspawn, md->bl.id, 0);
 	return 0;
 }
 
@@ -895,7 +895,7 @@ int mob_count_sub(struct block_list *bl, va_list ap) {
 int mob_spawn (struct mob_data *md)
 {
 	int i=0;
-	unsigned int tick = iTimer->gettick();
+	unsigned int tick = timer->gettick();
 	int c =0;
 
 	md->last_thinktime = tick;
@@ -918,16 +918,16 @@ int mob_spawn (struct mob_data *md)
 			if( !iMap->search_freecell(&md->bl, -1, &md->bl.x, &md->bl.y, md->spawn->xs, md->spawn->ys, battle_config.no_spawn_on_player?4:0) )
 			{ // retry again later
 				if( md->spawn_timer != INVALID_TIMER )
-					iTimer->delete_timer(md->spawn_timer, mob->delayspawn);
-				md->spawn_timer = iTimer->add_timer(tick+5000,mob->delayspawn,md->bl.id,0);
+					timer->delete(md->spawn_timer, mob->delayspawn);
+				md->spawn_timer = timer->add(tick+5000,mob->delayspawn,md->bl.id,0);
 				return 1;
 			}
 		}
 		else if( battle_config.no_spawn_on_player > 99 && iMap->foreachinrange(mob->count_sub, &md->bl, AREA_SIZE, BL_PC) )
 		{ // retry again later (players on sight)
 			if( md->spawn_timer != INVALID_TIMER )
-				iTimer->delete_timer(md->spawn_timer, mob->delayspawn);
-			md->spawn_timer = iTimer->add_timer(tick+5000,mob->delayspawn,md->bl.id,0);
+				timer->delete(md->spawn_timer, mob->delayspawn);
+			md->spawn_timer = timer->add(tick+5000,mob->delayspawn,md->bl.id,0);
 			return 1;
 		}
 	}
@@ -941,7 +941,7 @@ int mob_spawn (struct mob_data *md)
 	md->ud.target_to = 0;
 	if( md->spawn_timer != INVALID_TIMER )
 	{
-		iTimer->delete_timer(md->spawn_timer, mob->delayspawn);
+		timer->delete(md->spawn_timer, mob->delayspawn);
 		md->spawn_timer = INVALID_TIMER;
 	}
 
@@ -2049,7 +2049,7 @@ void mob_damage(struct mob_data *md, struct block_list *src, int damage) {
 		//Log damage
 		if (src)
 			mob->log_damage(md, src, damage);
-		md->dmgtick = iTimer->gettick();
+		md->dmgtick = timer->gettick();
 	}
 
 	if (battle_config.show_mob_info&3)
@@ -2073,7 +2073,7 @@ void mob_damage(struct mob_data *md, struct block_list *src, int damage) {
 
 	if( md->special_state.ai == 2 ) {//LOne WOlf explained that ANYONE can trigger the marine countdown skill. [Skotlex]
 		md->state.alchemist = 1;
-		mob->skill_use(md, iTimer->gettick(), MSC_ALCHEMIST);
+		mob->skill_use(md, timer->gettick(), MSC_ALCHEMIST);
 	}
 }
 
@@ -2094,7 +2094,7 @@ int mob_dead(struct mob_data *md, struct block_list *src, int type)
 	} pt[DAMAGELOG_SIZE];
 	int i, temp, count, m = md->bl.m, pnum = 0;
 	int dmgbltypes = 0;  // bitfield of all bl types, that caused damage to the mob and are elligible for exp distribution
-	unsigned int mvp_damage, tick = iTimer->gettick();
+	unsigned int mvp_damage, tick = timer->gettick();
 	bool rebirth, homkillonly;
 
 	status = &md->status;
@@ -2441,7 +2441,7 @@ int mob_dead(struct mob_data *md, struct block_list *src, int type)
 				mob->item_drop(md, dlist, mob->setlootitem(&md->lootitem[i]), 1, 10000, homkillonly);
 		}
 		if (dlist->item) //There are drop items.
-			iTimer->add_timer(tick + (!battle_config.delay_battle_damage?500:0), mob->delay_item_drop, 0, (intptr_t)dlist);
+			timer->add(tick + (!battle_config.delay_battle_damage?500:0), mob->delay_item_drop, 0, (intptr_t)dlist);
 		else //No drops
 			ers_free(item_drop_list_ers, dlist);
 	} else if (md->lootitem && md->lootitem_count) {	//Loot MUST drop!
@@ -2455,7 +2455,7 @@ int mob_dead(struct mob_data *md, struct block_list *src, int type)
 		dlist->item = NULL;
 		for(i = 0; i < md->lootitem_count; i++)
 			mob->item_drop(md, dlist, mob->setlootitem(&md->lootitem[i]), 1, 10000, homkillonly);
-		iTimer->add_timer(tick + (!battle_config.delay_battle_damage?500:0), mob->delay_item_drop, 0, (intptr_t)dlist);
+		timer->add(tick + (!battle_config.delay_battle_damage?500:0), mob->delay_item_drop, 0, (intptr_t)dlist);
 	}
 
 	if(mvp_sd && md->db->mexp > 0 && !md->special_state.ai) {
@@ -2594,7 +2594,7 @@ int mob_dead(struct mob_data *md, struct block_list *src, int type)
 	}
 
 	if(md->deletetimer != INVALID_TIMER) {
-		iTimer->delete_timer(md->deletetimer,mob->timer_delete);
+		timer->delete(md->deletetimer,mob->timer_delete);
 		md->deletetimer = INVALID_TIMER;
 	}
 	/**
@@ -2636,7 +2636,7 @@ int mob_dead(struct mob_data *md, struct block_list *src, int type)
 
 void mob_revive(struct mob_data *md, unsigned int hp)
 {
-	unsigned int tick = iTimer->gettick();
+	unsigned int tick = timer->gettick();
 	md->state.skillstate = MSS_IDLE;
 	md->last_thinktime = tick;
 	md->next_walktime = tick+rnd()%50+5000;
@@ -2721,7 +2721,7 @@ int mob_random_class (int *value, size_t count)
  *------------------------------------------*/
 int mob_class_change (struct mob_data *md, int class_)
 {
-	unsigned int tick = iTimer->gettick();
+	unsigned int tick = timer->gettick();
 	int i, c, hp_rate;
 
 	nullpo_ret(md);
@@ -3520,8 +3520,8 @@ int mob_clone_spawn(struct map_session_data *sd, int16 m, int16 x, int16 y, cons
 		if (duration) //Auto Delete after a while.
 		{
 			if( md->deletetimer != INVALID_TIMER )
-				iTimer->delete_timer(md->deletetimer, mob->timer_delete);
-			md->deletetimer = iTimer->add_timer (iTimer->gettick() + duration, mob->timer_delete, md->bl.id, 0);
+				timer->delete(md->deletetimer, mob->timer_delete);
+			md->deletetimer = timer->add (timer->gettick() + duration, mob->timer_delete, md->bl.id, 0);
 		}
 	}
 
@@ -4655,15 +4655,15 @@ int do_init_mob(void)
 
 	mob->load();
 
-	iTimer->add_timer_func_list(mob->delayspawn,"mob_delayspawn");
-	iTimer->add_timer_func_list(mob->delay_item_drop,"mob_delay_item_drop");
-	iTimer->add_timer_func_list(mob->ai_hard,"mob_ai_hard");
-	iTimer->add_timer_func_list(mob->ai_lazy,"mob_ai_lazy");
-	iTimer->add_timer_func_list(mob->timer_delete,"mob_timer_delete");
-	iTimer->add_timer_func_list(mob->spawn_guardian_sub,"mob_spawn_guardian_sub");
-	iTimer->add_timer_func_list(mob->respawn,"mob_respawn");
-	iTimer->add_timer_interval(iTimer->gettick()+MIN_MOBTHINKTIME,mob->ai_hard,0,0,MIN_MOBTHINKTIME);
-	iTimer->add_timer_interval(iTimer->gettick()+MIN_MOBTHINKTIME*10,mob->ai_lazy,0,0,MIN_MOBTHINKTIME*10);
+	timer->add_func_list(mob->delayspawn,"mob_delayspawn");
+	timer->add_func_list(mob->delay_item_drop,"mob_delay_item_drop");
+	timer->add_func_list(mob->ai_hard,"mob_ai_hard");
+	timer->add_func_list(mob->ai_lazy,"mob_ai_lazy");
+	timer->add_func_list(mob->timer_delete,"mob_timer_delete");
+	timer->add_func_list(mob->spawn_guardian_sub,"mob_spawn_guardian_sub");
+	timer->add_func_list(mob->respawn,"mob_respawn");
+	timer->add_interval(timer->gettick()+MIN_MOBTHINKTIME,mob->ai_hard,0,0,MIN_MOBTHINKTIME);
+	timer->add_interval(timer->gettick()+MIN_MOBTHINKTIME*10,mob->ai_lazy,0,0,MIN_MOBTHINKTIME*10);
 
 	return 0;
 }
diff --git a/src/map/npc.c b/src/map/npc.c
index 51d01d711..2439969a9 100644
--- a/src/map/npc.c
+++ b/src/map/npc.c
@@ -251,7 +251,7 @@ int npc_rr_secure_timeout_timer(int tid, unsigned int tick, int id, intptr_t dat
 		clif->scriptclear(sd,sd->npc_id);
 		sd->npc_idle_timer = INVALID_TIMER;
 	} else //Create a new instance of ourselves to continue
-		sd->npc_idle_timer = iTimer->add_timer(iTimer->gettick() + (SECURE_NPCTIMEOUT_INTERVAL*1000),npc->secure_timeout_timer,sd->bl.id,0);
+		sd->npc_idle_timer = timer->add(timer->gettick() + (SECURE_NPCTIMEOUT_INTERVAL*1000),npc->secure_timeout_timer,sd->bl.id,0);
 	return 0;
 }
 #endif
@@ -451,7 +451,7 @@ void npc_event_do_oninit(void)
 {
 	ShowStatus("Event '"CL_WHITE"OnInit"CL_RESET"' executed with '"CL_WHITE"%d"CL_RESET"' NPCs."CL_CLL"\n", npc->event_doall("OnInit"));
 
-	iTimer->add_timer_interval(iTimer->gettick()+100,npc->event_do_clock,0,0,1000);
+	timer->add_interval(timer->gettick()+100,npc->event_do_clock,0,0,1000);
 }
 
 /*==========================================
@@ -537,9 +537,9 @@ int npc_timerevent(int tid, unsigned int tick, int id, intptr_t data)
 		next = nd->u.scr.timer_event[ ted->next ].timer - nd->u.scr.timer_event[ ted->next - 1 ].timer;
 		ted->time += next;
 		if( sd )
-			sd->npc_timer_id = iTimer->add_timer(tick+next,npc->timerevent,id,(intptr_t)ted);
+			sd->npc_timer_id = timer->add(tick+next,npc->timerevent,id,(intptr_t)ted);
 		else
-			nd->u.scr.timerid = iTimer->add_timer(tick+next,npc->timerevent,id,(intptr_t)ted);
+			nd->u.scr.timerid = timer->add(tick+next,npc->timerevent,id,(intptr_t)ted);
 	}
 	else
 	{
@@ -569,7 +569,7 @@ int npc_timerevent(int tid, unsigned int tick, int id, intptr_t data)
 int npc_timerevent_start(struct npc_data* nd, int rid)
 {
 	int j;
-	unsigned int tick = iTimer->gettick();
+	unsigned int tick = timer->gettick();
 	struct map_session_data *sd = NULL; //Player to whom script is attached.
 
 	nullpo_ret(nd);
@@ -600,13 +600,13 @@ int npc_timerevent_start(struct npc_data* nd, int rid)
 		if( sd )
 		{
 			ted->rid = sd->bl.id; // Attach only the player if attachplayerrid was used.
-			sd->npc_timer_id = iTimer->add_timer(tick+next,npc->timerevent,nd->bl.id,(intptr_t)ted);
+			sd->npc_timer_id = timer->add(tick+next,npc->timerevent,nd->bl.id,(intptr_t)ted);
 		}
 		else
 		{
 			ted->rid = 0;
 			nd->u.scr.timertick = tick; // Set when timer is started
-			nd->u.scr.timerid = iTimer->add_timer(tick+next,npc->timerevent,nd->bl.id,(intptr_t)ted);
+			nd->u.scr.timerid = timer->add(tick+next,npc->timerevent,nd->bl.id,(intptr_t)ted);
 		}
 
 	} else if (!sd) {
@@ -639,16 +639,16 @@ int npc_timerevent_stop(struct npc_data* nd)
 	// Delete timer
 	if ( *tid != INVALID_TIMER )
 	{
-		td = iTimer->get_timer(*tid);
+		td = timer->get(*tid);
 		if( td && td->data )
 			ers_free(npc->timer_event_ers, (void*)td->data);
-		iTimer->delete_timer(*tid,npc->timerevent);
+		timer->delete(*tid,npc->timerevent);
 		*tid = INVALID_TIMER;
 	}
 
 	if( !sd && nd->u.scr.timertick )
 	{
-		nd->u.scr.timer += DIFF_TICK(iTimer->gettick(),nd->u.scr.timertick); // Set 'timer' to the time that has passed since the beginning of the timers
+		nd->u.scr.timer += DIFF_TICK(timer->gettick(),nd->u.scr.timertick); // Set 'timer' to the time that has passed since the beginning of the timers
 		nd->u.scr.timertick = 0; // Set 'tick' to zero so that we know it's off.
 	}
 
@@ -666,7 +666,7 @@ void npc_timerevent_quit(struct map_session_data* sd)
 	// Check timer existance
 	if( sd->npc_timer_id == INVALID_TIMER )
 		return;
-	if( !(td = iTimer->get_timer(sd->npc_timer_id)) )
+	if( !(td = timer->get(sd->npc_timer_id)) )
 	{
 		sd->npc_timer_id = INVALID_TIMER;
 		return;
@@ -675,7 +675,7 @@ void npc_timerevent_quit(struct map_session_data* sd)
 	// Delete timer
 	nd = (struct npc_data *)iMap->id2bl(td->id);
 	ted = (struct timer_event_data*)td->data;
-	iTimer->delete_timer(sd->npc_timer_id, npc->timerevent);
+	timer->delete(sd->npc_timer_id, npc->timerevent);
 	sd->npc_timer_id = INVALID_TIMER;
 
 	// Execute OnTimerQuit
@@ -702,7 +702,7 @@ void npc_timerevent_quit(struct map_session_data* sd)
 			old_timer = nd->u.scr.timer;
 
 			nd->u.scr.rid = sd->bl.id;
-			nd->u.scr.timertick = iTimer->gettick();
+			nd->u.scr.timertick = timer->gettick();
 			nd->u.scr.timer = ted->time;
 
 			//Execute label
@@ -730,7 +730,7 @@ int npc_gettimerevent_tick(struct npc_data* nd)
 
 	tick = nd->u.scr.timer; // The last time it's active(start, stop or event trigger)
 	if( nd->u.scr.timertick ) // It's a running timer
-		tick += DIFF_TICK(iTimer->gettick(), nd->u.scr.timertick);
+		tick += DIFF_TICK(timer->gettick(), nd->u.scr.timertick);
 
 	return tick;
 }
@@ -1212,13 +1212,13 @@ int npc_scriptcont(struct map_session_data* sd, int id, bool closing)
 	/**
 	 * Update the last NPC iteration
 	 **/
-	sd->npc_idle_tick = iTimer->gettick();
+	sd->npc_idle_tick = timer->gettick();
 #endif
 
 	/**
 	 * WPE can get to this point with a progressbar; we deny it.
 	 **/
-	if( sd->progressbar.npc_id && DIFF_TICK(sd->progressbar.timeout,iTimer->gettick()) > 0 )
+	if( sd->progressbar.npc_id && DIFF_TICK(sd->progressbar.timeout,timer->gettick()) > 0 )
 		return 1;
 
 	if( closing && sd->st->state == CLOSE )
@@ -1824,14 +1824,14 @@ int npc_unload(struct npc_data* nd, bool single) {
 		for( bl = (struct block_list*)mapit->first(iter); mapit->exists(iter); bl = (struct block_list*)mapit->next(iter) ) {
 			struct map_session_data *sd = ((TBL_PC*)bl);
 			if( sd && sd->npc_timer_id != INVALID_TIMER ) {
-				const struct TimerData *td = iTimer->get_timer(sd->npc_timer_id);
+				const struct TimerData *td = timer->get(sd->npc_timer_id);
 
 				if( td && td->id != nd->bl.id )
 					continue;
 
 				if( td && td->data )
 					ers_free(npc->timer_event_ers, (void*)td->data);
-				iTimer->delete_timer(sd->npc_timer_id, npc->timerevent);
+				timer->delete(sd->npc_timer_id, npc->timerevent);
 				sd->npc_timer_id = INVALID_TIMER;
 			}
 		}
@@ -1839,10 +1839,10 @@ int npc_unload(struct npc_data* nd, bool single) {
 
 		if (nd->u.scr.timerid != INVALID_TIMER) {
 			const struct TimerData *td;
-			td = iTimer->get_timer(nd->u.scr.timerid);
+			td = timer->get(nd->u.scr.timerid);
 			if (td && td->data)
 				ers_free(npc->timer_event_ers, (void*)td->data);
-			iTimer->delete_timer(nd->u.scr.timerid, npc->timerevent);
+			timer->delete(nd->u.scr.timerid, npc->timerevent);
 		}
 		if (nd->u.scr.timer_event)
 			aFree(nd->u.scr.timer_event);
@@ -2768,7 +2768,7 @@ void npc_movenpc(struct npc_data* nd, int16 x, int16 y)
 	y = cap_value(y, 0, map[m].ys-1);
 
 	iMap->foreachinrange(clif->outsight, &nd->bl, AREA_SIZE, BL_PC, &nd->bl);
-	iMap->moveblock(&nd->bl, x, y, iTimer->gettick());
+	iMap->moveblock(&nd->bl, x, y, timer->gettick());
 	iMap->foreachinrange(clif->insight, &nd->bl, AREA_SIZE, BL_PC, &nd->bl);
 }
 
@@ -3785,7 +3785,7 @@ int npc_reload(void) {
 				}
 				if( map[m].mob_delete_timer != INVALID_TIMER )
 				{ // Mobs were removed anyway,so delete the timer [Inkfish]
-					iTimer->delete_timer(map[m].mob_delete_timer, iMap->removemobs_timer);
+					timer->delete(map[m].mob_delete_timer, iMap->removemobs_timer);
 					map[m].mob_delete_timer = INVALID_TIMER;
 				}
 			}
@@ -3937,7 +3937,7 @@ int do_init_npc(void)
 	npc->base_ud.attacktimer    = INVALID_TIMER;
 	npc->base_ud.attackabletime =
 	npc->base_ud.canact_tick    =
-	npc->base_ud.canmove_tick   = iTimer->gettick();
+	npc->base_ud.canmove_tick   = timer->gettick();
 	
 	//Stock view data for normal npcs.
 	memset(&npc_viewdb, 0, sizeof(npc_viewdb));
@@ -3988,8 +3988,8 @@ int do_init_npc(void)
 	if (battle_config.warp_point_debug)
 		npc->debug_warps();
 
-	iTimer->add_timer_func_list(npc->event_do_clock,"npc_event_do_clock");
-	iTimer->add_timer_func_list(npc->timerevent,"npc_timerevent");
+	timer->add_func_list(npc->event_do_clock,"npc_event_do_clock");
+	timer->add_func_list(npc->timerevent,"npc_timerevent");
 
 	// Init dummy NPC
 	npc->fake_nd = (struct npc_data *)aCalloc(1,sizeof(struct npc_data));
diff --git a/src/map/party.c b/src/map/party.c
index 629bf9227..88d6cc0bf 100644
--- a/src/map/party.c
+++ b/src/map/party.c
@@ -123,8 +123,8 @@ void do_init_party(void)
 {
 	party_db = idb_alloc(DB_OPT_RELEASE_DATA);
 	party_booking_db = idb_alloc(DB_OPT_RELEASE_DATA); // Party Booking [Spiria]
-	iTimer->add_timer_func_list(party_send_xy_timer, "party_send_xy_timer");
-	iTimer->add_timer_interval(iTimer->gettick()+battle_config.party_update_interval, party_send_xy_timer, 0, 0, battle_config.party_update_interval);
+	timer->add_func_list(party_send_xy_timer, "party_send_xy_timer");
+	timer->add_interval(timer->gettick()+battle_config.party_update_interval, party_send_xy_timer, 0, 0, battle_config.party_update_interval);
 }
 
 /// Party data lookup using party id.
diff --git a/src/map/pc.c b/src/map/pc.c
index b8380a840..949a66d8c 100644
--- a/src/map/pc.c
+++ b/src/map/pc.c
@@ -179,8 +179,8 @@ void pc_setinvincibletimer(struct map_session_data* sd, int val) {
 	val += map[sd->bl.m].invincible_time_inc;
 	
 	if( sd->invincible_timer != INVALID_TIMER )
-		iTimer->delete_timer(sd->invincible_timer,pc_invincible_timer);
-	sd->invincible_timer = iTimer->add_timer(iTimer->gettick()+val,pc_invincible_timer,sd->bl.id,0);
+		timer->delete(sd->invincible_timer,pc_invincible_timer);
+	sd->invincible_timer = timer->add(timer->gettick()+val,pc_invincible_timer,sd->bl.id,0);
 }
 
 void pc_delinvincibletimer(struct map_session_data* sd)
@@ -189,9 +189,9 @@ void pc_delinvincibletimer(struct map_session_data* sd)
 
 	if( sd->invincible_timer != INVALID_TIMER )
 	{
-		iTimer->delete_timer(sd->invincible_timer,pc_invincible_timer);
+		timer->delete(sd->invincible_timer,pc_invincible_timer);
 		sd->invincible_timer = INVALID_TIMER;
-		skill->unit_move(&sd->bl,iTimer->gettick(),1);
+		skill->unit_move(&sd->bl,timer->gettick(),1);
 	}
 }
 
@@ -240,15 +240,15 @@ int pc_addspiritball(struct map_session_data *sd,int interval,int max)
 
 	if( sd->spiritball && sd->spiritball >= max ) {
 		if(sd->spirit_timer[0] != INVALID_TIMER)
-			iTimer->delete_timer(sd->spirit_timer[0],pc_spiritball_timer);
+			timer->delete(sd->spirit_timer[0],pc_spiritball_timer);
 		sd->spiritball--;
 		if( sd->spiritball != 0 )
 			memmove(sd->spirit_timer+0, sd->spirit_timer+1, (sd->spiritball)*sizeof(int));
 		sd->spirit_timer[sd->spiritball] = INVALID_TIMER;
 	}
 
-	tid = iTimer->add_timer(iTimer->gettick()+interval, pc_spiritball_timer, sd->bl.id, 0);
-	ARR_FIND(0, sd->spiritball, i, sd->spirit_timer[i] == INVALID_TIMER || DIFF_TICK(iTimer->get_timer(tid)->tick, iTimer->get_timer(sd->spirit_timer[i])->tick) < 0);
+	tid = timer->add(timer->gettick()+interval, pc_spiritball_timer, sd->bl.id, 0);
+	ARR_FIND(0, sd->spiritball, i, sd->spirit_timer[i] == INVALID_TIMER || DIFF_TICK(timer->get(tid)->tick, timer->get(sd->spirit_timer[i])->tick) < 0);
 	if( i != sd->spiritball )
 		memmove(sd->spirit_timer+i+1, sd->spirit_timer+i, (sd->spiritball-i)*sizeof(int));
 	sd->spirit_timer[i] = tid;
@@ -282,7 +282,7 @@ int pc_delspiritball(struct map_session_data *sd,int count,int type)
 
 	for(i=0;i<count;i++) {
 		if(sd->spirit_timer[i] != INVALID_TIMER) {
-			iTimer->delete_timer(sd->spirit_timer[i],pc_spiritball_timer);
+			timer->delete(sd->spirit_timer[i],pc_spiritball_timer);
 			sd->spirit_timer[i] = INVALID_TIMER;
 		}
 	}
@@ -488,7 +488,7 @@ int pc_inventory_rental_clear(struct map_session_data *sd)
 {
 	if( sd->rental_timer != INVALID_TIMER )
 	{
-		iTimer->delete_timer(sd->rental_timer, pc_inventory_rental_end);
+		timer->delete(sd->rental_timer, pc_inventory_rental_end);
 		sd->rental_timer = INVALID_TIMER;
 	}
 
@@ -523,7 +523,7 @@ void pc_inventory_rentals(struct map_session_data *sd)
 	}
 
 	if( c > 0 ) // min(next_tick,3600000) 1 hour each timer to keep announcing to the owner, and to avoid a but with rental time > 15 days
-		sd->rental_timer = iTimer->add_timer(iTimer->gettick() + min(next_tick,3600000), pc_inventory_rental_end, sd->bl.id, 0);
+		sd->rental_timer = timer->add(timer->gettick() + min(next_tick,3600000), pc_inventory_rental_end, sd->bl.id, 0);
 	else
 		sd->rental_timer = INVALID_TIMER;
 }
@@ -538,15 +538,15 @@ void pc_inventory_rental_add(struct map_session_data *sd, int seconds)
 	if( sd->rental_timer != INVALID_TIMER )
 	{
 		const struct TimerData * td;
-		td = iTimer->get_timer(sd->rental_timer);
-		if( DIFF_TICK(td->tick, iTimer->gettick()) > tick )
+		td = timer->get(sd->rental_timer);
+		if( DIFF_TICK(td->tick, timer->gettick()) > tick )
 		{ // Update Timer as this one ends first than the current one
 			pc->inventory_rental_clear(sd);
-			sd->rental_timer = iTimer->add_timer(iTimer->gettick() + tick, pc_inventory_rental_end, sd->bl.id, 0);
+			sd->rental_timer = timer->add(timer->gettick() + tick, pc_inventory_rental_end, sd->bl.id, 0);
 		}
 	}
 	else
-		sd->rental_timer = iTimer->add_timer(iTimer->gettick() + min(tick,3600000), pc_inventory_rental_end, sd->bl.id, 0);
+		sd->rental_timer = timer->add(timer->gettick() + min(tick,3600000), pc_inventory_rental_end, sd->bl.id, 0);
 }
 
 /**
@@ -637,7 +637,7 @@ int pc_setnewpc(struct map_session_data *sd, int account_id, int char_id, int lo
 	sd->client_tick  = client_tick;
 	sd->state.active = 0; //to be set to 1 after player is fully authed and loaded.
 	sd->bl.type      = BL_PC;
-	sd->canlog_tick  = iTimer->gettick();
+	sd->canlog_tick  = timer->gettick();
 	//Required to prevent homunculus copuing a base speed of 0.
 	sd->battle_status.speed = sd->base_status.speed = DEFAULT_WALK_SPEED;
 	return 0;
@@ -978,7 +978,7 @@ int pc_isequip(struct map_session_data *sd,int n)
  *------------------------------------------*/
 bool pc_authok(struct map_session_data *sd, int login_id2, time_t expiration_time, int group_id, struct mmo_charstatus *st, bool changing_mapservers) {
 	int i;
-	unsigned long tick = iTimer->gettick();
+	unsigned long tick = timer->gettick();
 	uint32 ip = session[sd->fd]->client_addr;
 
 	sd->login_id2 = login_id2;
@@ -1327,7 +1327,7 @@ int pc_reg_received(struct map_session_data *sd)
 		map[sd->bl.m].users_pvp--;
 		
 		if( map[sd->bl.m].flag.pvp && !map[sd->bl.m].flag.pvp_nocalcrank && sd->pvp_timer != INVALID_TIMER ) {// unregister the player for ranking
-			iTimer->delete_timer( sd->pvp_timer, pc->calc_pvprank_timer );
+			timer->delete( sd->pvp_timer, pc->calc_pvprank_timer );
 			sd->pvp_timer = INVALID_TIMER;
 		}
 		clif->changeoption(&sd->bl);
@@ -1991,7 +1991,7 @@ int pc_delautobonus(struct map_session_data* sd, struct s_autobonus *autobonus,c
 			}
 			else
 			{ // Logout / Unequipped an item with an activated bonus
-				iTimer->delete_timer(autobonus[i].active,pc->endautobonus);
+				timer->delete(autobonus[i].active,pc->endautobonus);
 				autobonus[i].active = INVALID_TIMER;
 			}
 		}
@@ -2019,7 +2019,7 @@ int pc_exeautobonus(struct map_session_data *sd,struct s_autobonus *autobonus)
 			script->run_autobonus(autobonus->other_script,sd->bl.id,sd->equip_index[j]);
 	}
 
-	autobonus->active = iTimer->add_timer(iTimer->gettick()+autobonus->duration, pc->endautobonus, sd->bl.id, (intptr_t)autobonus);
+	autobonus->active = timer->add(timer->gettick()+autobonus->duration, pc->endautobonus, sd->bl.id, (intptr_t)autobonus);
 	sd->state.autobonus |= autobonus->pos;
 	status_calc_pc(sd,0);
 
@@ -4090,7 +4090,7 @@ int pc_dropitem(struct map_session_data *sd,int n,int amount)
 int pc_takeitem(struct map_session_data *sd,struct flooritem_data *fitem)
 {
 	int flag=0;
-	unsigned int tick = iTimer->gettick();
+	unsigned int tick = timer->gettick();
 	struct map_session_data *first_sd = NULL,*second_sd = NULL,*third_sd = NULL;
 	struct party_data *p=NULL;
 
@@ -4344,7 +4344,7 @@ int pc_isUseitem(struct map_session_data *sd,int n)
  *	1 = success
  *------------------------------------------*/
 int pc_useitem(struct map_session_data *sd,int n) {
-	unsigned int tick = iTimer->gettick();
+	unsigned int tick = timer->gettick();
 	int amount, nameid, i;
 	struct script_code *item_script;
 
@@ -4892,8 +4892,8 @@ int pc_setpos(struct map_session_data* sd, unsigned short mapindex, int x, int y
 			if (sd->sc.data[SC_KNOWLEDGE]) {
 				struct status_change_entry *sce = sd->sc.data[SC_KNOWLEDGE];
 				if (sce->timer != INVALID_TIMER)
-					iTimer->delete_timer(sce->timer, iStatus->change_timer);
-				sce->timer = iTimer->add_timer(iTimer->gettick() + skill->get_time(SG_KNOWLEDGE, sce->val1), iStatus->change_timer, sd->bl.id, SC_KNOWLEDGE);
+					timer->delete(sce->timer, iStatus->change_timer);
+				sce->timer = timer->add(timer->gettick() + skill->get_time(SG_KNOWLEDGE, sce->val1), iStatus->change_timer, sd->bl.id, SC_KNOWLEDGE);
 			}
 			status_change_end(&sd->bl, SC_PROPERTYWALK, INVALID_TIMER);
 			status_change_end(&sd->bl, SC_CLOAKING, INVALID_TIMER);
@@ -5736,7 +5736,7 @@ int pc_follow_timer(int tid, unsigned int tick, int id, intptr_t data)
 		} else
 			pc->setpos(sd, map_id2index(tbl->m), tbl->x, tbl->y, CLR_TELEPORT);
 	}
-	sd->followtimer = iTimer->add_timer(
+	sd->followtimer = timer->add(
 		tick + 1000,	// increase time a bit to loosen up map's load
 		pc_follow_timer, sd->bl.id, 0);
 	return 0;
@@ -5747,7 +5747,7 @@ int pc_stop_following (struct map_session_data *sd)
 	nullpo_ret(sd);
 
 	if (sd->followtimer != INVALID_TIMER) {
-		iTimer->delete_timer(sd->followtimer,pc_follow_timer);
+		timer->delete(sd->followtimer,pc_follow_timer);
 		sd->followtimer = INVALID_TIMER;
 	}
 	sd->followtarget = -1;
@@ -5767,7 +5767,7 @@ int pc_follow(struct map_session_data *sd,int target_id)
 		pc->stop_following(sd);
 
 	sd->followtarget = target_id;
-	pc_follow_timer(INVALID_TIMER, iTimer->gettick(), sd->bl.id, 0);
+	pc_follow_timer(INVALID_TIMER, timer->gettick(), sd->bl.id, 0);
 
 	return 0;
 }
@@ -6705,7 +6705,7 @@ void pc_damage(struct map_session_data *sd,struct block_list *src,unsigned int h
 	if( sd->status.ele_id > 0 )
 		elemental->set_target(sd,src);
 
-	sd->canlog_tick = iTimer->gettick();
+	sd->canlog_tick = timer->gettick();
 }
 
 /*==========================================
@@ -6713,7 +6713,7 @@ void pc_damage(struct map_session_data *sd,struct block_list *src,unsigned int h
  *------------------------------------------*/
 int pc_dead(struct map_session_data *sd,struct block_list *src) {
 	int i=0,j=0,k=0;
-	unsigned int tick = iTimer->gettick();
+	unsigned int tick = timer->gettick();
 
 	for(k = 0; k < 5; k++)
 		if (sd->devotion[k]){
@@ -6910,7 +6910,7 @@ int pc_dead(struct map_session_data *sd,struct block_list *src) {
 				pc->setinvincibletimer(sd, battle_config.pc_invincible_time);
 			sc_start(&sd->bl,iStatus->skill2sc(MO_STEELBODY),100,1,skill->get_time(MO_STEELBODY,1));
 			if(map_flag_gvg2(sd->bl.m))
-				pc_respawn_timer(INVALID_TIMER, iTimer->gettick(), sd->bl.id, 0);
+				pc_respawn_timer(INVALID_TIMER, timer->gettick(), sd->bl.id, 0);
 			return 0;
 		}
 	}
@@ -7027,18 +7027,18 @@ int pc_dead(struct map_session_data *sd,struct block_list *src) {
 		}
 		if( sd->pvp_point < 0 )
 		{
-			iTimer->add_timer(tick+1, pc_respawn_timer,sd->bl.id,0);
+			timer->add(tick+1, pc_respawn_timer,sd->bl.id,0);
 			return 1|8;
 		}
 	}
 	//GvG
 	if( map_flag_gvg2(sd->bl.m) ) {
-		iTimer->add_timer(tick+1, pc_respawn_timer, sd->bl.id, 0);
+		timer->add(tick+1, pc_respawn_timer, sd->bl.id, 0);
 		return 1|8;
 	} else if( sd->bg_id ) {
 		struct battleground_data *bgd = bg->team_search(sd->bg_id);
 		if( bgd && bgd->mapindex > 0 ) { // Respawn by BG
-			iTimer->add_timer(tick+1000, pc_respawn_timer, sd->bl.id, 0);
+			timer->add(tick+1000, pc_respawn_timer, sd->bl.id, 0);
 			return 1|8;
 		}
 	}
@@ -7046,7 +7046,7 @@ int pc_dead(struct map_session_data *sd,struct block_list *src) {
 
 	//Reset "can log out" tick.
 	if( battle_config.prevent_logout )
-		sd->canlog_tick = iTimer->gettick() - battle_config.prevent_logout;
+		sd->canlog_tick = timer->gettick() - battle_config.prevent_logout;
 	return 1;
 }
 
@@ -8352,7 +8352,7 @@ int pc_addeventtimer(struct map_session_data *sd,int tick,const char *name)
 	if( i == MAX_EVENTTIMER )
 		return 0;
 
-	sd->eventtimer[i] = iTimer->add_timer(iTimer->gettick()+tick, pc_eventtimer, sd->bl.id, (intptr_t)aStrdup(name));
+	sd->eventtimer[i] = timer->add(timer->gettick()+tick, pc_eventtimer, sd->bl.id, (intptr_t)aStrdup(name));
 	sd->eventcount++;
 
 	return 1;
@@ -8374,13 +8374,13 @@ int pc_deleventtimer(struct map_session_data *sd,const char *name)
 	// find the named event timer
 	ARR_FIND( 0, MAX_EVENTTIMER, i,
 		sd->eventtimer[i] != INVALID_TIMER &&
-		(p = (char *)(iTimer->get_timer(sd->eventtimer[i])->data)) != NULL &&
+		(p = (char *)(timer->get(sd->eventtimer[i])->data)) != NULL &&
 		strcmp(p, name) == 0
 	);
 	if( i == MAX_EVENTTIMER )
 		return 0; // not found
 
-	iTimer->delete_timer(sd->eventtimer[i],pc_eventtimer);
+	timer->delete(sd->eventtimer[i],pc_eventtimer);
 	sd->eventtimer[i] = INVALID_TIMER;
 	sd->eventcount--;
 	aFree(p);
@@ -8399,8 +8399,8 @@ int pc_addeventtimercount(struct map_session_data *sd,const char *name,int tick)
 
 	for(i=0;i<MAX_EVENTTIMER;i++)
 		if( sd->eventtimer[i] != INVALID_TIMER && strcmp(
-			(char *)(iTimer->get_timer(sd->eventtimer[i])->data), name)==0 ){
-				iTimer->addtick_timer(sd->eventtimer[i],tick);
+			(char *)(timer->get(sd->eventtimer[i])->data), name)==0 ){
+				timer->addtick(sd->eventtimer[i],tick);
 				break;
 		}
 
@@ -8421,8 +8421,8 @@ int pc_cleareventtimer(struct map_session_data *sd)
 
 	for(i=0;i<MAX_EVENTTIMER;i++)
 		if( sd->eventtimer[i] != INVALID_TIMER ){
-			char *p = (char *)(iTimer->get_timer(sd->eventtimer[i])->data);
-			iTimer->delete_timer(sd->eventtimer[i],pc_eventtimer);
+			char *p = (char *)(timer->get(sd->eventtimer[i])->data);
+			timer->delete(sd->eventtimer[i],pc_eventtimer);
 			sd->eventtimer[i] = INVALID_TIMER;
 			sd->eventcount--;
 			if (p) aFree(p);
@@ -8599,7 +8599,7 @@ int pc_equipitem(struct map_session_data *sd,int n,int req_pos)
 		return 0;
 	}
 
-	if( DIFF_TICK(sd->canequip_tick,iTimer->gettick()) > 0 )
+	if( DIFF_TICK(sd->canequip_tick,timer->gettick()) > 0 )
 	{
 		clif->equipitemack(sd,n,0,0);
 		return 0;
@@ -9096,7 +9096,7 @@ int pc_calc_pvprank_timer(int tid, unsigned int tick, int id, intptr_t data)
 	}
 
 	if( pc->calc_pvprank(sd) > 0 )
-		sd->pvp_timer = iTimer->add_timer(iTimer->gettick()+PVP_CALCRANK_INTERVAL,pc->calc_pvprank_timer,id,data);
+		sd->pvp_timer = timer->add(timer->gettick()+PVP_CALCRANK_INTERVAL,pc->calc_pvprank_timer,id,data);
 	return 0;
 }
 
@@ -9337,7 +9337,7 @@ int pc_autosave(int tid, unsigned int tick, int id, intptr_t data)
 	interval = iMap->autosave_interval/(iMap->usercount()+1);
 	if(interval < iMap->minsave_interval)
 		interval = iMap->minsave_interval;
-	iTimer->add_timer(iTimer->gettick()+interval,pc_autosave,0,0);
+	timer->add(timer->gettick()+interval,pc_autosave,0,0);
 
 	return 0;
 }
@@ -9497,15 +9497,15 @@ int pc_add_charm(struct map_session_data *sd,int interval,int max,int type)
 	if( sd->charm[type] && sd->charm[type] >= max )
 	{
 		if(sd->charm_timer[type][0] != INVALID_TIMER)
-			iTimer->delete_timer(sd->charm_timer[type][0],pc_charm_timer);
+			timer->delete(sd->charm_timer[type][0],pc_charm_timer);
 		sd->charm[type]--;
 		if( sd->charm[type] != 0 )
 			memmove(sd->charm_timer[type]+0, sd->charm_timer[type]+1, (sd->charm[type])*sizeof(int));
 		sd->charm_timer[type][sd->charm[type]] = INVALID_TIMER;
 	}
 
-	tid = iTimer->add_timer(iTimer->gettick()+interval, pc_charm_timer, sd->bl.id, 0);
-	ARR_FIND(0, sd->charm[type], i, sd->charm_timer[type][i] == INVALID_TIMER || DIFF_TICK(iTimer->get_timer(tid)->tick, iTimer->get_timer(sd->charm_timer[type][i])->tick) < 0);
+	tid = timer->add(timer->gettick()+interval, pc_charm_timer, sd->bl.id, 0);
+	ARR_FIND(0, sd->charm[type], i, sd->charm_timer[type][i] == INVALID_TIMER || DIFF_TICK(timer->get(tid)->tick, timer->get(sd->charm_timer[type][i])->tick) < 0);
 	if( i != sd->charm[type] )
 		memmove(sd->charm_timer[type]+i+1, sd->charm_timer[type]+i, (sd->charm[type]-i)*sizeof(int));
 	sd->charm_timer[type][i] = tid;
@@ -9536,7 +9536,7 @@ int pc_del_charm(struct map_session_data *sd,int count,int type)
 
 	for(i = 0; i < count; i++) {
 		if(sd->charm_timer[type][i] != INVALID_TIMER) {
-			iTimer->delete_timer(sd->charm_timer[type][i],pc_charm_timer);
+			timer->delete(sd->charm_timer[type][i],pc_charm_timer);
 			sd->charm_timer[type][i] = INVALID_TIMER;
 		}
 	}
@@ -10143,7 +10143,7 @@ void pc_itemcd_do(struct map_session_data *sd, bool load) {
 			return;
 		}
 		for(i = 0; i < MAX_ITEMDELAYS; i++) {
-			if( cd->nameid[i] && DIFF_TICK(iTimer->gettick(),cd->tick[i]) < 0 ) {
+			if( cd->nameid[i] && DIFF_TICK(timer->gettick(),cd->tick[i]) < 0 ) {
 				sd->item_delay[cursor].tick = cd->tick[i];
 				sd->item_delay[cursor].nameid = cd->nameid[i];
 				cursor++;
@@ -10157,7 +10157,7 @@ void pc_itemcd_do(struct map_session_data *sd, bool load) {
 			idb_put( itemcd_db, sd->status.char_id, cd );
 		}
 		for(i = 0; i < MAX_ITEMDELAYS; i++) {
-			if( sd->item_delay[i].nameid && DIFF_TICK(iTimer->gettick(),sd->item_delay[i].tick) < 0 ) {
+			if( sd->item_delay[i].nameid && DIFF_TICK(timer->gettick(),sd->item_delay[i].tick) < 0 ) {
 				cd->tick[cursor] = sd->item_delay[i].tick;
 				cd->nameid[cursor] = sd->item_delay[i].nameid;
 				cursor++;
@@ -10186,17 +10186,17 @@ int do_init_pc(void) {
 
 	pc->readdb();
 
-	iTimer->add_timer_func_list(pc_invincible_timer, "pc_invincible_timer");
-	iTimer->add_timer_func_list(pc_eventtimer, "pc_eventtimer");
-	iTimer->add_timer_func_list(pc_inventory_rental_end, "pc_inventory_rental_end");
-	iTimer->add_timer_func_list(pc->calc_pvprank_timer, "pc->calc_pvprank_timer");
-	iTimer->add_timer_func_list(pc_autosave, "pc_autosave");
-	iTimer->add_timer_func_list(pc_spiritball_timer, "pc_spiritball_timer");
-	iTimer->add_timer_func_list(pc_follow_timer, "pc_follow_timer");
-	iTimer->add_timer_func_list(pc->endautobonus, "pc->endautobonus");
-	iTimer->add_timer_func_list(pc_charm_timer, "pc_charm_timer");
+	timer->add_func_list(pc_invincible_timer, "pc_invincible_timer");
+	timer->add_func_list(pc_eventtimer, "pc_eventtimer");
+	timer->add_func_list(pc_inventory_rental_end, "pc_inventory_rental_end");
+	timer->add_func_list(pc->calc_pvprank_timer, "pc->calc_pvprank_timer");
+	timer->add_func_list(pc_autosave, "pc_autosave");
+	timer->add_func_list(pc_spiritball_timer, "pc_spiritball_timer");
+	timer->add_func_list(pc_follow_timer, "pc_follow_timer");
+	timer->add_func_list(pc->endautobonus, "pc->endautobonus");
+	timer->add_func_list(pc_charm_timer, "pc_charm_timer");
 
-	iTimer->add_timer(iTimer->gettick() + iMap->autosave_interval, pc_autosave, 0, 0);
+	timer->add(timer->gettick() + iMap->autosave_interval, pc_autosave, 0, 0);
 
 	// 0=day, 1=night [Yor]
 	iMap->night_flag = battle_config.night_at_start ? 1 : 0;
@@ -10205,11 +10205,11 @@ int do_init_pc(void) {
 		int day_duration = battle_config.day_duration;
 		int night_duration = battle_config.night_duration;
 		// add night/day timer [Yor]
-		iTimer->add_timer_func_list(pc->map_day_timer, "pc->map_day_timer");
-		iTimer->add_timer_func_list(pc->map_night_timer, "pc->map_night_timer");
+		timer->add_func_list(pc->map_day_timer, "pc->map_day_timer");
+		timer->add_func_list(pc->map_night_timer, "pc->map_night_timer");
 
-		pc->day_timer_tid   = iTimer->add_timer_interval(iTimer->gettick() + (iMap->night_flag ? 0 : day_duration) + night_duration, pc->map_day_timer,   0, 0, day_duration + night_duration);
-		pc->night_timer_tid = iTimer->add_timer_interval(iTimer->gettick() + day_duration + (iMap->night_flag ? night_duration : 0), pc->map_night_timer, 0, 0, day_duration + night_duration);
+		pc->day_timer_tid   = timer->add_interval(timer->gettick() + (iMap->night_flag ? 0 : day_duration) + night_duration, pc->map_day_timer,   0, 0, day_duration + night_duration);
+		pc->night_timer_tid = timer->add_interval(timer->gettick() + day_duration + (iMap->night_flag ? night_duration : 0), pc->map_night_timer, 0, 0, day_duration + night_duration);
 	}
 
 	do_init_pc_groups();
diff --git a/src/map/pet.c b/src/map/pet.c
index 8498517ef..b4714cc06 100644
--- a/src/map/pet.c
+++ b/src/map/pet.c
@@ -102,7 +102,7 @@ int pet_attackskill(struct pet_data *pd, int target_id)
 		(battle_config.pet_equip_required && !pd->pet.equip))
 		return 0;
 
-	if (DIFF_TICK(pd->ud.canact_tick, iTimer->gettick()) > 0)
+	if (DIFF_TICK(pd->ud.canact_tick, timer->gettick()) > 0)
 		return 0;
 	
 	if (rnd()%100 < (pd->a_skill->rate +pd->pet.intimate*pd->a_skill->bonusrate/1000))
@@ -183,7 +183,7 @@ int pet_sc_check(struct map_session_data *sd, int type)
 	||  pd->recovery->type != type )
 		return 1;
 
-	pd->recovery->timer = iTimer->add_timer(iTimer->gettick()+pd->recovery->delay*1000,pet->recovery_timer,sd->bl.id,0);
+	pd->recovery->timer = timer->add(timer->gettick()+pd->recovery->delay*1000,pet->recovery_timer,sd->bl.id,0);
 	
 	return 0;
 }
@@ -233,7 +233,7 @@ int pet_hungry(int tid, unsigned int tick, int id, intptr_t data)
 		interval = pd->petDB->hungry_delay;
 	if(interval <= 0)
 		interval = 1;
-	pd->pet_hungry_timer = iTimer->add_timer(tick+interval,pet->hungry,sd->bl.id,0);
+	pd->pet_hungry_timer = timer->add(tick+interval,pet->hungry,sd->bl.id,0);
 
 	return 0;
 }
@@ -263,7 +263,7 @@ int pet_hungry_timer_delete(struct pet_data *pd)
 {
 	nullpo_ret(pd);
 	if(pd->pet_hungry_timer != INVALID_TIMER) {
-		iTimer->delete_timer(pd->pet_hungry_timer,pet->hungry);
+		timer->delete(pd->pet_hungry_timer,pet->hungry);
 		pd->pet_hungry_timer = INVALID_TIMER;
 	}
 
@@ -365,7 +365,7 @@ int pet_data_init(struct map_session_data *sd, struct s_pet *petinfo)
 	iMap->addiddb(&pd->bl);
 	status_calc_pet(pd,1);
 
-	pd->last_thinktime = iTimer->gettick();
+	pd->last_thinktime = timer->gettick();
 	pd->state.skillbonus = 0;
 	if( battle_config.pet_status_support )
 		script->run(pet->db[i].pet_script,0,sd->bl.id,0);
@@ -378,7 +378,7 @@ int pet_data_init(struct map_session_data *sd, struct s_pet *petinfo)
 		interval = pd->petDB->hungry_delay;
 	if( interval <= 0 )
 		interval = 1;
-	pd->pet_hungry_timer = iTimer->add_timer(iTimer->gettick() + interval, pet->hungry, sd->bl.id, 0);
+	pd->pet_hungry_timer = timer->add(timer->gettick() + interval, pet->hungry, sd->bl.id, 0);
 	return 0;
 }
 
@@ -672,16 +672,16 @@ int pet_equipitem(struct map_session_data *sd,int index)
 	clif->send_petdata(NULL, sd->pd, 3, sd->pd->vd.head_bottom);
 	if (battle_config.pet_equip_required)
 	{ 	//Skotlex: start support timers if need
-		unsigned int tick = iTimer->gettick();
+		unsigned int tick = timer->gettick();
 		if (pd->s_skill && pd->s_skill->timer == INVALID_TIMER)
 		{
 			if (pd->s_skill->id)
-				pd->s_skill->timer=iTimer->add_timer(tick+pd->s_skill->delay*1000, pet->skill_support_timer, sd->bl.id, 0);
+				pd->s_skill->timer=timer->add(tick+pd->s_skill->delay*1000, pet->skill_support_timer, sd->bl.id, 0);
 			else
-				pd->s_skill->timer=iTimer->add_timer(tick+pd->s_skill->delay*1000, pet->heal_timer, sd->bl.id, 0);
+				pd->s_skill->timer=timer->add(tick+pd->s_skill->delay*1000, pet->heal_timer, sd->bl.id, 0);
 		}
 		if (pd->bonus && pd->bonus->timer == INVALID_TIMER)
-			pd->bonus->timer=iTimer->add_timer(tick+pd->bonus->delay*1000, pet->skill_bonus_timer, sd->bl.id, 0);
+			pd->bonus->timer=timer->add(tick+pd->bonus->delay*1000, pet->skill_bonus_timer, sd->bl.id, 0);
 	}
 
 	return 0;
@@ -716,14 +716,14 @@ int pet_unequipitem(struct map_session_data *sd, struct pet_data *pd)
 		if( pd->s_skill && pd->s_skill->timer != INVALID_TIMER )
 		{
 			if( pd->s_skill->id )
-				iTimer->delete_timer(pd->s_skill->timer, pet->skill_support_timer);
+				timer->delete(pd->s_skill->timer, pet->skill_support_timer);
 			else
-				iTimer->delete_timer(pd->s_skill->timer, pet->heal_timer);
+				timer->delete(pd->s_skill->timer, pet->heal_timer);
 			pd->s_skill->timer = INVALID_TIMER;
 		}
 		if( pd->bonus && pd->bonus->timer != INVALID_TIMER )
 		{
-			iTimer->delete_timer(pd->bonus->timer, pet->skill_bonus_timer);
+			timer->delete(pd->bonus->timer, pet->skill_bonus_timer);
 			pd->bonus->timer = INVALID_TIMER;
 		}
 	}
@@ -1032,10 +1032,10 @@ int pet_lootitem_drop(struct pet_data *pd,struct map_session_data *sd)
 	memset(pd->loot->item,0,pd->loot->max * sizeof(struct item));
 	pd->loot->count = 0;
 	pd->loot->weight = 0;
-	pd->ud.canact_tick = iTimer->gettick()+10000;	//prevent picked up during 10*1000ms
+	pd->ud.canact_tick = timer->gettick()+10000;	//prevent picked up during 10*1000ms
 
 	if (dlist->item)
-		iTimer->add_timer(iTimer->gettick()+540,pet->delay_item_drop,0,(intptr_t)dlist);
+		timer->add(timer->gettick()+540,pet->delay_item_drop,0,(intptr_t)dlist);
 	else
 		ers_free(pet->item_drop_list_ers, dlist);
 	return 1;
@@ -1049,7 +1049,7 @@ int pet_skill_bonus_timer(int tid, unsigned int tick, int id, intptr_t data)
 	struct map_session_data *sd=iMap->id2sd(id);
 	struct pet_data *pd;
 	int bonus;
-	int timer = 0;
+	int next = 0;
 
 	if(sd == NULL || sd->pd==NULL || sd->pd->bonus == NULL)
 		return 1;
@@ -1065,10 +1065,10 @@ int pet_skill_bonus_timer(int tid, unsigned int tick, int id, intptr_t data)
 	// determine the time for the next timer
 	if (pd->state.skillbonus && pd->bonus->delay > 0) {
 		bonus = 0;
-		timer = pd->bonus->delay*1000;	// the duration until pet bonuses will be reactivated again
+		next = pd->bonus->delay*1000;	// the duration until pet bonuses will be reactivated again
 	} else if (pd->pet.intimate) {
 		bonus = 1;
-		timer = pd->bonus->duration*1000;	// the duration for pet bonuses to be in effect
+		next = pd->bonus->duration*1000;	// the duration for pet bonuses to be in effect
 	} else { //Lost pet...
 		pd->bonus->timer = INVALID_TIMER;
 		return 0;
@@ -1079,7 +1079,7 @@ int pet_skill_bonus_timer(int tid, unsigned int tick, int id, intptr_t data)
 		status_calc_pc(sd, 0);
 	}
 	// wait for the next timer
-	pd->bonus->timer=iTimer->add_timer(tick+timer,pet->skill_bonus_timer,sd->bl.id,0);
+	pd->bonus->timer=timer->add(tick+next,pet->skill_bonus_timer,sd->bl.id,0);
 	return 0;
 }
 
@@ -1138,14 +1138,14 @@ int pet_heal_timer(int tid, unsigned int tick, int id, intptr_t data)
 		(rate = get_percentage(status->hp, status->max_hp)) > pd->s_skill->hp ||
 		(rate = (pd->ud.skilltimer != INVALID_TIMER)) //Another skill is in effect
 	) {  //Wait (how long? 1 sec for every 10% of remaining)
-		pd->s_skill->timer=iTimer->add_timer(iTimer->gettick()+(rate>10?rate:10)*100,pet->heal_timer,sd->bl.id,0);
+		pd->s_skill->timer=timer->add(timer->gettick()+(rate>10?rate:10)*100,pet->heal_timer,sd->bl.id,0);
 		return 0;
 	}
 	pet_stop_attack(pd);
 	pet_stop_walking(pd,1);
 	clif->skill_nodamage(&pd->bl,&sd->bl,AL_HEAL,pd->s_skill->lv,1);
 	iStatus->heal(&sd->bl, pd->s_skill->lv,0, 0);
-	pd->s_skill->timer=iTimer->add_timer(tick+pd->s_skill->delay*1000,pet->heal_timer,sd->bl.id,0);
+	pd->s_skill->timer=timer->add(tick+pd->s_skill->delay*1000,pet->heal_timer,sd->bl.id,0);
 	return 0;
 }
 
@@ -1172,7 +1172,7 @@ int pet_skill_support_timer(int tid, unsigned int tick, int id, intptr_t data)
 
 	if (DIFF_TICK(pd->ud.canact_tick, tick) > 0)
 	{	//Wait until the pet can act again.
-		pd->s_skill->timer=iTimer->add_timer(pd->ud.canact_tick,pet->skill_support_timer,sd->bl.id,0);
+		pd->s_skill->timer=timer->add(pd->ud.canact_tick,pet->skill_support_timer,sd->bl.id,0);
 		return 0;
 	}
 	
@@ -1181,13 +1181,13 @@ int pet_skill_support_timer(int tid, unsigned int tick, int id, intptr_t data)
 		(rate = get_percentage(status->hp, status->max_hp)) > pd->s_skill->hp ||
 		(rate = (pd->ud.skilltimer != INVALID_TIMER)) //Another skill is in effect
 	) {  //Wait (how long? 1 sec for every 10% of remaining)
-		pd->s_skill->timer=iTimer->add_timer(tick+(rate>10?rate:10)*100,pet->skill_support_timer,sd->bl.id,0);
+		pd->s_skill->timer=timer->add(tick+(rate>10?rate:10)*100,pet->skill_support_timer,sd->bl.id,0);
 		return 0;
 	}
 	
 	pet_stop_attack(pd);
 	pet_stop_walking(pd,1);
-	pd->s_skill->timer=iTimer->add_timer(tick+pd->s_skill->delay*1000,pet->skill_support_timer,sd->bl.id,0);
+	pd->s_skill->timer=timer->add(tick+pd->s_skill->delay*1000,pet->skill_support_timer,sd->bl.id,0);
 	if (skill->get_inf(pd->s_skill->id) & INF_GROUND_SKILL)
 		unit->skilluse_pos(&pd->bl, sd->bl.x, sd->bl.y, pd->s_skill->id, pd->s_skill->lv);
 	else
@@ -1355,14 +1355,14 @@ int do_init_pet(void)
 	pet->item_drop_ers = ers_new(sizeof(struct item_drop),"pet.c::item_drop_ers",ERS_OPT_NONE);
 	pet->item_drop_list_ers = ers_new(sizeof(struct item_drop_list),"pet.c::item_drop_list_ers",ERS_OPT_NONE);
 	
-	iTimer->add_timer_func_list(pet->hungry,"pet_hungry");
-	iTimer->add_timer_func_list(pet->ai_hard,"pet_ai_hard");
-	iTimer->add_timer_func_list(pet->skill_bonus_timer,"pet_skill_bonus_timer"); // [Valaris]
-	iTimer->add_timer_func_list(pet->delay_item_drop,"pet_delay_item_drop");
-	iTimer->add_timer_func_list(pet->skill_support_timer, "pet_skill_support_timer"); // [Skotlex]
-	iTimer->add_timer_func_list(pet->recovery_timer,"pet_recovery_timer"); // [Valaris]
-	iTimer->add_timer_func_list(pet->heal_timer,"pet_heal_timer"); // [Valaris]
-	iTimer->add_timer_interval(iTimer->gettick()+MIN_PETTHINKTIME,pet->ai_hard,0,0,MIN_PETTHINKTIME);
+	timer->add_func_list(pet->hungry,"pet_hungry");
+	timer->add_func_list(pet->ai_hard,"pet_ai_hard");
+	timer->add_func_list(pet->skill_bonus_timer,"pet_skill_bonus_timer"); // [Valaris]
+	timer->add_func_list(pet->delay_item_drop,"pet_delay_item_drop");
+	timer->add_func_list(pet->skill_support_timer, "pet_skill_support_timer"); // [Skotlex]
+	timer->add_func_list(pet->recovery_timer,"pet_recovery_timer"); // [Valaris]
+	timer->add_func_list(pet->heal_timer,"pet_heal_timer"); // [Valaris]
+	timer->add_interval(timer->gettick()+MIN_PETTHINKTIME,pet->ai_hard,0,0,MIN_PETTHINKTIME);
 
 	return 0;
 }
diff --git a/src/map/script.c b/src/map/script.c
index 7ac638848..bba74e669 100644
--- a/src/map/script.c
+++ b/src/map/script.c
@@ -2822,7 +2822,7 @@ void script_free_state(struct script_state* st) {
 		}
 
 		if( st->sleep.timer != INVALID_TIMER )
-			iTimer->delete_timer(st->sleep.timer, script->run_timer);
+			timer->delete(st->sleep.timer, script->run_timer);
 		if( st->stack ) {
 			script->free_vars(st->stack->var_function);
 			script->pop_stack(st, 0, st->stack->sp);
@@ -3381,7 +3381,7 @@ static void script_detach_state(struct script_state* st, bool dequeue_event)
 			 * We're done with this NPC session, so we cancel the timer (if existent) and move on
 			 **/
 			if( sd->npc_idle_timer != INVALID_TIMER ) {
-				iTimer->delete_timer(sd->npc_idle_timer,npc->secure_timeout_timer);
+				timer->delete(sd->npc_idle_timer,npc->secure_timeout_timer);
 				sd->npc_idle_timer = INVALID_TIMER;
 			}
 #endif
@@ -3421,8 +3421,8 @@ void script_attach_state(struct script_state* st) {
  **/
 #ifdef SECURE_NPCTIMEOUT
 		if( sd->npc_idle_timer == INVALID_TIMER )
-			sd->npc_idle_timer = iTimer->add_timer(iTimer->gettick() + (SECURE_NPCTIMEOUT_INTERVAL*1000),npc->secure_timeout_timer,sd->bl.id,0);
-		sd->npc_idle_tick = iTimer->gettick();
+			sd->npc_idle_timer = timer->add(timer->gettick() + (SECURE_NPCTIMEOUT_INTERVAL*1000),npc->secure_timeout_timer,sd->bl.id,0);
+		sd->npc_idle_tick = timer->gettick();
 #endif
 	}
 }
@@ -3546,7 +3546,7 @@ void run_script_main(struct script_state *st)
 		//Delay execution
 		sd = iMap->id2sd(st->rid); // Get sd since script might have attached someone while running. [Inkfish]
 		st->sleep.charid = sd?sd->status.char_id:0;
-		st->sleep.timer  = iTimer->add_timer(iTimer->gettick()+st->sleep.tick,
+		st->sleep.timer  = timer->add(timer->gettick()+st->sleep.tick,
 			script->run_timer, st->sleep.charid, (intptr_t)st->id);
 	} else if(st->state != END && st->rid){
 		//Resume later (st is already attached to player).
@@ -8154,7 +8154,7 @@ BUILDIN(savepoint)
 BUILDIN(gettimetick)	/* Asgard Version */
 {
 	int type;
-	time_t timer;
+	time_t tt;
 	struct tm *t;
 	
 	type=script_getnum(st,2);
@@ -8167,14 +8167,14 @@ BUILDIN(gettimetick)	/* Asgard Version */
 			break;
 		case 1:
 			//type 1:(Second Ticks: 0-86399, 00:00:00-23:59:59)
-			time(&timer);
-			t=localtime(&timer);
+			time(&tt);
+			t=localtime(&tt);
 			script_pushint(st,((t->tm_hour)*3600+(t->tm_min)*60+t->tm_sec));
 			break;
 		case 0:
 		default:
 			//type 0:(System Ticks)
-			script_pushint(st,iTimer->gettick());
+			script_pushint(st,timer->gettick());
 			break;
 	}
 	return true;
@@ -9724,11 +9724,11 @@ BUILDIN(getstatus)
 		case 4:  script_pushint(st, sd->sc.data[id]->val4);	break;
 		case 5:
 		{
-			struct TimerData* timer = (struct TimerData*)iTimer->get_timer(sd->sc.data[id]->timer);
+			struct TimerData* td = (struct TimerData*)timer->get(sd->sc.data[id]->timer);
 			
-			if( timer )
+			if( td )
 			{// return the amount of time remaining
-				script_pushint(st, timer->tick - iTimer->gettick());
+				script_pushint(st, td->tick - timer->gettick());
 			}
 		}
 			break;
@@ -10402,7 +10402,7 @@ BUILDIN(getmapflag)
 static int script_mapflag_pvp_sub(struct block_list *bl,va_list ap) {
 	TBL_PC* sd = (TBL_PC*)bl;
 	if (sd->pvp_timer == INVALID_TIMER) {
-		sd->pvp_timer = iTimer->add_timer(iTimer->gettick() + 200, pc->calc_pvprank_timer, sd->bl.id, 0);
+		sd->pvp_timer = timer->add(timer->gettick() + 200, pc->calc_pvprank_timer, sd->bl.id, 0);
 		sd->pvp_rank = 0;
 		sd->pvp_lastusers = 0;
 		sd->pvp_point = 5;
@@ -10632,7 +10632,7 @@ BUILDIN(pvpon)
 		if( sd->bl.m != m || sd->pvp_timer != INVALID_TIMER )
 			continue; // not applicable
 		
-		sd->pvp_timer = iTimer->add_timer(iTimer->gettick()+200,pc->calc_pvprank_timer,sd->bl.id,0);
+		sd->pvp_timer = timer->add(timer->gettick()+200,pc->calc_pvprank_timer,sd->bl.id,0);
 		sd->pvp_rank = 0;
 		sd->pvp_lastusers = 0;
 		sd->pvp_point = 5;
@@ -10649,7 +10649,7 @@ static int buildin_pvpoff_sub(struct block_list *bl,va_list ap)
 	TBL_PC* sd = (TBL_PC*)bl;
 	clif->pvpset(sd, 0, 0, 2);
 	if (sd->pvp_timer != INVALID_TIMER) {
-		iTimer->delete_timer(sd->pvp_timer, pc->calc_pvprank_timer);
+		timer->delete(sd->pvp_timer, pc->calc_pvprank_timer);
 		sd->pvp_timer = INVALID_TIMER;
 	}
 	return 0;
@@ -11695,7 +11695,7 @@ BUILDIN(petskillbonus)
 	if (pd->bonus)
 	{ //Clear previous bonus
 		if (pd->bonus->timer != INVALID_TIMER)
-			iTimer->delete_timer(pd->bonus->timer, pet->skill_bonus_timer);
+			timer->delete(pd->bonus->timer, pet->skill_bonus_timer);
 	} else //init
 		pd->bonus = (struct pet_bonus *) aMalloc(sizeof(struct pet_bonus));
 	
@@ -11711,7 +11711,7 @@ BUILDIN(petskillbonus)
 	if (battle_config.pet_equip_required && pd->pet.equip == 0)
 		pd->bonus->timer = INVALID_TIMER;
 	else
-		pd->bonus->timer = iTimer->add_timer(iTimer->gettick()+pd->bonus->delay*1000, pet->skill_bonus_timer, sd->bl.id, 0);
+		pd->bonus->timer = timer->add(timer->gettick()+pd->bonus->delay*1000, pet->skill_bonus_timer, sd->bl.id, 0);
 	
 	return true;
 }
@@ -12065,7 +12065,7 @@ BUILDIN(petrecovery)
 	if (pd->recovery)
 	{ //Halt previous bonus
 		if (pd->recovery->timer != INVALID_TIMER)
-			iTimer->delete_timer(pd->recovery->timer, pet->recovery_timer);
+			timer->delete(pd->recovery->timer, pet->recovery_timer);
 	} else //Init
 		pd->recovery = (struct pet_recovery *)aMalloc(sizeof(struct pet_recovery));
 	
@@ -12093,9 +12093,9 @@ BUILDIN(petheal)
 		if (pd->s_skill->timer != INVALID_TIMER)
 		{
 			if (pd->s_skill->id)
-				iTimer->delete_timer(pd->s_skill->timer, pet->skill_support_timer);
+				timer->delete(pd->s_skill->timer, pet->skill_support_timer);
 			else
-				iTimer->delete_timer(pd->s_skill->timer, pet->heal_timer);
+				timer->delete(pd->s_skill->timer, pet->heal_timer);
 		}
 	} else //init memory
 		pd->s_skill = (struct pet_skill_support *) aMalloc(sizeof(struct pet_skill_support));
@@ -12111,7 +12111,7 @@ BUILDIN(petheal)
 	if (battle_config.pet_equip_required && pd->pet.equip == 0)
 		pd->s_skill->timer = INVALID_TIMER;
 	else
-		pd->s_skill->timer = iTimer->add_timer(iTimer->gettick()+pd->s_skill->delay*1000,pet->heal_timer,sd->bl.id,0);
+		pd->s_skill->timer = timer->add(timer->gettick()+pd->s_skill->delay*1000,pet->heal_timer,sd->bl.id,0);
 	
 	return true;
 }
@@ -12187,9 +12187,9 @@ BUILDIN(petskillsupport)
 		if (pd->s_skill->timer != INVALID_TIMER)
 		{
 			if (pd->s_skill->id)
-				iTimer->delete_timer(pd->s_skill->timer, pet->skill_support_timer);
+				timer->delete(pd->s_skill->timer, pet->skill_support_timer);
 			else
-				iTimer->delete_timer(pd->s_skill->timer, pet->heal_timer);
+				timer->delete(pd->s_skill->timer, pet->heal_timer);
 		}
 	} else //init memory
 		pd->s_skill = (struct pet_skill_support *) aMalloc(sizeof(struct pet_skill_support));
@@ -12204,7 +12204,7 @@ BUILDIN(petskillsupport)
 	if (battle_config.pet_equip_required && pd->pet.equip == 0)
 		pd->s_skill->timer = INVALID_TIMER;
 	else
-		pd->s_skill->timer = iTimer->add_timer(iTimer->gettick()+pd->s_skill->delay*1000,pet->skill_support_timer,sd->bl.id,0);
+		pd->s_skill->timer = timer->add(timer->gettick()+pd->s_skill->delay*1000,pet->skill_support_timer,sd->bl.id,0);
 	
 	return true;
 }
@@ -12242,7 +12242,7 @@ BUILDIN(npcskilleffect)
 	int y=script_getnum(st,5);
 	
 	if (bl)
-		clif->skill_poseffect(bl,skill_id,skill_lv,x,y,iTimer->gettick());
+		clif->skill_poseffect(bl,skill_id,skill_lv,x,y,timer->gettick());
 	
 	return true;
 }
@@ -12916,7 +12916,7 @@ BUILDIN(summon)
 	const char *str,*event="";
 	TBL_PC *sd;
 	struct mob_data *md;
-	int tick = iTimer->gettick();
+	int tick = timer->gettick();
 	
 	sd=script_rid2sd(st);
 	if (!sd) return true;
@@ -12937,8 +12937,8 @@ BUILDIN(summon)
 		md->master_id=sd->bl.id;
 		md->special_state.ai = AI_ATTACK;
 		if( md->deletetimer != INVALID_TIMER )
-			iTimer->delete_timer(md->deletetimer, mob->timer_delete);
-		md->deletetimer = iTimer->add_timer(tick+(timeout>0?timeout*1000:60000),mob->timer_delete,md->bl.id,0);
+			timer->delete(md->deletetimer, mob->timer_delete);
+		md->deletetimer = timer->add(tick+(timeout>0?timeout*1000:60000),mob->timer_delete,md->bl.id,0);
 		mob->spawn (md); //Now it is ready for spawning.
 		clif->specialeffect(&md->bl,344,AREA);
 		sc_start4(&md->bl, SC_MODECHANGE, 100, 1, 0, MD_AGGRESSIVE, 0, 60000);
@@ -15025,7 +15025,7 @@ BUILDIN(unitattack)
 	switch( unit_bl->type )
 	{
 		case BL_PC:
-			clif->pActionRequest_sub(((TBL_PC *)unit_bl), actiontype > 0 ? 0x07 : 0x00, target_bl->id, iTimer->gettick());
+			clif->pActionRequest_sub(((TBL_PC *)unit_bl), actiontype > 0 ? 0x07 : 0x00, target_bl->id, timer->gettick());
 			script_pushint(st, 1);
 			return true;
 		case BL_MOB:
@@ -15266,7 +15266,7 @@ BUILDIN(awake) {
 				tst->rid = 0;
 			}
 			
-			iTimer->delete_timer(tst->sleep.timer, script->run_timer);
+			timer->delete(tst->sleep.timer, script->run_timer);
 			tst->sleep.timer = INVALID_TIMER;
 			if(tst->state != RERUNLINE)
 				tst->sleep.tick = 0;
@@ -16433,7 +16433,7 @@ BUILDIN(progressbar)
 	second = script_getnum(st,3);
 	
 	sd->progressbar.npc_id = st->oid;
-	sd->progressbar.timeout = iTimer->gettick() + second*1000;
+	sd->progressbar.timeout = timer->gettick() + second*1000;
 	sd->state.workinprogress = 3;
 	
 	clif->progressbar(sd, strtol(color, (char **)NULL, 0), second);
diff --git a/src/map/skill.c b/src/map/skill.c
index 6ec9d2fec..3b7378022 100644
--- a/src/map/skill.c
+++ b/src/map/skill.c
@@ -496,7 +496,7 @@ int skillnotok (uint16 skill_id, struct map_session_data *sd)
 	// allowing a skill to be cast. This is to prevent no-delay ACT files from spamming skills such as
 	// AC_DOUBLE which do not have a skill delay and are not regarded in terms of attack motion.
 	if( !sd->state.autocast && sd->skillitem != skill_id && sd->canskill_tick &&
-		DIFF_TICK(iTimer->gettick(), sd->canskill_tick) < (sd->battle_status.amotion * (battle_config.skill_amotion_leniency) / 100) )
+		DIFF_TICK(timer->gettick(), sd->canskill_tick) < (sd->battle_status.amotion * (battle_config.skill_amotion_leniency) / 100) )
 	{// attempted to cast a skill before the attack motion has finished
 		return 1;
 	}
@@ -2334,8 +2334,8 @@ int skill_attack (int attack_type, struct block_list* src, struct block_list *ds
 					sce->val1 = skill_id; //Update combo-skill
 					sce->val3 = skill_id;
 					if( sce->timer != INVALID_TIMER )
-						iTimer->delete_timer(sce->timer, iStatus->change_timer);
-					sce->timer = iTimer->add_timer(tick+sce->val4, iStatus->change_timer, src->id, SC_COMBOATTACK);
+						timer->delete(sce->timer, iStatus->change_timer);
+					sce->timer = timer->add(tick+sce->val4, iStatus->change_timer, src->id, SC_COMBOATTACK);
 					break;
 				}
 				unit->cancel_combo(src); // Cancel combo wait
@@ -2717,12 +2717,12 @@ int skill_attack (int attack_type, struct block_list* src, struct block_list *ds
 			) && check_distance_bl(bl, d_bl, sce->val3) )
 		{
 			if(!rmdamage){
-				clif->damage(d_bl,d_bl, iTimer->gettick(), 0, 0, damage, 0, 0, 0);
+				clif->damage(d_bl,d_bl, timer->gettick(), 0, 0, damage, 0, 0, 0);
 				status_fix_damage(NULL,d_bl, damage, 0);
 			} else{ //Reflected magics are done directly on the target not on paladin
 				//This check is only for magical skill.
 				//For BF_WEAPON skills types track var rdamage and function battle_calc_return_damage
-				clif->damage(bl,bl, iTimer->gettick(), 0, 0, damage, 0, 0, 0);
+				clif->damage(bl,bl, timer->gettick(), 0, 0, damage, 0, 0, 0);
 				status_fix_damage(bl,bl, damage, 0);
 			}
 		}
@@ -3307,7 +3307,7 @@ int skill_addtimerskill (struct block_list *src, unsigned int tick, int target,
 	if( i == MAX_SKILLTIMERSKILL ) return 1;
 
 	ud->skilltimerskill[i] = ers_alloc(skill->timer_ers, struct skill_timerskill);
-	ud->skilltimerskill[i]->timer = iTimer->add_timer(tick, skill->timerskill, src->id, i);
+	ud->skilltimerskill[i]->timer = timer->add(tick, skill->timerskill, src->id, i);
 	ud->skilltimerskill[i]->src_id = src->id;
 	ud->skilltimerskill[i]->target_id = target;
 	ud->skilltimerskill[i]->skill_id = skill_id;
@@ -3333,7 +3333,7 @@ int skill_cleartimerskill (struct block_list *src)
 
 	for(i=0;i<MAX_SKILLTIMERSKILL;i++) {
 		if(ud->skilltimerskill[i]) {
-			iTimer->delete_timer(ud->skilltimerskill[i]->timer, skill->timerskill);
+			timer->delete(ud->skilltimerskill[i]->timer, skill->timerskill);
 			ers_free(skill->timer_ers, ud->skilltimerskill[i]);
 			ud->skilltimerskill[i]=NULL;
 		}
@@ -3346,8 +3346,8 @@ int skill_activate_reverbetion( struct block_list *bl, va_list ap) {
 	if( bl->type != BL_SKILL )
 		return 0;
 	if( su->alive && (sg = su->group) && sg->skill_id == WM_REVERBERATION ) {
-		iMap->foreachinrange(skill->trap_splash, bl, skill->get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag, bl, iTimer->gettick());
-		su->limit=DIFF_TICK(iTimer->gettick(),sg->tick);
+		iMap->foreachinrange(skill->trap_splash, bl, skill->get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag, bl, timer->gettick());
+		su->limit=DIFF_TICK(timer->gettick(),sg->tick);
 		sg->unit_id = UNT_USED_TRAPS;
 	}
 	return 0;
@@ -4430,7 +4430,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
 				skill->attack(skill->get_type(skill_id), src, src, bl, skill_id, skill_lv, tick, flag);
 			else {
 				clif->skill_nodamage(src, bl, skill_id, 0, 1);
-				skill->addtimerskill(src, iTimer->gettick() + skill->get_time(skill_id, skill_lv) - 1000, bl->id, 0, 0, skill_id, skill_lv, 0, 0);
+				skill->addtimerskill(src, timer->gettick() + skill->get_time(skill_id, skill_lv) - 1000, bl->id, 0, 0, skill_id, skill_lv, 0, 0);
 			}
 			break;
 
@@ -4567,7 +4567,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
 
 	if( sd && !(flag&1) )
 	{// ensure that the skill last-cast tick is recorded
-		sd->canskill_tick = iTimer->gettick();
+		sd->canskill_tick = timer->gettick();
 
 		if( sd->state.arrow_atk )
 		{// consume arrow on last invocation to this skill.
@@ -4810,8 +4810,8 @@ int skill_castend_id(int tid, unsigned int tick, int id, intptr_t data)
 			case NPC_GRANDDARKNESS:
 				if( (sc = iStatus->get_sc(src)) && sc->data[SC_NOEQUIPSHIELD] )
 				{
-					const struct TimerData *timer = iTimer->get_timer(sc->data[SC_NOEQUIPSHIELD]->timer);
-					if( timer && timer->func == iStatus->change_timer && DIFF_TICK(timer->tick,iTimer->gettick()+skill->get_time(ud->skill_id, ud->skill_lv)) > 0 )
+					const struct TimerData *td = timer->get(sc->data[SC_NOEQUIPSHIELD]->timer);
+					if( td && td->func == iStatus->change_timer && DIFF_TICK(td->tick,timer->gettick()+skill->get_time(ud->skill_id, ud->skill_lv)) > 0 )
 						break;
 				}
 				sc_start2(src, SC_NOEQUIPSHIELD, 100, 0, 1, skill->get_time(ud->skill_id, ud->skill_lv));
@@ -8560,7 +8560,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
 				if( is_boss(bl) ) break;
 				if( sc_start2(bl, type, 100, skill_lv, src->id, skill->get_time(skill_id, skill_lv))) {
 					if( bl->type == BL_MOB )
-						mob->unlocktarget((TBL_MOB*)bl,iTimer->gettick());
+						mob->unlocktarget((TBL_MOB*)bl,timer->gettick());
 					unit->stop_attack(bl);
 					clif->bladestop(src, bl->id, 1);
 					iMap->freeblock_unlock();
@@ -9153,8 +9153,8 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
 					md->master_id = src->id;
 					md->special_state.ai = AI_ZANZOU;
 					if( md->deletetimer != INVALID_TIMER )
-						iTimer->delete_timer(md->deletetimer, mob->timer_delete);
-					md->deletetimer = iTimer->add_timer (iTimer->gettick() + skill->get_time(skill_id, skill_lv), mob->timer_delete, md->bl.id, 0);
+						timer->delete(md->deletetimer, mob->timer_delete);
+					md->deletetimer = timer->add (timer->gettick() + skill->get_time(skill_id, skill_lv), mob->timer_delete, md->bl.id, 0);
 					mob->spawn( md );
 					pc->setinvincibletimer(sd,500);// unlock target lock
 					clif->skill_nodamage(src,bl,skill_id,skill_lv,1);
@@ -9338,8 +9338,8 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
 						if (md) {
 							md->master_id = src->id;
 							if (md->deletetimer != INVALID_TIMER)
-								iTimer->delete_timer(md->deletetimer, mob->timer_delete);
-							md->deletetimer = iTimer->add_timer(iTimer->gettick() + skill->get_time(skill_id, skill_lv), mob->timer_delete, md->bl.id, 0);
+								timer->delete(md->deletetimer, mob->timer_delete);
+							md->deletetimer = timer->add(timer->gettick() + skill->get_time(skill_id, skill_lv), mob->timer_delete, md->bl.id, 0);
 							mob->spawn(md); //Now it is ready for spawning.
 							sc_start4(&md->bl, SC_MODECHANGE, 100, 1, 0, MD_CANATTACK|MD_AGGRESSIVE, 0, 60000);
 						}
@@ -9367,7 +9367,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
 	}
 
 	if( sd && !(flag&1) ) { // ensure that the skill last-cast tick is recorded
-		sd->canskill_tick = iTimer->gettick();
+		sd->canskill_tick = timer->gettick();
 
 		if( sd->state.arrow_atk ) { // consume arrow on last invocation to this skill.
 			battle->consume_ammo(sd, skill_id, skill_lv);
@@ -9772,7 +9772,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
 			struct skill_unit_group *sg;
 			if ((sg= skill->locate_element_field(src)) != NULL && ( sg->skill_id == SA_VOLCANO || sg->skill_id == SA_DELUGE || sg->skill_id == SA_VIOLENTGALE ))
 			{
-				if (sg->limit - DIFF_TICK(iTimer->gettick(), sg->tick) > 0) {
+				if (sg->limit - DIFF_TICK(timer->gettick(), sg->tick) > 0) {
 					skill->unitsetting(src,skill_id,skill_lv,x,y,0);
 					return 0; // not to consume items
 				} else
@@ -10000,8 +10000,8 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
 					md->master_id = src->id;
 					md->special_state.ai = (skill_id == AM_SPHEREMINE) ? AI_SPHERE : AI_FLORA;
 					if( md->deletetimer != INVALID_TIMER )
-						iTimer->delete_timer(md->deletetimer, mob->timer_delete);
-					md->deletetimer = iTimer->add_timer (iTimer->gettick() + skill->get_time(skill_id,skill_lv), mob->timer_delete, md->bl.id, 0);
+						timer->delete(md->deletetimer, mob->timer_delete);
+					md->deletetimer = timer->add (timer->gettick() + skill->get_time(skill_id,skill_lv), mob->timer_delete, md->bl.id, 0);
 					mob->spawn (md); //Now it is ready for spawning.
 				}
 			}
@@ -10099,8 +10099,8 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
 					if ((i = skill->get_time(skill_id, skill_lv)) > 0)
 					{
 						if( md->deletetimer != INVALID_TIMER )
-							iTimer->delete_timer(md->deletetimer, mob->timer_delete);
-						md->deletetimer = iTimer->add_timer (tick + i, mob->timer_delete, md->bl.id, 0);
+							timer->delete(md->deletetimer, mob->timer_delete);
+						md->deletetimer = timer->add (tick + i, mob->timer_delete, md->bl.id, 0);
 					}
 					mob->spawn (md);
 				}
@@ -10199,7 +10199,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
 						case 2: sx = x - i; break;
 						case 6: sx = x + i; break;
 					}
-					skill->addtimerskill(src,iTimer->gettick() + (50 * i),0,sx,sy,skill_id,skill_lv,dir,flag&2);
+					skill->addtimerskill(src,timer->gettick() + (50 * i),0,sx,sy,skill_id,skill_lv,dir,flag&2);
 				}
 			}
 			break;
@@ -10234,8 +10234,8 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
 					md->master_id = src->id;
 					md->special_state.ai = AI_FLORA;
 					if( md->deletetimer != INVALID_TIMER )
-						iTimer->delete_timer(md->deletetimer, mob->timer_delete);
-					md->deletetimer = iTimer->add_timer (iTimer->gettick() + skill->get_time(skill_id, skill_lv), mob->timer_delete, md->bl.id, 0);
+						timer->delete(md->deletetimer, mob->timer_delete);
+					md->deletetimer = timer->add (timer->gettick() + skill->get_time(skill_id, skill_lv), mob->timer_delete, md->bl.id, 0);
 					mob->spawn( md );
 				}
 			}
@@ -10370,7 +10370,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
 		status_change_end(src,SC_CURSEDCIRCLE_ATKER,INVALID_TIMER);
 
 	if( sd ) {// ensure that the skill last-cast tick is recorded
-		sd->canskill_tick = iTimer->gettick();
+		sd->canskill_tick = timer->gettick();
 
 		if( sd->state.arrow_atk && !(flag&1) ) {
 			// consume arrow if this is a ground skill
@@ -10490,7 +10490,7 @@ int skill_icewall_block(struct block_list *bl,va_list ap) {
 		return 0;
 
 	if( !check_distance_bl(bl, target, status_get_range(bl) ) ) {
-		mob->unlocktarget(md,iTimer->gettick());
+		mob->unlocktarget(md,timer->gettick());
 		mob_stop_walking(md,1);
 	}
 
@@ -10644,7 +10644,7 @@ struct skill_unit_group* skill_unitsetting (struct block_list *src, uint16 skill
 					old_sg->skill_id == SA_VIOLENTGALE
 				) && old_sg->limit > 0)
 				{	//Use the previous limit (minus the elapsed time) [Skotlex]
-					limit = old_sg->limit - DIFF_TICK(iTimer->gettick(), old_sg->tick);
+					limit = old_sg->limit - DIFF_TICK(timer->gettick(), old_sg->tick);
 					if (limit < 0)	//This can happen...
 						limit = skill->get_time(skill_id,skill_lv);
 				}
@@ -10859,7 +10859,7 @@ struct skill_unit_group* skill_unitsetting (struct block_list *src, uint16 skill
 	group->state.guildaura = ( skill_id >= GD_LEADERSHIP && skill_id <= GD_HAWKEYES )?1:0;
 	group->item_id = req_item;
   	//if tick is greater than current, do not invoke onplace function just yet. [Skotlex]
-	if (DIFF_TICK(group->tick, iTimer->gettick()) > SKILLUNITTIMER_INTERVAL)
+	if (DIFF_TICK(group->tick, timer->gettick()) > SKILLUNITTIMER_INTERVAL)
 		active_flag = 0;
 
 	if(skill_id==HT_TALKIEBOX || skill_id==RG_GRAFFITI){
@@ -10976,7 +10976,7 @@ struct skill_unit_group* skill_unitsetting (struct block_list *src, uint16 skill
 
 		// execute on all targets standing on this cell
 		if (range==0 && active_flag)
-			iMap->foreachincell(skill->unit_effect,unit->bl.m,unit->bl.x,unit->bl.y,group->bl_flag,&unit->bl,iTimer->gettick(),1);
+			iMap->foreachincell(skill->unit_effect,unit->bl.m,unit->bl.x,unit->bl.y,group->bl_flag,&unit->bl,timer->gettick(),1);
 	}
 
 	if (!group->alive_count) {	//No cells? Something that was blocked completely by Land Protector?
@@ -11038,7 +11038,7 @@ int skill_unit_onplace (struct skill_unit *src, struct block_list *bl, unsigned
 			} else if( sc && battle->check_target(&sg->unit->bl,bl,sg->target_flag) > 0 ) {
 				int sec = skill->get_time2(sg->skill_id,sg->skill_lv);
 				if( iStatus->change_start(bl,type,10000,sg->skill_lv,1,sg->group_id,0,sec,8) ) {
-					const struct TimerData* td = sc->data[type]?iTimer->get_timer(sc->data[type]->timer):NULL;
+					const struct TimerData* td = sc->data[type]?timer->get(sc->data[type]->timer):NULL;
 					if( td )
 						sec = DIFF_TICK(td->tick, tick);
 					iMap->moveblock(bl, src->bl.x, src->bl.y, tick);
@@ -11150,8 +11150,8 @@ int skill_unit_onplace (struct skill_unit *src, struct block_list *bl, unsigned
 			else if (sce->val4 == 1) {
 				//Readjust timers since the effect will not last long.
 				sce->val4 = 0;
-				iTimer->delete_timer(sce->timer, iStatus->change_timer);
-				sce->timer = iTimer->add_timer(tick+sg->limit, iStatus->change_timer, bl->id, type);
+				timer->delete(sce->timer, iStatus->change_timer);
+				sce->timer = timer->add(tick+sg->limit, iStatus->change_timer, bl->id, type);
 			}
 			break;
 
@@ -11411,7 +11411,7 @@ int skill_unit_onplace_timer (struct skill_unit *src, struct block_list *bl, uns
 			if( sg->val2 == 0 && tsc && (sg->unit_id == UNT_ANKLESNARE || bl->id != sg->src_id) ) {
 				int sec = skill->get_time2(sg->skill_id,sg->skill_lv);
 				if( iStatus->change_start(bl,type,10000,sg->skill_lv,sg->group_id,0,0,sec, 8) ) {
-					const struct TimerData* td = tsc->data[type]?iTimer->get_timer(tsc->data[type]->timer):NULL;
+					const struct TimerData* td = tsc->data[type]?timer->get(tsc->data[type]->timer):NULL;
 					if( td )
 						sec = DIFF_TICK(td->tick, tick);
 					if( sg->unit_id == UNT_MANHOLE || battle_config.skill_trap_type || !map_flag_gvg2(src->bl.m) ) {
@@ -11748,7 +11748,7 @@ int skill_unit_onplace_timer (struct skill_unit *src, struct block_list *bl, uns
 				if( !sg->val2 ) {
 					int sec = skill->get_time2(sg->skill_id, sg->skill_lv);
 					if( sc_start(bl, type, 100, sg->skill_lv, sec) ) {
-						const struct TimerData* td = tsc->data[type]?iTimer->get_timer(tsc->data[type]->timer):NULL;
+						const struct TimerData* td = tsc->data[type]?timer->get(tsc->data[type]->timer):NULL;
 						if( td )
 							sec = DIFF_TICK(td->tick, tick);
 						///iMap->moveblock(bl, src->bl.x, src->bl.y, tick); // in official server it doesn't behave like this. [malufett]
@@ -12046,11 +12046,11 @@ static int skill_unit_onleft (uint16 skill_id, struct block_list *bl, unsigned i
 		case DC_FORTUNEKISS:
 		case DC_SERVICEFORYOU:
 			if (sce) {
-				iTimer->delete_timer(sce->timer, iStatus->change_timer);
+				timer->delete(sce->timer, iStatus->change_timer);
 				//NOTE: It'd be nice if we could get the skill_lv for a more accurate extra time, but alas...
 				//not possible on our current implementation.
 				sce->val4 = 1; //Store the fact that this is a "reduced" duration effect.
-				sce->timer = iTimer->add_timer(tick+skill->get_time2(skill_id,1), iStatus->change_timer, bl->id, type);
+				sce->timer = timer->add(tick+skill->get_time2(skill_id,1), iStatus->change_timer, bl->id, type);
 			}
 			break;
 		case PF_FOGWALL:
@@ -12060,8 +12060,8 @@ static int skill_unit_onleft (uint16 skill_id, struct block_list *bl, unsigned i
 					if (bl->type == BL_PC) //Players get blind ended inmediately, others have it still for 30 secs. [Skotlex]
 						status_change_end(bl, SC_BLIND, INVALID_TIMER);
 					else {
-						iTimer->delete_timer(sce->timer, iStatus->change_timer);
-						sce->timer = iTimer->add_timer(30000+tick, iStatus->change_timer, bl->id, SC_BLIND);
+						timer->delete(sce->timer, iStatus->change_timer);
+						sce->timer = timer->add(30000+tick, iStatus->change_timer, bl->id, SC_BLIND);
 					}
 				}
 			}
@@ -13091,7 +13091,7 @@ int skill_check_condition_castbegin(struct map_session_data* sd, uint16 skill_id
 			break;
 		case ST_MOVE_ENABLE:
 			if (sc && sc->data[SC_COMBOATTACK] && sc->data[SC_COMBOATTACK]->val1 == skill_id)
-				sd->ud.canmove_tick = iTimer->gettick(); //When using a combo, cancel the can't move delay to enable the skill. [Skotlex]
+				sd->ud.canmove_tick = timer->gettick(); //When using a combo, cancel the can't move delay to enable the skill. [Skotlex]
 
 			if (!unit->can_move(&sd->bl)) {
 				clif->skill_fail(sd,skill_id,USESKILL_FAIL_LEVEL,0);
@@ -14741,7 +14741,7 @@ int skill_detonator(struct block_list *bl, va_list ap)
 					iMap->foreachinrange(skill->trap_splash,bl,skill->get_splash(unit->group->skill_id,unit->group->skill_lv),unit->group->bl_flag,bl,unit->group->tick);
 			}				
 			clif->changetraplook(bl, UNT_USED_TRAPS);
-			unit->group->limit = DIFF_TICK(iTimer->gettick(),unit->group->tick) +
+			unit->group->limit = DIFF_TICK(timer->gettick(),unit->group->tick) +
 				(unit_id == UNT_TALKIEBOX ? 5000 : (unit_id == UNT_CLUSTERBOMB || unit_id == UNT_ICEBOUNDTRAP? 2500 : (unit_id == UNT_FIRINGTRAP ? 0 : 1500)) );
 			unit->group->unit_id = UNT_USED_TRAPS;
 			break;
@@ -14963,7 +14963,7 @@ int skill_trap_splash (struct block_list *bl, va_list ap) {
 					case UNT_FIRINGTRAP:
 					case UNT_ICEBOUNDTRAP:
 						clif->changetraplook(bl, UNT_USED_TRAPS);
-						su->group->limit = DIFF_TICK(iTimer->gettick(),su->group->tick) + 1500;
+						su->group->limit = DIFF_TICK(timer->gettick(),su->group->tick) + 1500;
 						su->group->unit_id = UNT_USED_TRAPS;
 				}
 				break;
@@ -15159,7 +15159,7 @@ int skill_delunit (struct skill_unit* unit) {
 
 	// invoke onout event
 	if( !unit->range )
-		iMap->foreachincell(skill->unit_effect,unit->bl.m,unit->bl.x,unit->bl.y,group->bl_flag,&unit->bl,iTimer->gettick(),4);
+		iMap->foreachincell(skill->unit_effect,unit->bl.m,unit->bl.x,unit->bl.y,group->bl_flag,&unit->bl,timer->gettick(),4);
 
 	// perform ondelete actions
 	switch (group->skill_id) {
@@ -15261,7 +15261,7 @@ struct skill_unit_group* skill_initunitgroup (struct block_list* src, int count,
 	if(i == MAX_SKILLUNITGROUP) {
 		// array is full, make room by discarding oldest group
 		int j=0;
-		unsigned maxdiff=0,x,tick=iTimer->gettick();
+		unsigned maxdiff=0,x,tick=timer->gettick();
 		for(i=0;i<MAX_SKILLUNITGROUP && ud->skillunit[i];i++)
 			if((x=DIFF_TICK(tick,ud->skillunit[i]->tick))>maxdiff){
 				maxdiff=x;
@@ -15290,7 +15290,7 @@ struct skill_unit_group* skill_initunitgroup (struct block_list* src, int count,
 	group->map        = src->m;
 	group->limit      = limit;
 	group->interval   = interval;
-	group->tick       = iTimer->gettick();
+	group->tick       = timer->gettick();
 	group->valstr     = NULL;
 
 	ud->skillunit[i] = group;
@@ -15598,7 +15598,7 @@ int skill_unit_timer_sub(DBKey key, DBData *data, va_list ap) {
 				group->limit = skill->get_time(group->skill_id,group->skill_lv);
 				unit->limit = skill->get_time(group->skill_id,group->skill_lv);
 				// apply effect to all units standing on it
-				iMap->foreachincell(skill->unit_effect,unit->bl.m,unit->bl.x,unit->bl.y,group->bl_flag,&unit->bl,iTimer->gettick(),1);
+				iMap->foreachincell(skill->unit_effect,unit->bl.m,unit->bl.x,unit->bl.y,group->bl_flag,&unit->bl,timer->gettick(),1);
 			break;
 
 			case UNT_CALLFAMILY:
@@ -15875,7 +15875,7 @@ int skill_unit_move (struct block_list *bl, unsigned int tick, int flag) {
 int skill_unit_move_unit_group (struct skill_unit_group *group, int16 m, int16 dx, int16 dy)
 {
 	int i,j;
-	unsigned int tick = iTimer->gettick();
+	unsigned int tick = timer->gettick();
 	int *m_flag;
 	struct skill_unit *unit1;
 	struct skill_unit *unit2;
@@ -16731,8 +16731,8 @@ int skill_magicdecoy(struct map_session_data *sd, int nameid) {
 		md->master_id = sd->bl.id;
 		md->special_state.ai = AI_FLORA;
 		if( md->deletetimer != INVALID_TIMER )
-			iTimer->delete_timer(md->deletetimer, mob->timer_delete);
-		md->deletetimer = iTimer->add_timer (iTimer->gettick() + skill->get_time(NC_MAGICDECOY,skill_id), mob->timer_delete, md->bl.id, 0);
+			timer->delete(md->deletetimer, mob->timer_delete);
+		md->deletetimer = timer->add (timer->gettick() + skill->get_time(NC_MAGICDECOY,skill_id), mob->timer_delete, md->bl.id, 0);
 		mob->spawn(md);
 		md->status.matk_min = md->status.matk_max = 250 + (50 * skill_id);
 	}
@@ -17062,13 +17062,13 @@ int skill_blockpc_start_(struct map_session_data *sd, uint16 skill_id, int tick,
 #endif
 			cd->entry[cd->cursor]->skidx = idx;
 			cd->entry[cd->cursor]->skill_id = skill_id;
-			cd->entry[cd->cursor]->started = iTimer->gettick();
+			cd->entry[cd->cursor]->started = timer->gettick();
 			
 			cd->cursor++;
 		}
 	}
 
-	sd->blockskill[idx] = 0x1|(0xFE&iTimer->add_timer(iTimer->gettick()+tick,skill->blockpc_end,sd->bl.id,idx));
+	sd->blockskill[idx] = 0x1|(0xFE&timer->add(timer->gettick()+tick,skill->blockpc_end,sd->bl.id,idx));
 	return 0;
 }
 
@@ -17094,7 +17094,7 @@ int skill_blockhomun_start(struct homun_data *hd, uint16 skill_id, int tick) { /
 		return -1;
 	}
 	hd->blockskill[idx] = 1;
-	return iTimer->add_timer(iTimer->gettick() + tick, skill->blockhomun_end, hd->bl.id, idx);
+	return timer->add(timer->gettick() + tick, skill->blockhomun_end, hd->bl.id, idx);
 }
 
 int skill_blockmerc_end(int tid, unsigned int tick, int id, intptr_t data) {//[orn]
@@ -17119,7 +17119,7 @@ int skill_blockmerc_start(struct mercenary_data *md, uint16 skill_id, int tick)
 		return -1;
 	}
 	md->blockskill[idx] = 1;
-	return iTimer->add_timer(iTimer->gettick() + tick, skill->blockmerc_end, md->bl.id, idx);
+	return timer->add(timer->gettick() + tick, skill->blockmerc_end, md->bl.id, idx);
 }
 /**
  * Adds a new skill unit entry for this player to recast after map load
@@ -17572,7 +17572,7 @@ void skill_cooldown_save(struct map_session_data * sd) {
 		return;
 	}
 	
-	now = iTimer->gettick();
+	now = timer->gettick();
 		
 	// process each individual cooldown associated with the character
 	for( i = 0; i < cd->cursor; i++ ) {
@@ -17598,7 +17598,7 @@ void skill_cooldown_load(struct map_session_data * sd) {
 
 	clif->cooldown_list(sd->fd,cd);
 	
-	now = iTimer->gettick();
+	now = timer->gettick();
 	
 	// process each individual cooldown associated with the character
 	for( i = 0; i < cd->cursor; i++ ) {
@@ -18087,13 +18087,13 @@ int do_init_skill (void) {
 	ers_chunk_size(skill->cd_ers, 25);
 	ers_chunk_size(skill->cd_entry_ers, 100);
 	
-	iTimer->add_timer_func_list(skill->unit_timer,"skill_unit_timer");
-	iTimer->add_timer_func_list(skill->castend_id,"skill_castend_id");
-	iTimer->add_timer_func_list(skill->castend_pos,"skill_castend_pos");
-	iTimer->add_timer_func_list(skill->timerskill,"skill_timerskill");
-	iTimer->add_timer_func_list(skill->blockpc_end, "skill_blockpc_end");
+	timer->add_func_list(skill->unit_timer,"skill_unit_timer");
+	timer->add_func_list(skill->castend_id,"skill_castend_id");
+	timer->add_func_list(skill->castend_pos,"skill_castend_pos");
+	timer->add_func_list(skill->timerskill,"skill_timerskill");
+	timer->add_func_list(skill->blockpc_end, "skill_blockpc_end");
 
-	iTimer->add_timer_interval(iTimer->gettick()+SKILLUNITTIMER_INTERVAL,skill->unit_timer,0,0,SKILLUNITTIMER_INTERVAL);
+	timer->add_interval(timer->gettick()+SKILLUNITTIMER_INTERVAL,skill->unit_timer,0,0,SKILLUNITTIMER_INTERVAL);
 	
 	return 0;
 }
diff --git a/src/map/status.c b/src/map/status.c
index ee5d4bfd5..4f1ca9094 100644
--- a/src/map/status.c
+++ b/src/map/status.c
@@ -1157,7 +1157,7 @@ int status_damage(struct block_list *src,struct block_list *target,int64 in_hp,
 	}
 
 	if (target->type == BL_SKILL)
-		return skill->unit_ondamaged((struct skill_unit *)target, src, hp, iTimer->gettick());
+		return skill->unit_ondamaged((struct skill_unit *)target, src, hp, timer->gettick());
 
 	status = iStatus->get_status_data(target);
 	if( status == &dummy_status )
@@ -1259,7 +1259,7 @@ int status_damage(struct block_list *src,struct block_list *target,int64 in_hp,
 	if( status->hp || (flag&8) )
 	{	//Still lives or has been dead before this damage.
 		if (walkdelay)
-			unit->set_walkdelay(target, iTimer->gettick(), walkdelay, 0);
+			unit->set_walkdelay(target, timer->gettick(), walkdelay, 0);
 		return (int)(hp+sp);
 	}
 
@@ -1347,7 +1347,7 @@ int status_damage(struct block_list *src,struct block_list *target,int64 in_hp,
 		unit->stop_walking(target,1);
 		unit->skillcastcancel(target,0);
 		clif->clearunit_area(target,CLR_DEAD);
-		skill->unit_move(target,iTimer->gettick(),4);
+		skill->unit_move(target,timer->gettick(),4);
 		skill->cleartimerskill(target);
 	}
 
@@ -7302,7 +7302,7 @@ int status_change_start(struct block_list* bl,enum sc_type type,int rate,int val
 			//Kaahi overwrites previous level regardless of existing level.
 			//Delete timer if it exists.
 			if (sce->val4 != INVALID_TIMER) {
-				iTimer->delete_timer(sce->val4,iStatus->kaahi_heal_timer);
+				timer->delete(sce->val4,iStatus->kaahi_heal_timer);
 				sce->val4 = INVALID_TIMER;
 			}
 			break;
@@ -7882,8 +7882,8 @@ int status_change_start(struct block_list* bl,enum sc_type type,int rate,int val
 						sc_start4(src,SC_RG_CCONFINE_M,100,val1,1,0,0,tick+1000);
 					else { //Increase count of locked enemies and refresh time.
 						(sce2->val2)++;
-						iTimer->delete_timer(sce2->timer, iStatus->change_timer);
-						sce2->timer = iTimer->add_timer(iTimer->gettick()+tick+1000, iStatus->change_timer, src->id, SC_RG_CCONFINE_M);
+						timer->delete(sce2->timer, iStatus->change_timer);
+						sce2->timer = timer->add(timer->gettick()+tick+1000, iStatus->change_timer, src->id, SC_RG_CCONFINE_M);
 					}
 				} else //Status failed.
 					return 0;
@@ -7917,8 +7917,8 @@ int status_change_start(struct block_list* bl,enum sc_type type,int rate,int val
 			struct unit_data *ud = unit->bl2ud(bl);
 			if (ud && !val3) {
 				tick += 300 * battle_config.combo_delay_rate/100;
-				ud->attackabletime = iTimer->gettick()+tick;
-				unit->set_walkdelay(bl, iTimer->gettick(), tick, 1);
+				ud->attackabletime = timer->gettick()+tick;
+				unit->set_walkdelay(bl, timer->gettick(), tick, 1);
 			}
 			val3 = 0;
 			val4 = tick;
@@ -7928,7 +7928,7 @@ int status_change_start(struct block_list* bl,enum sc_type type,int rate,int val
 			val2 = 11-val1; //Chance to consume: 11-skill_lv%
 			break;
 		case SC_RUN:
-			val4 = iTimer->gettick(); //Store time at which you started running.
+			val4 = timer->gettick(); //Store time at which you started running.
 			tick = -1;
 			break;
 		case SC_KAAHI:
@@ -8325,7 +8325,7 @@ int status_change_start(struct block_list* bl,enum sc_type type,int rate,int val
 			tick_time = 1000; // [GodLesZ] tick time
 			break;
 		case SC_WUGDASH:
-			val4 = iTimer->gettick(); //Store time at which you started running.
+			val4 = timer->gettick(); //Store time at which you started running.
 			tick = -1;
 			break;
 		case SC__SHADOWFORM: {
@@ -9115,7 +9115,7 @@ int status_change_start(struct block_list* bl,enum sc_type type,int rate,int val
 	//Don't trust the previous sce assignment, in case the SC ended somewhere between there and here.
 	if((sce=sc->data[type])) {// reuse old sc
 		if( sce->timer != INVALID_TIMER )
-			iTimer->delete_timer(sce->timer, iStatus->change_timer);
+			timer->delete(sce->timer, iStatus->change_timer);
 	} else {// new sc
 		++(sc->count);
 		sce = sc->data[type] = ers_alloc(sc_data_ers, struct status_change_entry);
@@ -9125,7 +9125,7 @@ int status_change_start(struct block_list* bl,enum sc_type type,int rate,int val
 	sce->val3 = val3;
 	sce->val4 = val4;
 	if (tick >= 0)
-		sce->timer = iTimer->add_timer(iTimer->gettick() + tick, iStatus->change_timer, bl->id, type);
+		sce->timer = timer->add(timer->gettick() + tick, iStatus->change_timer, bl->id, type);
 	else
 		sce->timer = INVALID_TIMER; //Infinite duration
 
@@ -9270,7 +9270,7 @@ int status_change_clear(struct block_list* bl, int type) {
 			//If for some reason status_change_end decides to still keep the status when quitting. [Skotlex]
 			(sc->count)--;
 			if (sc->data[i]->timer != INVALID_TIMER)
-				iTimer->delete_timer(sc->data[i]->timer, iStatus->change_timer);
+				timer->delete(sc->data[i]->timer, iStatus->change_timer);
 			ers_free(sc_data_ers, sc->data[i]);
 			sc->data[i] = NULL;
 		}
@@ -9319,7 +9319,7 @@ int status_change_end_(struct block_list* bl, enum sc_type type, int tid, const
 			//Do not end infinite endure.
 				return 0;
 		if (sce->timer != INVALID_TIMER) //Could be a SC with infinite duration
-			iTimer->delete_timer(sce->timer,iStatus->change_timer);
+			timer->delete(sce->timer,iStatus->change_timer);
 		if (sc->opt1)
 			switch (type) {
 				//"Ugly workaround"  [Skotlex]
@@ -9335,7 +9335,7 @@ int status_change_end_(struct block_list* bl, enum sc_type type, int tid, const
 					//since these SC are not affected by it, and it lets us know
 					//if we have already delayed this attack or not.
 					sce->val1 = 0;
-					sce->timer = iTimer->add_timer(iTimer->gettick()+10, iStatus->change_timer, bl->id, type);
+					sce->timer = timer->add(timer->gettick()+10, iStatus->change_timer, bl->id, type);
 					return 1;
 				}
 		}
@@ -9375,7 +9375,7 @@ int status_change_end_(struct block_list* bl, enum sc_type type, int tid, const
 					unit->stop_walking(bl,1);
 			}
 			if (begin_spurt && sce->val1 >= 7 &&
-				DIFF_TICK(iTimer->gettick(), sce->val4) <= 1000 &&
+				DIFF_TICK(timer->gettick(), sce->val4) <= 1000 &&
 				(!sd || (sd->weapontype1 == 0 && sd->weapontype2 == 0))
 				)
 				sc_start(bl,SC_STRUP,100,sce->val1,skill->get_time2(iStatus->sc2skill(type), sce->val1));
@@ -9515,7 +9515,7 @@ int status_change_end_(struct block_list* bl, enum sc_type type, int tid, const
 		{
 			struct block_list *src=iMap->id2bl(sce->val3);
 			if(src && tid != INVALID_TIMER)
-				skill->castend_damage_id(src, bl, sce->val2, sce->val1, iTimer->gettick(), SD_LEVEL );
+				skill->castend_damage_id(src, bl, sce->val2, sce->val1, timer->gettick(), SD_LEVEL );
 		}
 		break;
 	case SC_RG_CCONFINE_S:
@@ -9536,7 +9536,7 @@ int status_change_end_(struct block_list* bl, enum sc_type type, int tid, const
 				+skill->get_range2(bl, iStatus->sc2skill(type), sce->val1)
 				+skill->get_range2(bl, TF_BACKSLIDING, 1); //Since most people use this to escape the hold....
 			iMap->foreachinarea(iStatus->change_timer_sub,
-				bl->m, bl->x-range, bl->y-range, bl->x+range,bl->y+range,BL_CHAR,bl,sce,type,iTimer->gettick());
+				bl->m, bl->x-range, bl->y-range, bl->x+range,bl->y+range,BL_CHAR,bl,sce,type,timer->gettick());
 		}
 		break;
 	case SC_COMBOATTACK:
@@ -9624,7 +9624,7 @@ int status_change_end_(struct block_list* bl, enum sc_type type, int tid, const
 	case SC_KAAHI:
 		//Delete timer if it exists.
 		if (sce->val4 != INVALID_TIMER)
-			iTimer->delete_timer(sce->val4,iStatus->kaahi_heal_timer);
+			timer->delete(sce->val4,iStatus->kaahi_heal_timer);
 		break;
 	case SC_JAILED:
 		if(tid == INVALID_TIMER)
@@ -9676,7 +9676,7 @@ int status_change_end_(struct block_list* bl, enum sc_type type, int tid, const
 			struct block_list* src = iMap->id2bl(sce->val2);
 			if( tid == -1 || !src)
 				break; // Terminated by Damage
-			status_fix_damage(src,bl,400*sce->val1,clif->damage(bl,bl,iTimer->gettick(),0,0,400*sce->val1,0,0,0));
+			status_fix_damage(src,bl,400*sce->val1,clif->damage(bl,bl,timer->gettick(),0,0,400*sce->val1,0,0,0));
 		}
 		break;
 	case SC_WUGDASH:
@@ -9724,7 +9724,7 @@ int status_change_end_(struct block_list* bl, enum sc_type type, int tid, const
 		break;
 	case SC_CURSEDCIRCLE_ATKER:
 		if( sce->val2 ) // used the default area size cause there is a chance the caster could knock back and can't clear the target.
-			iMap->foreachinrange(iStatus->change_timer_sub, bl, battle_config.area_size,BL_CHAR, bl, sce, SC_CURSEDCIRCLE_TARGET, iTimer->gettick());
+			iMap->foreachinrange(iStatus->change_timer_sub, bl, battle_config.area_size,BL_CHAR, bl, sce, SC_CURSEDCIRCLE_TARGET, timer->gettick());
 		break;
 	case SC_RAISINGDRAGON:
 		if( sd && sce->val2 && !pc_isdead(sd) ) {
@@ -9979,7 +9979,7 @@ int status_change_end_(struct block_list* bl, enum sc_type type, int tid, const
 		status_calc_bl(bl,calc_flag);
 
 	if(opt_flag&4) //Out of hiding, invoke on place.
-		skill->unit_move(bl,iTimer->gettick(),1);
+		skill->unit_move(bl,timer->gettick(),1);
 
 	if(opt_flag&2 && sd && iMap->getcell(bl->m,bl->x,bl->y,CELL_CHKNPC))
 		npc->touch_areanpc(sd,bl->m,bl->x,bl->y); //Trigger on-touch event.
@@ -10061,7 +10061,7 @@ int status_change_timer(int tid, unsigned int tick, int id, intptr_t data)
 	// set the next timer of the sce (don't assume the status still exists)
 #define sc_timer_next(t,f,i,d) \
 	if( (sce=sc->data[type]) ) \
-	sce->timer = iTimer->add_timer(t,f,i,d); \
+	sce->timer = timer->add(t,f,i,d); \
 	else \
 	ShowError("status_change_timer: Unexpected NULL status change id: %d data: %d\n", id, data)
 
@@ -11131,14 +11131,14 @@ int status_change_clear_buffs (struct block_list* bl, int type)
 int status_change_spread( struct block_list *src, struct block_list *bl ) {
 	int i, flag = 0;
 	struct status_change *sc = iStatus->get_sc(src);
-	const struct TimerData *timer;
+	const struct TimerData *td;
 	unsigned int tick;
 	struct status_change_data data;
 
 	if( !sc || !sc->count )
 		return 0;
 
-	tick = iTimer->gettick();
+	tick = timer->gettick();
 
 	for( i = SC_COMMON_MIN; i < SC_MAX; i++ ) {
 		if( !sc->data[i] || i == SC_COMMON_MAX )
@@ -11171,10 +11171,10 @@ int status_change_spread( struct block_list *src, struct block_list *bl ) {
 		case SC_DEATHHURT:
 		case SC_PARALYSE:
 			if( sc->data[i]->timer != INVALID_TIMER ) {
-				timer = iTimer->get_timer(sc->data[i]->timer);
-				if (timer == NULL || timer->func != iStatus->change_timer || DIFF_TICK(timer->tick,tick) < 0)
+				td = timer->get(sc->data[i]->timer);
+				if (td == NULL || td->func != iStatus->change_timer || DIFF_TICK(td->tick,tick) < 0)
 					continue;
-				data.tick = DIFF_TICK(timer->tick,tick);
+				data.tick = DIFF_TICK(td->tick,tick);
 			} else
 				data.tick = INVALID_TIMER;
 			break;
@@ -11616,16 +11616,16 @@ int status_readdb(void)
 *------------------------------------------*/
 int do_init_status(void)
 {
-	iTimer->add_timer_func_list(iStatus->change_timer,"status_change_timer");
-	iTimer->add_timer_func_list(kaahi_heal_timer,"kaahi_heal_timer");
-	iTimer->add_timer_func_list(status_natural_heal_timer,"status_natural_heal_timer");
+	timer->add_func_list(iStatus->change_timer,"status_change_timer");
+	timer->add_func_list(kaahi_heal_timer,"kaahi_heal_timer");
+	timer->add_func_list(status_natural_heal_timer,"status_natural_heal_timer");
 	initChangeTables();
 	initDummyData();
 	iStatus->readdb();
 	status_calc_sigma();
-	natural_heal_prev_tick = iTimer->gettick();
+	natural_heal_prev_tick = timer->gettick();
 	sc_data_ers = ers_new(sizeof(struct status_change_entry),"status.c::sc_data_ers",ERS_OPT_NONE);
-	iTimer->add_timer_interval(natural_heal_prev_tick + NATURAL_HEAL_INTERVAL, status_natural_heal_timer, 0, 0, NATURAL_HEAL_INTERVAL);
+	timer->add_interval(natural_heal_prev_tick + NATURAL_HEAL_INTERVAL, status_natural_heal_timer, 0, 0, NATURAL_HEAL_INTERVAL);
 	return 0;
 }
 void do_final_status(void)
diff --git a/src/map/unit.c b/src/map/unit.c
index 0551baaea..1bae8885a 100644
--- a/src/map/unit.c
+++ b/src/map/unit.c
@@ -133,7 +133,7 @@ int unit_walktoxy_sub(struct block_list *bl)
 	else
 		i = iStatus->get_speed(bl);
 	if( i > 0)
-		ud->walktimer = iTimer->add_timer(iTimer->gettick()+i,unit->walktoxy_timer,bl->id,i);
+		ud->walktimer = timer->add(timer->gettick()+i,unit->walktoxy_timer,bl->id,i);
 	return 1;
 }
 
@@ -213,9 +213,9 @@ int unit_walktoxy_timer(int tid, unsigned int tick, int id, intptr_t data)
 			// mercenary should be warped after being 3 seconds too far from the master [greenbox]
 			if (sd->md->masterteleport_timer == 0)
 			{
-				sd->md->masterteleport_timer = iTimer->gettick();
+				sd->md->masterteleport_timer = timer->gettick();
 			}
-			else if (DIFF_TICK(iTimer->gettick(), sd->md->masterteleport_timer) > 3000)
+			else if (DIFF_TICK(timer->gettick(), sd->md->masterteleport_timer) > 3000)
 			{
 				sd->md->masterteleport_timer = 0;
 				unit->warp( &sd->md->bl, sd->bl.m, sd->bl.x, sd->bl.y, CLR_TELEPORT );
@@ -254,9 +254,9 @@ int unit_walktoxy_timer(int tid, unsigned int tick, int id, intptr_t data)
 			// mercenary should be warped after being 3 seconds too far from the master [greenbox]
 			if (mrd->masterteleport_timer == 0)
 			{
-				mrd->masterteleport_timer = iTimer->gettick();
+				mrd->masterteleport_timer = timer->gettick();
 			}
-			else if (DIFF_TICK(iTimer->gettick(), mrd->masterteleport_timer) > 3000)
+			else if (DIFF_TICK(timer->gettick(), mrd->masterteleport_timer) > 3000)
 			{
 				mrd->masterteleport_timer = 0;
 				unit->warp( bl, mrd->master->bl.id, mrd->master->bl.x, mrd->master->bl.y, CLR_TELEPORT );
@@ -283,7 +283,7 @@ int unit_walktoxy_timer(int tid, unsigned int tick, int id, intptr_t data)
 		i = iStatus->get_speed(bl);
 
 	if(i > 0) {
-		ud->walktimer = iTimer->add_timer(tick+i,unit->walktoxy_timer,id,i);
+		ud->walktimer = timer->add(tick+i,unit->walktoxy_timer,id,i);
 		if( md && DIFF_TICK(tick,md->dmgtick) < 3000 )//not required not damaged recently
 			clif->move(ud);
 	} else if(ud->state.running) {
@@ -361,10 +361,10 @@ int unit_walktoxy( struct block_list *bl, short x, short y, int flag)
 	if ((wpd.path_len > battle_config.max_walk_path) && (bl->type != BL_NPC))
 		return 0;
 
-	if (flag&4 && DIFF_TICK(ud->canmove_tick, iTimer->gettick()) > 0 &&
-		DIFF_TICK(ud->canmove_tick, iTimer->gettick()) < 2000)
+	if (flag&4 && DIFF_TICK(ud->canmove_tick, timer->gettick()) > 0 &&
+		DIFF_TICK(ud->canmove_tick, timer->gettick()) < 2000)
   	{	// Delay walking command. [Skotlex]
-		iTimer->add_timer(ud->canmove_tick+1, unit->delay_walktoxy_timer, bl->id, (x<<16)|(y&0xFFFF));
+		timer->add(ud->canmove_tick+1, unit->delay_walktoxy_timer, bl->id, (x<<16)|(y&0xFFFF));
 		return 1;
 	}
 
@@ -388,7 +388,7 @@ int unit_walktoxy( struct block_list *bl, short x, short y, int flag)
 	}
 
 	if(ud->attacktimer != INVALID_TIMER) {
-		iTimer->delete_timer( ud->attacktimer, unit->attack_timer );
+		timer->delete( ud->attacktimer, unit->attack_timer );
 		ud->attacktimer = INVALID_TIMER;
 	}
 
@@ -412,7 +412,7 @@ int unit_walktobl_sub(int tid, unsigned int tick, int id, intptr_t data)
 	if (ud && ud->walktimer == INVALID_TIMER && ud->target == data)
 	{
 		if (DIFF_TICK(ud->canmove_tick, tick) > 0) //Keep waiting?
-			iTimer->add_timer(ud->canmove_tick+1, unit->walktobl_sub, id, data);
+			timer->add(ud->canmove_tick+1, unit->walktobl_sub, id, data);
 		else if (unit->can_move(bl))
 		{
 			if (unit->walktoxy_sub(bl))
@@ -461,9 +461,9 @@ int unit_walktobl(struct block_list *bl, struct block_list *tbl, int range, int
 		return 1;
 	}
 
-	if(DIFF_TICK(ud->canmove_tick, iTimer->gettick()) > 0)
+	if(DIFF_TICK(ud->canmove_tick, timer->gettick()) > 0)
 	{	//Can't move, wait a bit before invoking the movement.
-		iTimer->add_timer(ud->canmove_tick+1, unit->walktobl_sub, bl->id, ud->target);
+		timer->add(ud->canmove_tick+1, unit->walktobl_sub, bl->id, ud->target);
 		return 1;
 	}
 
@@ -471,7 +471,7 @@ int unit_walktobl(struct block_list *bl, struct block_list *tbl, int range, int
 		return 0;
 
 	if(ud->attacktimer != INVALID_TIMER) {
-		iTimer->delete_timer( ud->attacktimer, unit->attack_timer );
+		timer->delete( ud->attacktimer, unit->attack_timer );
 		ud->attacktimer = INVALID_TIMER;
 	}
 
@@ -595,7 +595,7 @@ int unit_wugdash(struct block_list *bl, struct map_session_data *sd) {
 
 		if( sd ){
 			clif->fixpos(bl);
-			skill->castend_damage_id(bl, &sd->bl, RA_WUGDASH, lv, iTimer->gettick(), SD_LEVEL);
+			skill->castend_damage_id(bl, &sd->bl, RA_WUGDASH, lv, timer->gettick(), SD_LEVEL);
 		}
 		return 0;
 	}
@@ -612,7 +612,7 @@ int unit_wugdash(struct block_list *bl, struct map_session_data *sd) {
 
 		if( sd ){
 			clif->fixpos(bl);
-			skill->castend_damage_id(bl, &sd->bl, RA_WUGDASH, lv, iTimer->gettick(), SD_LEVEL);
+			skill->castend_damage_id(bl, &sd->bl, RA_WUGDASH, lv, timer->gettick(), SD_LEVEL);
 		}
 		return 0;
 	}
@@ -659,7 +659,7 @@ int unit_movepos(struct block_list *bl, short dst_x, short dst_y, int easy, bool
 
 	iMap->foreachinmovearea(clif->outsight, bl, AREA_SIZE, dx, dy, sd?BL_ALL:BL_PC, bl);
 
-	iMap->moveblock(bl, dst_x, dst_y, iTimer->gettick());
+	iMap->moveblock(bl, dst_x, dst_y, timer->gettick());
 
 	ud->walktimer = -2; // arbitrary non-INVALID_TIMER value to make the clif code send walking packets
 	iMap->foreachinmovearea(clif->insight, bl, AREA_SIZE, -dx, -dy, sd?BL_ALL:BL_PC, bl);
@@ -754,7 +754,7 @@ int unit_blown(struct block_list* bl, int dx, int dy, int count, int flag)
 			if(su) {
 				skill->unit_move_unit_group(su->group, bl->m, dx, dy);
 			} else {
-				iMap->moveblock(bl, nx, ny, iTimer->gettick());
+				iMap->moveblock(bl, nx, ny, timer->gettick());
 			}
 
 			iMap->foreachinmovearea(clif->insight, bl, AREA_SIZE, -dx, -dy, bl->type == BL_PC ? BL_ALL : BL_PC, bl);
@@ -847,7 +847,7 @@ int unit_warp(struct block_list *bl,short m,short x,short y,clr_type type)
 
 	iMap->addblock(bl);
 	clif->spawn(bl);
-	skill->unit_move(bl,iTimer->gettick(),1);
+	skill->unit_move(bl,timer->gettick(),1);
 
 	return 0;
 }
@@ -871,13 +871,13 @@ int unit_stop_walking(struct block_list *bl,int type)
 	if(!ud || ud->walktimer == INVALID_TIMER)
 		return 0;
 	//NOTE: We are using timer data after deleting it because we know the
-	//iTimer->delete_timer function does not messes with it. If the function's
+	//timer->delete function does not messes with it. If the function's
 	//behaviour changes in the future, this code could break!
-	td = iTimer->get_timer(ud->walktimer);
-	iTimer->delete_timer(ud->walktimer, unit->walktoxy_timer);
+	td = timer->get(ud->walktimer);
+	timer->delete(ud->walktimer, unit->walktoxy_timer);
 	ud->walktimer = INVALID_TIMER;
 	ud->state.change_walk_target = 0;
-	tick = iTimer->gettick();
+	tick = timer->gettick();
 	if( (type&0x02 && !ud->walkpath.path_pos) //Force moving at least one cell.
 	||  (type&0x04 && td && DIFF_TICK(td->tick, tick) <= td->data/2) //Enough time has passed to cover half-cell
 	) {
@@ -893,7 +893,7 @@ int unit_stop_walking(struct block_list *bl,int type)
 	ud->to_x = bl->x;
 	ud->to_y = bl->y;
 	if(bl->type == BL_PET && type&~0xff)
-		ud->canmove_tick = iTimer->gettick() + (type>>8);
+		ud->canmove_tick = timer->gettick() + (type>>8);
 
 	//Readded, the check in unit_set_walkdelay means dmg during running won't fall through to this place in code [Kevin]
 	if (ud->state.running) {
@@ -939,7 +939,7 @@ int unit_can_move(struct block_list *bl) {
 	if (ud->skilltimer != INVALID_TIMER && ud->skill_id != LG_EXEEDBREAK && (!sd || !pc->checkskill(sd, SA_FREECAST) || skill->get_inf2(ud->skill_id)&INF2_GUILD_SKILL))
 		return 0; // prevent moving while casting
 
-	if (DIFF_TICK(ud->canmove_tick, iTimer->gettick()) > 0)
+	if (DIFF_TICK(ud->canmove_tick, timer->gettick()) > 0)
 		return 0;
 
 	if (sd && (
@@ -1061,13 +1061,13 @@ int unit_set_walkdelay(struct block_list *bl, unsigned int tick, int delay, int
 			//Resume running after can move again [Kevin]
 			if(ud->state.running)
 			{
-				iTimer->add_timer(ud->canmove_tick, unit->resume_running, bl->id, (intptr_t)ud);
+				timer->add(ud->canmove_tick, unit->resume_running, bl->id, (intptr_t)ud);
 			}
 			else
 			{
 				unit->stop_walking(bl,2|4);
 				if(ud->target)
-					iTimer->add_timer(ud->canmove_tick+1, unit->walktobl_sub, bl->id, ud->target);
+					timer->add(ud->canmove_tick+1, unit->walktobl_sub, bl->id, ud->target);
 			}
 		}
 	}
@@ -1081,7 +1081,7 @@ int unit_skilluse_id2(struct block_list *src, int target_id, uint16 skill_id, ui
 	struct status_change *sc;
 	struct map_session_data *sd = NULL;
 	struct block_list * target = NULL;
-	unsigned int tick = iTimer->gettick();
+	unsigned int tick = timer->gettick();
 	int temp = 0, range;
 
 	nullpo_ret(src);
@@ -1421,7 +1421,7 @@ int unit_skilluse_id2(struct block_list *src, int target_id, uint16 skill_id, ui
 
 
 	if( casttime > 0 ) {
-		ud->skilltimer = iTimer->add_timer( tick+casttime, skill->castend_id, src->id, 0 );
+		ud->skilltimer = timer->add( tick+casttime, skill->castend_id, src->id, 0 );
 		if( sd && (pc->checkskill(sd,SA_FREECAST) > 0 || skill_id == LG_EXEEDBREAK) )
 			status_calc_bl(&sd->bl, SCB_SPEED);
 	} else
@@ -1445,7 +1445,7 @@ int unit_skilluse_pos2( struct block_list *src, short skill_x, short skill_y, ui
 	struct unit_data        *ud = NULL;
 	struct status_change *sc;
 	struct block_list    bl;
-	unsigned int tick = iTimer->gettick();
+	unsigned int tick = timer->gettick();
 	int range;
 
 	nullpo_ret(src);
@@ -1556,7 +1556,7 @@ int unit_skilluse_pos2( struct block_list *src, short skill_x, short skill_y, ui
 	// in official this is triggered even if no cast time.
 	clif->skillcasting(src, src->id, 0, skill_x, skill_y, skill_id, skill->get_ele(skill_id, skill_lv), casttime);
 	if( casttime > 0 ) {
-		ud->skilltimer = iTimer->add_timer( tick+casttime, skill->castend_pos, src->id, 0 );
+		ud->skilltimer = timer->add( tick+casttime, skill->castend_pos, src->id, 0 );
 		if( (sd && pc->checkskill(sd,SA_FREECAST) > 0) || skill_id == LG_EXEEDBREAK)
 			status_calc_bl(&sd->bl, SCB_SPEED);	
 	} else {
@@ -1595,7 +1595,7 @@ int unit_stop_attack(struct block_list *bl)
 	if(!ud || ud->attacktimer == INVALID_TIMER)
 		return 0;
 
-	iTimer->delete_timer( ud->attacktimer, unit->attack_timer );
+	timer->delete( ud->attacktimer, unit->attack_timer );
 	ud->attacktimer = INVALID_TIMER;
 	unit->set_target(ud, 0);
 	return 0;
@@ -1611,7 +1611,7 @@ int unit_unattackable(struct block_list *bl)
 	}
 
 	if(bl->type == BL_MOB)
-		mob->unlocktarget((struct mob_data*)bl, iTimer->gettick()) ;
+		mob->unlocktarget((struct mob_data*)bl, timer->gettick()) ;
 	else if(bl->type == BL_PET)
 		pet->unlocktarget((struct pet_data*)bl);
 	return 0;
@@ -1663,11 +1663,11 @@ int unit_attack(struct block_list *src,int target_id,int continuous)
 	if(src->type == BL_MOB)
 		((TBL_MOB*)src)->state.skillstate = ((TBL_MOB*)src)->state.aggressive?MSS_ANGRY:MSS_BERSERK;
 
-	if(DIFF_TICK(ud->attackabletime, iTimer->gettick()) > 0)
+	if(DIFF_TICK(ud->attackabletime, timer->gettick()) > 0)
 		//Do attack next time it is possible. [Skotlex]
-		ud->attacktimer=iTimer->add_timer(ud->attackabletime,unit->attack_timer,src->id,0);
+		ud->attacktimer=timer->add(ud->attackabletime,unit->attack_timer,src->id,0);
 	else //Attack NOW.
-		unit->attack_timer(INVALID_TIMER, iTimer->gettick(), src->id, 0);
+		unit->attack_timer(INVALID_TIMER, timer->gettick(), src->id, 0);
 
 	return 0;
 }
@@ -1684,13 +1684,13 @@ int unit_cancel_combo(struct block_list *bl)
 	ud = unit->bl2ud(bl);
 	nullpo_ret(ud);
 
-	ud->attackabletime = iTimer->gettick() + status_get_amotion(bl);
+	ud->attackabletime = timer->gettick() + status_get_amotion(bl);
 
 	if (ud->attacktimer == INVALID_TIMER)
 		return 1; //Nothing more to do.
 
-	iTimer->delete_timer(ud->attacktimer, unit->attack_timer);
-	ud->attacktimer=iTimer->add_timer(ud->attackabletime,unit->attack_timer,bl->id,0);
+	timer->delete(ud->attacktimer, unit->attack_timer);
+	ud->attacktimer=timer->add(ud->attackabletime,unit->attack_timer,bl->id,0);
 	return 1;
 }
 /*==========================================
@@ -1857,7 +1857,7 @@ int unit_attack_timer_sub(struct block_list* src, int tid, unsigned int tick)
 		if( ud->state.attack_continue ) {
 			if( DIFF_TICK(ud->canact_tick, ud->attackabletime) > 0 )
 				ud->attackabletime = ud->canact_tick;
-			ud->attacktimer=iTimer->add_timer(ud->attackabletime,unit->attack_timer,src->id,0);
+			ud->attacktimer=timer->add(ud->attackabletime,unit->attack_timer,src->id,0);
 		}
 		return 1;
 	}
@@ -1927,7 +1927,7 @@ int unit_attack_timer_sub(struct block_list* src, int tid, unsigned int tick)
 	if(ud->state.attack_continue) {
 		if( src->type == BL_PC )
 			((TBL_PC*)src)->idletime = last_tick;
-		ud->attacktimer = iTimer->add_timer(ud->attackabletime,unit->attack_timer,src->id,0);
+		ud->attacktimer = timer->add(ud->attackabletime,unit->attack_timer,src->id,0);
 	}
 
 	return 1;
@@ -1951,7 +1951,7 @@ int unit_skillcastcancel(struct block_list *bl,int type)
 {
 	struct map_session_data *sd = NULL;
 	struct unit_data *ud = unit->bl2ud( bl);
-	unsigned int tick=iTimer->gettick();
+	unsigned int tick=timer->gettick();
 	int ret=0, skill_id;
 
 	nullpo_ret(bl);
@@ -1978,9 +1978,9 @@ int unit_skillcastcancel(struct block_list *bl,int type)
 		skill_id = ud->skill_id;
 
 	if (skill->get_inf(skill_id) & INF_GROUND_SKILL)
-		ret = iTimer->delete_timer( ud->skilltimer, skill->castend_pos );
+		ret = timer->delete( ud->skilltimer, skill->castend_pos );
 	else
-		ret = iTimer->delete_timer( ud->skilltimer, skill->castend_id );
+		ret = timer->delete( ud->skilltimer, skill->castend_id );
 	if( ret < 0 )
 		ShowError("delete timer error : skill_id : %d\n",ret);
 
@@ -2015,7 +2015,7 @@ void unit_dataset(struct block_list *bl) {
 	ud->attacktimer    = INVALID_TIMER;
 	ud->attackabletime =
 	ud->canact_tick    =
-	ud->canmove_tick   = iTimer->gettick();
+	ud->canmove_tick   = timer->gettick();
 }
 
 /*==========================================
@@ -2090,7 +2090,7 @@ int unit_remove_map(struct block_list *bl, clr_type clrtype, const char* file, i
 		unit->skillcastcancel(bl,0);
 
 // Do not reset can-act delay. [Skotlex]
-	ud->attackabletime = ud->canmove_tick /*= ud->canact_tick*/ = iTimer->gettick();
+	ud->attackabletime = ud->canmove_tick /*= ud->canact_tick*/ = timer->gettick();
 	if(sc && sc->count ) { //map-change/warp dispells.
 		status_change_end(bl, SC_BLADESTOP, INVALID_TIMER);
 		status_change_end(bl, SC_BASILICA, INVALID_TIMER);
@@ -2126,7 +2126,7 @@ int unit_remove_map(struct block_list *bl, clr_type clrtype, const char* file, i
 	}
 
 	if (bl->type&(BL_CHAR|BL_PET)) {
-		skill->unit_move(bl,iTimer->gettick(),4);
+		skill->unit_move(bl,timer->gettick(),4);
 		skill->cleartimerskill(bl);
 	}
 
@@ -2172,7 +2172,7 @@ int unit_remove_map(struct block_list *bl, clr_type clrtype, const char* file, i
 			sd->adopt_invite = 0;
 
 			if(sd->pvp_timer != INVALID_TIMER) {
-				iTimer->delete_timer(sd->pvp_timer,pc->calc_pvprank_timer);
+				timer->delete(sd->pvp_timer,pc->calc_pvprank_timer);
 				sd->pvp_timer = INVALID_TIMER;
 				sd->pvp_rank = 0;
 			}
@@ -2433,9 +2433,9 @@ int unit_free(struct block_list *bl, clr_type clrtype)
 			{
 				if (pd->s_skill->timer != INVALID_TIMER) {
 					if (pd->s_skill->id)
-						iTimer->delete_timer(pd->s_skill->timer, pet->skill_support_timer);
+						timer->delete(pd->s_skill->timer, pet->skill_support_timer);
 					else
-						iTimer->delete_timer(pd->s_skill->timer, pet->heal_timer);
+						timer->delete(pd->s_skill->timer, pet->heal_timer);
 				}
 				aFree(pd->s_skill);
 				pd->s_skill = NULL;
@@ -2443,14 +2443,14 @@ int unit_free(struct block_list *bl, clr_type clrtype)
 			if( pd->recovery )
 			{
 				if(pd->recovery->timer != INVALID_TIMER)
-					iTimer->delete_timer(pd->recovery->timer, pet->recovery_timer);
+					timer->delete(pd->recovery->timer, pet->recovery_timer);
 				aFree(pd->recovery);
 				pd->recovery = NULL;
 			}
 			if( pd->bonus )
 			{
 				if (pd->bonus->timer != INVALID_TIMER)
-					iTimer->delete_timer(pd->bonus->timer, pet->skill_bonus_timer);
+					timer->delete(pd->bonus->timer, pet->skill_bonus_timer);
 				aFree(pd->bonus);
 				pd->bonus = NULL;
 			}
@@ -2478,12 +2478,12 @@ int unit_free(struct block_list *bl, clr_type clrtype)
 			struct mob_data *md = (struct mob_data*)bl;
 			if( md->spawn_timer != INVALID_TIMER )
 			{
-				iTimer->delete_timer(md->spawn_timer,mob->delayspawn);
+				timer->delete(md->spawn_timer,mob->delayspawn);
 				md->spawn_timer = INVALID_TIMER;
 			}
 			if( md->deletetimer != INVALID_TIMER )
 			{
-				iTimer->delete_timer(md->deletetimer,mob->timer_delete);
+				timer->delete(md->deletetimer,mob->timer_delete);
 				md->deletetimer = INVALID_TIMER;
 			}
 			if( md->lootitem )
@@ -2593,10 +2593,10 @@ int unit_free(struct block_list *bl, clr_type clrtype)
 }
 
 int do_init_unit(void) {
-	iTimer->add_timer_func_list(unit->attack_timer,  "unit_attack_timer");
-	iTimer->add_timer_func_list(unit->walktoxy_timer,"unit_walktoxy_timer");
-	iTimer->add_timer_func_list(unit->walktobl_sub, "unit_walktobl_sub");
-	iTimer->add_timer_func_list(unit->delay_walktoxy_timer,"unit_delay_walktoxy_timer");
+	timer->add_func_list(unit->attack_timer,  "unit_attack_timer");
+	timer->add_func_list(unit->walktoxy_timer,"unit_walktoxy_timer");
+	timer->add_func_list(unit->walktobl_sub, "unit_walktobl_sub");
+	timer->add_func_list(unit->delay_walktoxy_timer,"unit_delay_walktoxy_timer");
 	return 0;
 }