Refactor code using directions to use enum unit_dir

This removes a lot of duplicated code, especially related to people not using the arrays dirx and diry.
Assertions for whenever these arrays are used have been added as well, to ensure valid index range.
Some trailing white space has been removed as well.

11 files changed, 207 insertions, 205 deletions

diff --git a/src/map/atcommand.c b/src/map/atcommand.c
index 707522423..410cd7af7 100644
--- a/src/map/atcommand.c
+++ b/src/map/atcommand.c
@@ -4123,16 +4123,36 @@ ACMD(mapinfo)
 			for (i = 0; i < map->list[m_id].npc_num;) {
 				struct npc_data *nd = map->list[m_id].npc[i];
 				switch(nd->dir) {
-					case 0:  strcpy(direction, msg_fd(fd,1101)); break; // North
-					case 1:  strcpy(direction, msg_fd(fd,1102)); break; // North West
-					case 2:  strcpy(direction, msg_fd(fd,1103)); break; // West
-					case 3:  strcpy(direction, msg_fd(fd,1104)); break; // South West
-					case 4:  strcpy(direction, msg_fd(fd,1105)); break; // South
-					case 5:  strcpy(direction, msg_fd(fd,1106)); break; // South East
-					case 6:  strcpy(direction, msg_fd(fd,1107)); break; // East
-					case 7:  strcpy(direction, msg_fd(fd,1108)); break; // North East
-					case 9:  strcpy(direction, msg_fd(fd,1109)); break; // North
-					default: strcpy(direction, msg_fd(fd,1110)); break; // Unknown
+				case UNIT_DIR_NORTH:
+					strcpy(direction, msg_fd(fd, 1101)); // North
+					break;
+				case UNIT_DIR_NORTHWEST:
+					strcpy(direction, msg_fd(fd, 1102)); // North West
+					break;
+				case UNIT_DIR_WEST:
+					strcpy(direction, msg_fd(fd, 1103)); // West
+					break;
+				case UNIT_DIR_SOUTHWEST:
+					strcpy(direction, msg_fd(fd, 1104)); // South West
+					break;
+				case UNIT_DIR_SOUTH:
+					strcpy(direction, msg_fd(fd, 1105)); // South
+					break;
+				case UNIT_DIR_SOUTHEAST:
+					strcpy(direction, msg_fd(fd, 1106)); // South East
+					break;
+				case UNIT_DIR_EAST:
+					strcpy(direction, msg_fd(fd, 1107)); // East
+					break;
+				case UNIT_DIR_NORTHEAST:
+					strcpy(direction, msg_fd(fd, 1108)); // North East
+					break;
+				case 9: // is this actually used? [skyleo]
+					strcpy(direction, msg_fd(fd, 1109)); // North
+					break;
+				default:
+					strcpy(direction, msg_fd(fd, 1110)); // Unknown
+					break;
 				}
 				if(strcmp(nd->name,nd->exname) == 0)
 					safesnprintf(atcmd_output, sizeof(atcmd_output), msg_fd(fd,1111), // NPC %d: %s | Direction: %s | Sprite: %d | Location: %d %d
@@ -6899,7 +6919,7 @@ ACMD(identify)
 			}
 		}
 	}
-	
+
 	if (num == 0)
 		clif->message(fd,msg_fd(fd,1238)); // There are no items to appraise.
 	else if (!identifyall)
diff --git a/src/map/battle.c b/src/map/battle.c
index c057ad81a..24e58cc09 100644
--- a/src/map/battle.c
+++ b/src/map/battle.c
@@ -3231,12 +3231,11 @@ static int64 battle_calc_damage(struct block_list *src, struct block_list *bl, s
 		if (!damage) return 0;
 
 		if( (sce = sc->data[SC_LIGHTNINGWALK]) && flag&BF_LONG && rnd()%100 < sce->val1 ) {
-			int dx[8]={0,-1,-1,-1,0,1,1,1};
-			int dy[8]={1,1,0,-1,-1,-1,0,1};
-			uint8 dir = map->calc_dir(bl, src->x, src->y);
-			if( unit->movepos(bl, src->x-dx[dir], src->y-dy[dir], 1, 1) ) {
-				clif->slide(bl,src->x-dx[dir],src->y-dy[dir]);
-				unit->setdir(bl, dir);
+			enum unit_dir dir = map->calc_dir(bl, src->x, src->y);
+			Assert_ret(dir >= UNIT_DIR_FIRST && dir < UNIT_DIR_MAX);
+			if (unit->movepos(bl, src->x - dirx[dir], src->y - diry[dir], 1, 1)) {
+				clif->slide(bl, src->x - dirx[dir], src->y - diry[dir]);
+				unit->set_dir(bl, dir);
 			}
 			d->dmg_lv = ATK_DEF;
 			status_change_end(bl, SC_LIGHTNINGWALK, INVALID_TIMER);
@@ -5858,10 +5857,10 @@ static void battle_reflect_damage(struct block_list *target, struct block_list *
 		if( wd->flag & BF_SHORT ) {
 			if( !is_boss(src) ) {
 				if( sc->data[SC_DEATHBOUND] && skill_id != WS_CARTTERMINATION ) {
-					uint8 dir = map->calc_dir(target,src->x,src->y),
-					t_dir = unit->getdir(target);
+					enum unit_dir dir = map->calc_dir(target, src->x, src->y);
+					enum unit_dir t_dir = unit->getdir(target);
 
-					if( !map->check_dir(dir,t_dir) ) {
+					if (map->check_dir(dir, t_dir) == 0) {
 						int64 rd1 = damage * sc->data[SC_DEATHBOUND]->val2 / 100; // Amplify damage.
 
 						trdamage += rdamage = rd1 - (damage = rd1 * 30 / 100); // not normalized as intended.
@@ -6229,10 +6228,10 @@ static enum damage_lv battle_weapon_attack(struct block_list *src, struct block_
 			status_change_end(src, SC_CLOAKINGEXCEED, INVALID_TIMER);
 	}
 	if( tsc && tsc->data[SC_AUTOCOUNTER] && status->check_skilluse(target, src, KN_AUTOCOUNTER, 1) ) {
-		uint8 dir = map->calc_dir(target,src->x,src->y);
-		int t_dir = unit->getdir(target);
+		enum unit_dir dir = map->calc_dir(target, src->x, src->y),
+		            t_dir = unit->getdir(target);
 		int dist = distance_bl(src, target);
-		if(dist <= 0 || (!map->check_dir(dir,t_dir) && dist <= tstatus->rhw.range+1)) {
+		if(dist <= 0 || (map->check_dir(dir, t_dir) == 0 && dist <= tstatus->rhw.range + 1)) {
 			uint16 skill_lv = tsc->data[SC_AUTOCOUNTER]->val1;
 			clif->skillcastcancel(target); //Remove the casting bar. [Skotlex]
 			clif->damage(src, target, sstatus->amotion, 1, 0, 1, BDT_NORMAL, 0); //Display MISS.
diff --git a/src/map/clif.c b/src/map/clif.c
index 3022d7f69..a0ffeac32 100644
--- a/src/map/clif.c
+++ b/src/map/clif.c
@@ -11348,15 +11348,7 @@ static void clif_parse_MapMove(int fd, struct map_session_data *sd)
 ///     0 = straight
 ///     1 = turned CW
 ///     2 = turned CCW
-/// dir:
-///     0 = north
-///     1 = northwest
-///     2 = west
-///     3 = southwest
-///     4 = south
-///     5 = southeast
-///     6 = east
-///     7 = northeast
+/// dir: @see enum unit_dir
 static void clif_changed_dir(struct block_list *bl, enum send_target target)
 {
 	unsigned char buf[64];
diff --git a/src/map/map.c b/src/map/map.c
index 9637609ec..e0ab2b08d 100644
--- a/src/map/map.c
+++ b/src/map/map.c
@@ -1670,7 +1670,7 @@ static int map_search_freecell(struct block_list *src, int16 m, int16 *x, int16
  *------------------------------------------*/
 static bool map_closest_freecell(int16 m, const struct block_list *bl, int16 *x, int16 *y, int type, int flag)
 {
-	uint8 dir = 6;
+	enum unit_dir dir = UNIT_DIR_EAST;
 	int16 tx;
 	int16 ty;
 	int costrange = 10;
@@ -1689,7 +1689,7 @@ static bool map_closest_freecell(int16 m, const struct block_list *bl, int16 *x,
 		short dy = diry[dir];
 
 		//Linear search
-		if(dir%2 == 0 && costrange%MOVE_COST == 0) {
+		if (!unit_is_diagonal_dir(dir) && (costrange % MOVE_COST) == 0) {
 			tx = *x+dx*(costrange/MOVE_COST);
 			ty = *y+dy*(costrange/MOVE_COST);
 			if (!map->count_oncell(m, tx, ty, type, flag) && map->getcell(m, bl, tx, ty, CELL_CHKPASS)) {
@@ -1699,7 +1699,7 @@ static bool map_closest_freecell(int16 m, const struct block_list *bl, int16 *x,
 			}
 		}
 		//Full diagonal search
-		else if(dir%2 == 1 && costrange%MOVE_DIAGONAL_COST == 0) {
+		else if (unit_is_diagonal_dir(dir) && (costrange % MOVE_DIAGONAL_COST) == 0) {
 			tx = *x+dx*(costrange/MOVE_DIAGONAL_COST);
 			ty = *y+dy*(costrange/MOVE_DIAGONAL_COST);
 			if (!map->count_oncell(m, tx, ty, type, flag) && map->getcell(m, bl, tx, ty, CELL_CHKPASS)) {
@@ -1709,16 +1709,24 @@ static bool map_closest_freecell(int16 m, const struct block_list *bl, int16 *x,
 			}
 		}
 		//One cell diagonal, rest linear (TODO: Find a better algorithm for this)
-		else if(dir%2 == 1 && costrange%MOVE_COST == 4) {
-			tx = *x+dx*((dir%4==3)?(costrange/MOVE_COST):1);
-			ty = *y+dy*((dir%4==1)?(costrange/MOVE_COST):1);
+		else if (unit_is_diagonal_dir(dir) && (costrange % MOVE_COST) == 4) {
+			tx = *x + dx;
+			ty = *y + dy;
+			if (unit_is_dir_or_opposite(dir, UNIT_DIR_SOUTHWEST))
+				tx *= costrange / MOVE_COST;
+			if (unit_is_dir_or_opposite(dir, UNIT_DIR_NORTHWEST))
+				ty *= costrange / MOVE_COST;
 			if (!map->count_oncell(m, tx, ty, type, flag) && map->getcell(m, bl, tx, ty, CELL_CHKPASS)) {
 				*x = tx;
 				*y = ty;
 				return true;
 			}
-			tx = *x+dx*((dir%4==1)?(costrange/MOVE_COST):1);
-			ty = *y+dy*((dir%4==3)?(costrange/MOVE_COST):1);
+			tx = *x + dx;
+			ty = *y + dy;
+			if (unit_is_dir_or_opposite(dir, UNIT_DIR_NORTHWEST))
+				tx *= costrange / MOVE_COST;
+			if (unit_is_dir_or_opposite(dir, UNIT_DIR_SOUTHWEST))
+				ty *= costrange / MOVE_COST;
 			if (!map->count_oncell(m, tx, ty, type, flag) && map->getcell(m, bl, tx, ty, CELL_CHKPASS)) {
 				*x = tx;
 				*y = ty;
@@ -1727,17 +1735,17 @@ static bool map_closest_freecell(int16 m, const struct block_list *bl, int16 *x,
 		}
 
 		//Get next direction
-		if (dir == 5) {
+		if (dir == UNIT_DIR_SOUTHEAST) {
 			//Diagonal search complete, repeat with higher cost range
 			if(costrange == 14) costrange += 6;
 			else if(costrange == 28 || costrange >= 38) costrange += 2;
 			else costrange += 4;
-			dir = 6;
-		} else if (dir == 4) {
+			dir = UNIT_DIR_EAST;
+		} else if (dir == UNIT_DIR_SOUTH) {
 			//Linear search complete, switch to diagonal directions
-			dir = 7;
+			dir = UNIT_DIR_NORTHEAST;
 		} else {
-			dir = (dir+2)%8;
+			dir = unit_get_ccw90_dir(dir);
 		}
 	}
 
@@ -2936,11 +2944,11 @@ static int map_random_dir(struct block_list *bl, int16 *x, int16 *y)
 	if (dist < 1) dist =1;
 
 	do {
-		int j = 1 + 2*(rnd()%4); //Pick a random diagonal direction
+		enum unit_dir dir = unit_get_rnd_diagonal_dir();
 		short segment = 1+(rnd()%dist); //Pick a random interval from the whole vector in that direction
-		xi = bl->x + segment*dirx[j];
+		xi = bl->x + segment * dirx[dir];
 		segment = (short)sqrt((float)(dist2 - segment*segment)); //The complement of the previously picked segment
-		yi = bl->y + segment*diry[j];
+		yi = bl->y + segment * diry[dir];
 	} while ((map->getcell(bl->m, bl, xi, yi, CELL_CHKNOPASS) || !path->search(NULL, bl, bl->m, bl->x, bl->y, xi, yi, 1, CELL_CHKNOREACH))
 	       && (++i)<100);
 
diff --git a/src/map/npc.c b/src/map/npc.c
index e66888a74..2ac99948b 100644
--- a/src/map/npc.c
+++ b/src/map/npc.c
@@ -3391,7 +3391,7 @@ static bool npc_viewisid(const char *viewid)
  * @param class_  The NPC view class.
  * @return A pointer to the created NPC data (ownership passed to the caller).
  */
-static struct npc_data *npc_create_npc(enum npc_subtype subtype, int m, int x, int y, uint8 dir, int class_)
+static struct npc_data *npc_create_npc(enum npc_subtype subtype, int m, int x, int y, enum unit_dir dir, int class_)
 {
 	struct npc_data *nd;
 
diff --git a/src/map/npc.h b/src/map/npc.h
index 65c9796d9..1585a2bc8 100644
--- a/src/map/npc.h
+++ b/src/map/npc.h
@@ -95,7 +95,7 @@ struct npc_data {
 	int chat_id;
 	int touching_id;
 	int64 next_walktime;
-	uint8 dir;
+	enum unit_dir dir;
 	uint8 area_size;
 
 	int clan_id;
@@ -281,7 +281,7 @@ struct npc_interface {
 	void (*parsename) (struct npc_data *nd, const char *name, const char *start, const char *buffer, const char *filepath);
 	int (*parseview) (const char *w4, const char *start, const char *buffer, const char *filepath);
 	bool (*viewisid) (const char *viewid);
-	struct npc_data *(*create_npc) (enum npc_subtype subtype, int m, int x, int y, uint8 dir, int class_);
+	struct npc_data *(*create_npc) (enum npc_subtype subtype, int m, int x, int y, enum unit_dir dir, int class_);
 	struct npc_data* (*add_warp) (char *name, short from_mapid, short from_x, short from_y, short xs, short ys, unsigned short to_mapindex, short to_x, short to_y);
 	const char *(*parse_warp) (const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval);
 	const char *(*parse_shop) (const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval);
diff --git a/src/map/script.c b/src/map/script.c
index 0e30708d9..28d06a8f1 100644
--- a/src/map/script.c
+++ b/src/map/script.c
@@ -19727,7 +19727,7 @@ static BUILDIN(setunitdata)
 			clif->changelook(bl, LOOK_WEAPON, val);
 			break;
 		case UDT_LOOKDIR:
-			unit->setdir(bl, (uint8) val);
+			unit->setdir(bl, (enum unit_dir) val);
 			break;
 		case UDT_CANMOVETICK:
 			md->ud.canmove_tick = val;
@@ -19859,7 +19859,7 @@ static BUILDIN(setunitdata)
 			status->calc_misc(bl, &hd->base_status, hd->homunculus.level);
 			break;
 		case UDT_LOOKDIR:
-			unit->setdir(bl, (unsigned char) val);
+			unit->setdir(bl, (enum unit_dir) val);
 			break;
 		case UDT_CANMOVETICK:
 			hd->ud.canmove_tick = val;
@@ -19998,7 +19998,7 @@ static BUILDIN(setunitdata)
 			status->calc_misc(bl, &pd->status, pd->pet.level);
 			break;
 		case UDT_LOOKDIR:
-			unit->setdir(bl, (unsigned char) val);
+			unit->setdir(bl, (enum unit_dir) val);
 			break;
 		case UDT_CANMOVETICK:
 			pd->ud.canmove_tick = val;
@@ -20131,7 +20131,7 @@ static BUILDIN(setunitdata)
 			status->calc_misc(bl, &mc->base_status, mc->db->lv);
 			break;
 		case UDT_LOOKDIR:
-			unit->setdir(bl, (unsigned char) val);
+			unit->setdir(bl, (enum unit_dir) val);
 			break;
 		case UDT_CANMOVETICK:
 			mc->ud.canmove_tick = val;
@@ -20265,7 +20265,7 @@ static BUILDIN(setunitdata)
 			status->calc_misc(bl, &ed->base_status, ed->db->lv);
 			break;
 		case UDT_LOOKDIR:
-			unit->setdir(bl, (unsigned char) val);
+			unit->setdir(bl, (enum unit_dir) val);
 			break;
 		case UDT_CANMOVETICK:
 			ed->ud.canmove_tick = val;
@@ -20397,7 +20397,7 @@ static BUILDIN(setunitdata)
 			status->calc_misc(bl, &nd->status, nd->level);
 			break;
 		case UDT_LOOKDIR:
-			unit->setdir(bl, (unsigned char) val);
+			unit->setdir(bl, (enum unit_dir) val);
 			break;
 		case UDT_STR:
 			nd->status.str = (unsigned short) val;
@@ -23250,7 +23250,6 @@ static BUILDIN(progressbar_unit)
 }
 static BUILDIN(pushpc)
 {
-	uint8 dir;
 	int cells, dx, dy;
 	struct map_session_data* sd;
 
@@ -23259,14 +23258,14 @@ static BUILDIN(pushpc)
 		return true;
 	}
 
-	dir = script_getnum(st,2);
-	cells     = script_getnum(st,3);
+	enum unit_dir dir = script_getnum(st, 2);
+	cells = script_getnum(st,3);
 
-	if (dir > 7) {
+	if (dir >= UNIT_DIR_MAX) {
 		ShowWarning("buildin_pushpc: Invalid direction %d specified.\n", dir);
 		script->reportsrc(st);
 
-		dir%= 8;  // trim spin-over
+		dir %= UNIT_DIR_MAX;  // trim spin-over
 	}
 
 	if(!cells)
@@ -23275,10 +23274,11 @@ static BUILDIN(pushpc)
 	}
 	else if(cells<0)
 	{// pushing backwards
-		dir = (dir+4)%8;  // turn around
-		cells     = -cells;
+		dir   = unit_get_opposite_dir(dir);
+		cells = -cells;
 	}
 
+	Assert_retr(false, dir >= UNIT_DIR_FIRST && dir < UNIT_DIR_MAX);
 	dx = dirx[dir];
 	dy = diry[dir];
 
diff --git a/src/map/skill.c b/src/map/skill.c
index a8dbefbd7..668c1849c 100644
--- a/src/map/skill.c
+++ b/src/map/skill.c
@@ -1180,7 +1180,6 @@ static int skillnotok_mercenary(uint16 skill_id, struct mercenary_data *md)
 static struct s_skill_unit_layout *skill_get_unit_layout(uint16 skill_id, uint16 skill_lv, struct block_list *src, int x, int y)
 {
 	int pos = skill->get_unit_layout_type(skill_id,skill_lv);
-	uint8 dir;
 
 	nullpo_retr(&skill->dbs->unit_layout[0], src);
 	if (pos < -1 || pos >= MAX_SKILL_UNIT_LAYOUT) {
@@ -1191,7 +1190,9 @@ static struct s_skill_unit_layout *skill_get_unit_layout(uint16 skill_id, uint16
 	if (pos != -1) // simple single-definition layout
 		return &skill->dbs->unit_layout[pos];
 
-	dir = (src->x == x && src->y == y) ? 6 : map->calc_dir(src,x,y); // 6 - default aegis direction
+	enum unit_dir dir = UNIT_DIR_EAST; // default aegis direction
+	if (src->x != x || src->y != y)
+		dir = map->calc_dir(src, x, y);
 
 	if (skill_id == MG_FIREWALL)
 		return &skill->dbs->unit_layout [skill->firewall_unit_pos + dir];
@@ -2626,11 +2627,11 @@ static int skill_strip_equip(struct block_list *bl, unsigned short where, int ra
 /*=========================================================================
  * Used to knock back players, monsters, traps, etc
  * 'count' is the number of squares to knock back
- * 'direction' indicates the way OPPOSITE to the knockback direction (or -1 for default behavior)
+ * 'direction' indicates the way OPPOSITE to the knockback direction (or UNIT_DIR_UNDEFINED for default behavior)
  * if 'flag&0x1', position update packets must not be sent.
  * if 'flag&0x2', skill blown ignores players' special_state.no_knockback
  */
-static int skill_blown(struct block_list *src, struct block_list *target, int count, int8 dir, int flag)
+static int skill_blown(struct block_list *src, struct block_list *target, int count, enum unit_dir dir, int flag)
 {
 	int dx = 0, dy = 0;
 	struct status_change *tsc = status->get_sc(target);
@@ -2672,10 +2673,10 @@ static int skill_blown(struct block_list *src, struct block_list *target, int co
 			break;
 	}
 
-	if (dir == -1) // <optimized>: do the computation here instead of outside
+	if (dir == UNIT_DIR_UNDEFINED) // <optimized>: do the computation here instead of outside
 		dir = map->calc_dir(target, src->x, src->y); // direction from src to target, reversed
 
-	if (dir >= 0 && dir < 8) {
+	if (dir >= UNIT_DIR_FIRST && dir < UNIT_DIR_MAX) {
 		// take the reversed 'direction' and reverse it
 		dx = -dirx[dir];
 		dy = -diry[dir];
@@ -3297,7 +3298,7 @@ static int skill_attack(int attack_type, struct block_list *src, struct block_li
 	//Only knockback if it's still alive, otherwise a "ghost" is left behind. [Skotlex]
 	//Reflected spells do not bounce back (bl == dsrc since it only happens for direct skills)
 	if (dmg.blewcount > 0 && bl!=dsrc && !status->isdead(bl)) {
-		int8 dir = -1; // default
+		enum unit_dir dir = UNIT_DIR_UNDEFINED; // default
 		switch(skill_id) {//direction
 			case MG_FIREWALL:
 			case PR_SANCTUARY:
@@ -3310,16 +3311,16 @@ static int skill_attack(int attack_type, struct block_list *src, struct block_li
 			// This ensures the storm randomly pushes instead of exactly a cell backwards per official mechanics.
 			case WZ_STORMGUST:
 				if(!battle_config.stormgust_knockback)
-					dir = rnd()%8;
+					dir = rnd() % UNIT_DIR_MAX;
 				break;
 			case WL_CRIMSONROCK:
 				dir = map->calc_dir(bl,skill->area_temp[4],skill->area_temp[5]);
 				break;
 			case MC_CARTREVOLUTION:
-				dir = 6; // Official servers push target to the West
+				dir = UNIT_DIR_EAST; // Official servers push target to the West
 				break;
 			default:
-				dir = skill->attack_dir_unknown(&attack_type, src, dsrc, bl, &skill_id, &skill_lv, &tick, &flag);
+				dir = UNIT_DIR_UNDEFINED;
 				break;
 
 		}
@@ -3337,8 +3338,9 @@ static int skill_attack(int attack_type, struct block_list *src, struct block_li
 			case SR_KNUCKLEARROW:
 				if( skill->blown(dsrc,bl,dmg.blewcount,dir,0) && !(flag&4) ) {
 					short dir_x, dir_y;
-					dir_x = dirx[(dir+4)%8];
-					dir_y = diry[(dir+4)%8];
+					Assert_ret(dir >= UNIT_DIR_FIRST && dir < UNIT_DIR_MAX);
+					dir_x = dirx[unit_get_opposite_dir(dir)];
+					dir_y = diry[unit_get_opposite_dir(dir)];
 					if (map->getcell(bl->m, bl, bl->x + dir_x, bl->y + dir_y, CELL_CHKNOPASS) != 0)
 						skill->addtimerskill(src, tick + 300 * ((flag&2) ? 1 : 2), bl->id, 0, 0, skill_id, skill_lv, BF_WEAPON, flag|4);
 				}
@@ -3496,12 +3498,9 @@ static int skill_attack_copy_unknown(int *attack_type, struct block_list *src, s
 	return *skill_id;
 }
 
-static int skill_attack_dir_unknown(int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag)
-{
-	return -1;
-}
-
-static void skill_attack_blow_unknown(int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type, struct Damage *dmg, int64 *damage, int8 *dir)
+static void skill_attack_blow_unknown(int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl,
+                                      uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type,
+                                      struct Damage *dmg, int64 *damage, enum unit_dir *dir)
 {
 	nullpo_retv(bl);
 	nullpo_retv(dmg);
@@ -3512,7 +3511,7 @@ static void skill_attack_blow_unknown(int *attack_type, struct block_list *src,
 	if (!dmg->blewcount && bl->type == BL_SKILL && *damage > 0){
 		struct skill_unit *su = BL_UCAST(BL_SKILL, bl);
 		if (su->group && su->group->skill_id == HT_BLASTMINE)
-			skill->blown(src, bl, 3, -1, 0);
+			skill->blown(src, bl, 3, UNIT_DIR_UNDEFINED, 0);
 	}
 }
 
@@ -4406,7 +4405,7 @@ static int skill_castend_damage_id(struct block_list *src, struct block_list *bl
 		case KN_CHARGEATK: {
 				bool path_exists = path->search_long(NULL, src, src->m, src->x, src->y, bl->x, bl->y,CELL_CHKWALL);
 				unsigned int dist = distance_bl(src, bl);
-				uint8 dir = map->calc_dir(bl, src->x, src->y);
+				enum unit_dir dir = map->calc_dir(bl, src->x, src->y);
 
 				// teleport to target (if not on WoE grounds)
 				if( !map_flag_gvg2(src->m) && !map->list[src->m].flag.battleground && unit->movepos(src, bl->x, bl->y, 0, 1) )
@@ -4418,7 +4417,7 @@ static int skill_castend_damage_id(struct block_list *src, struct block_list *bl
 					skill->blown(src, bl, dist, dir, 0);
 					//HACK: since knockback officially defaults to the left, the client also turns to the left... therefore,
 					// make the caster look in the direction of the target
-					unit->setdir(src, (dir+4)%8);
+					unit->setdir(src, unit_get_opposite_dir(dir));
 				}
 
 			}
@@ -4457,11 +4456,12 @@ static int skill_castend_damage_id(struct block_list *src, struct block_list *bl
 
 		case RG_BACKSTAP:
 			{
-				uint8 dir = map->calc_dir(src, bl->x, bl->y), t_dir = unit->getdir(bl);
-				if ((!check_distance_bl(src, bl, 0) && !map->check_dir(dir, t_dir)) || bl->type == BL_SKILL) {
+				enum unit_dir dir = map->calc_dir(src, bl->x, bl->y);
+				enum unit_dir t_dir = unit->getdir(bl);
+				if ((!check_distance_bl(src, bl, 0) && map->check_dir(dir, t_dir) == 0) || bl->type == BL_SKILL) {
 					status_change_end(src, SC_HIDING, INVALID_TIMER);
 					skill->attack(BF_WEAPON, src, src, bl, skill_id, skill_lv, tick, flag);
-					dir = dir < 4 ? dir+4 : dir-4; // change direction [Celest]
+					dir = unit_get_opposite_dir(dir); // change direction [Celest]
 					unit->setdir(bl,dir);
 				}
 				else if (sd)
@@ -4489,7 +4489,6 @@ static int skill_castend_damage_id(struct block_list *src, struct block_list *bl
 			{
 				short x, y, i = 2; // Move 2 cells for Issen(from target)
 				struct block_list *mbl = bl;
-				short dir = 0;
 
 				skill->attack(BF_WEAPON,src,src,bl,skill_id,skill_lv,tick,flag);
 
@@ -4511,13 +4510,13 @@ static int skill_castend_damage_id(struct block_list *src, struct block_list *bl
 					status->set_hp(src, 1, STATUS_HEAL_DEFAULT);
 #endif // RENEWAL
 				}
-				dir = map->calc_dir(src,bl->x,bl->y);
-				if( dir > 0 && dir < 4) x = -i;
-				else if( dir > 4 ) x = i;
-				else x = 0;
-				if( dir > 2 && dir < 6 ) y = -i;
-				else if( dir == 7 || dir < 2 ) y = i;
-				else y = 0;
+				enum unit_dir dir = map->calc_dir(src, bl->x, bl->y);
+				if (Assert_chk(dir >= UNIT_DIR_FIRST && dir < UNIT_DIR_MAX)) {
+					map->freeblock_unlock(); // unblock before assert-returning
+					return 0;
+				}
+				x = i * dirx[dir];
+				y = i * diry[dir];
 				if ((mbl == src || (!map_flag_gvg2(src->m) && !map->list[src->m].flag.battleground))) { // only NJ_ISSEN don't have slide effect in GVG
 					if (!(unit->movepos(src, mbl->x+x, mbl->y+y, 1, 1))) {
 						// The cell is not reachable (wall, object, ...), move next to the target
@@ -4744,12 +4743,12 @@ static int skill_castend_damage_id(struct block_list *src, struct block_list *bl
 					if(idb_exists(skill->bowling_db, bl->id))
 						break;
 					// Random direction
-					dir = rnd()%8;
+					dir = rnd() % UNIT_DIR_MAX;
 				} else {
 					// Create an empty list of already hit targets
 					db_clear(skill->bowling_db);
 					// Direction is walkpath
-					dir = (unit->getdir(src)+4)%8;
+					dir = unit_get_opposite_dir(unit->getdir(src));
 				}
 				// Add current target to the list of already hit targets
 				idb_put(skill->bowling_db, bl->id, bl);
@@ -4758,6 +4757,7 @@ static int skill_castend_damage_id(struct block_list *src, struct block_list *bl
 				ty = bl->y;
 				for(i=0;i<c;i++) {
 					// Target coordinates (get changed even if knockback fails)
+					Assert_ret(dir >= UNIT_DIR_FIRST && dir < UNIT_DIR_MAX);
 					tx -= dirx[dir];
 					ty -= diry[dir];
 					// If target cell is a wall then break
@@ -4786,18 +4786,21 @@ static int skill_castend_damage_id(struct block_list *src, struct block_list *bl
 				if (bl->id==skill->area_temp[1])
 					break;
 				if (skill->attack(BF_WEAPON,src,src,bl,skill_id,skill_lv,tick,SD_ANIMATION))
-					skill->blown(src,bl,skill->area_temp[2],-1,0);
+					skill->blown(src, bl, skill->area_temp[2], UNIT_DIR_UNDEFINED, 0);
 			} else {
-				int x=bl->x,y=bl->y,i,dir;
-				dir = map->calc_dir(bl,src->x,src->y);
+				int x = bl->x;
+				int y = bl->y;
+				int i;
+				enum unit_dir dir = map->calc_dir(bl, src->x, src->y);
 				skill->area_temp[1] = bl->id;
 				skill->area_temp[2] = skill->get_blewcount(skill_id,skill_lv);
 				// all the enemies between the caster and the target are hit, as well as the target
 				if (skill->attack(BF_WEAPON,src,src,bl,skill_id,skill_lv,tick,0))
-					skill->blown(src,bl,skill->area_temp[2],-1,0);
+					skill->blown(src, bl, skill->area_temp[2], UNIT_DIR_UNDEFINED, 0);
 				for (i=0;i<4;i++) {
 					map->foreachincell(skill->area_sub,bl->m,x,y,BL_CHAR,src,skill_id,skill_lv,
 					                   tick,flag|BCT_ENEMY|1,skill->castend_damage_id);
+					Assert_ret(dir >= UNIT_DIR_FIRST && dir < UNIT_DIR_MAX);
 					x += dirx[dir];
 					y += diry[dir];
 				}
@@ -5019,7 +5022,7 @@ static int skill_castend_damage_id(struct block_list *src, struct block_list *bl
 			if(rnd()%100 < (10 + 3*skill_lv)) {
 				if( !sd || pc->checkskill(sd,KN_SPEARBOOMERANG) == 0 )
 					break; // Spear Boomerang auto cast chance only works if you have mastered Spear Boomerang.
-				skill->blown(src,bl,6,-1,0);
+				skill->blown(src, bl, 6, UNIT_DIR_UNDEFINED, 0);
 				skill->addtimerskill(src,tick+800,bl->id,0,0,skill_id,skill_lv,BF_WEAPON,flag);
 				skill->castend_damage_id(src,bl,KN_SPEARBOOMERANG,1,tick,0);
 			}
@@ -5041,16 +5044,10 @@ static int skill_castend_damage_id(struct block_list *src, struct block_list *bl
 		case KO_JYUMONJIKIRI:
 		case GC_DARKILLUSION:
 			{
-				short x, y;
-				short dir = map->calc_dir(bl, src->x, src->y);
-
-				if ( dir < 4 ) {
-					x = bl->x + 2 * (dir > 0) - 3 * (dir > 0);
-					y = bl->y + 1 - (dir / 2) - (dir > 2);
-				} else {
-					x = bl->x + 2 * (dir > 4) - 1 * (dir > 4);
-					y = bl->y + (dir / 6) - 1 + (dir > 6);
-				}
+				enum unit_dir dir = map->calc_dir(bl, src->x, src->y);
+				Assert_ret(dir >= UNIT_DIR_FIRST && dir < UNIT_DIR_MAX);
+				short x = bl->x + dirx[dir];
+				short y = bl->y + diry[dir];
 
 				if ( unit->movepos(src, x, y, 1, 1) ) {
 					clif->slide(src, x, y);
@@ -5207,14 +5204,13 @@ static int skill_castend_damage_id(struct block_list *src, struct block_list *bl
 			skill->attack(BF_MAGIC,src,src,bl,skill_id,skill_lv,tick,flag|ELE_DARK);
 			break;
 		case RA_WUGSTRIKE:
-			if( sd && pc_isridingwug(sd) ){
-				short x[8]={0,-1,-1,-1,0,1,1,1};
-				short y[8]={1,1,0,-1,-1,-1,0,1};
-				uint8 dir = map->calc_dir(bl, src->x, src->y);
-
-				if( unit->movepos(src, bl->x+x[dir], bl->y+y[dir], 1, 1) )
-				{
-					clif->slide(src, bl->x+x[dir], bl->y+y[dir]);
+			if (sd != NULL && pc_isridingwug(sd)) {
+				enum unit_dir dir = map->calc_dir(bl, src->x, src->y);
+				Assert_ret(dir >= UNIT_DIR_FIRST && dir < UNIT_DIR_MAX);
+				short x = bl->x + dirx[dir];
+				short y = bl->y + diry[dir];
+				if (unit->movepos(src, x, y, 1, 1) != 0) {
+					clif->slide(src, x, y);
 					clif->fixpos(src);
 					skill->attack(BF_WEAPON, src, src, bl, skill_id, skill_lv, tick, flag);
 				}
@@ -5657,8 +5653,9 @@ static int skill_castend_id(int tid, int64 tick, int id, intptr_t data)
 		}
 
 		if(ud->skill_id == RG_BACKSTAP) {
-			uint8 dir = map->calc_dir(src,target->x,target->y),t_dir = unit->getdir(target);
-			if(check_distance_bl(src, target, 0) || map->check_dir(dir,t_dir)) {
+			enum unit_dir dir = map->calc_dir(src, target->x, target->y);
+			enum unit_dir t_dir = unit->getdir(target);
+			if (check_distance_bl(src, target, 0) || map->check_dir(dir, t_dir) != 0) {
 				break;
 			}
 		}
@@ -5877,25 +5874,13 @@ static int skill_castend_id(int tid, int64 tick, int id, intptr_t data)
 		}
 		if (target && target->m == src->m) {
 			//Move character to target anyway.
-			int dir, x, y;
+			enum unit_dir dir = map->calc_dir(src, target->x, target->y);
+			Assert_ret(dir >= UNIT_DIR_FIRST && dir < UNIT_DIR_MAX);
 			int dist = 3; // number of cells that asura caster will walk
+			int x = dist * dirx[dir];
+			int y = dist * diry[dir];
 
-			dir = map->calc_dir(src,target->x,target->y);
-			if (dir > 0 && dir < 4)
-				x = -dist;
-			else if (dir > 4)
-				x = dist;
-			else
-				x = 0;
-			
-			if (dir > 2 && dir < 6)
-				y = -dist;
-			else if (dir == 7 || dir < 2)
-				y = dist;
-			else
-				y = 0;
-
-			if (unit->movepos(src, src->x + x, src->y + y, 1, 1) == 1) {
+			if (unit->movepos(src, src->x + x, src->y + y, 1, 1) != 0) {
 				//Display movement + animation.
 				clif->slide(src, src->x, src->y);
 				clif->spiritball(src);
@@ -7835,7 +7820,9 @@ static int skill_castend_nodamage_id(struct block_list *src, struct block_list *
 
 		case TK_HIGHJUMP:
 			{
-				int x,y, dir = unit->getdir(src);
+				int x;
+				int y;
+				enum unit_dir dir = unit->getdir(src);
 
 				//Fails on noteleport maps, except for GvG and BG maps [Skotlex]
 				if( map->list[src->m].flag.noteleport
@@ -8084,11 +8071,16 @@ static int skill_castend_nodamage_id(struct block_list *src, struct block_list *
 
 		case NPC_RUN:
 			{
-				const int mask[8][2] = {{0,-1},{1,-1},{1,0},{1,1},{0,1},{-1,1},{-1,0},{-1,-1}};
-				uint8 dir = (bl == src)?unit->getdir(src):map->calc_dir(src,bl->x,bl->y); //If cast on self, run forward, else run away.
+				enum unit_dir dir;
+				if (bl == src) //If cast on self, run forward, else run away.
+					dir = unit->getdir(src);
+				else
+					dir = map->calc_dir(src, bl->x, bl->y);
+				Assert_ret(dir >= UNIT_DIR_FIRST && dir < UNIT_DIR_MAX);
 				unit->stop_attack(src);
 				//Run skillv tiles overriding the can-move check.
-				if (unit->walktoxy(src, src->x + skill_lv * mask[dir][0], src->y + skill_lv * mask[dir][1], 2) && md)
+				if (unit->walktoxy(src, (src->x + skill_lv * -dirx[dir]),
+				    (src->y + skill_lv * -diry[dir]), 2) != 0 && md != NULL)
 					md->state.skillstate = MSS_WALK; //Otherwise it isn't updated in the AI.
 			}
 			break;
@@ -9449,7 +9441,9 @@ static int skill_castend_nodamage_id(struct block_list *src, struct block_list *
 		case NC_F_SIDESLIDE:
 		case NC_B_SIDESLIDE:
 			{
-				uint8 dir = (skill_id == NC_F_SIDESLIDE) ? (unit->getdir(src)+4)%8 : unit->getdir(src);
+				enum unit_dir dir = unit->getdir(src);
+				if (skill_id == NC_F_SIDESLIDE)
+					dir = unit_get_opposite_dir(dir);
 				skill->blown(src,bl,skill->get_blewcount(skill_id,skill_lv),dir,0);
 				clif->slide(src,src->x,src->y);
 				clif->skill_nodamage(src,bl,skill_id,skill_lv,1);
@@ -11606,17 +11600,16 @@ static int skill_castend_pos2(struct block_list *src, int x, int y, uint16 skill
 
 		case WL_EARTHSTRAIN:
 			{
-				int i, wave = skill_lv + 4, dir = map->calc_dir(src,x,y);
+				int i;
+				int wave = skill_lv + 4;
+				enum unit_dir dir = map->calc_dir(src, x, y);
+				Assert_ret(dir >= UNIT_DIR_FIRST && dir < UNIT_DIR_MAX);
 				int sx = x = src->x, sy = y = src->y; // Store first caster's location to avoid glitch on unit setting
 
-				for( i = 1; i <= wave; i++ )
-				{
-					switch( dir ){
-						case 0: case 1: case 7: sy = y + i; break;
-						case 3: case 4: case 5: sy = y - i; break;
-						case 2: sx = x - i; break;
-						case 6: sx = x + i; break;
-					}
+				for (i = 1; i <= wave; i++) {
+					sy = y + i * diry[dir];
+					if (dir == UNIT_DIR_WEST || dir == UNIT_DIR_EAST)
+						sx = x + i * dirx[dir];
 					skill->addtimerskill(src,timer->gettick() + (140 * i),0,sx,sy,skill_id,skill_lv,dir,flag&2);
 				}
 			}
@@ -13835,12 +13828,14 @@ static int skill_check_condition_char_sub(struct block_list *bl, va_list ap)
 	} else {
 
 		switch(skill_id) {
-			case PR_BENEDICTIO: {
-				uint8 dir = map->calc_dir(&sd->bl,tsd->bl.x,tsd->bl.y);
-				dir = (unit->getdir(&sd->bl) + dir)%8; //This adjusts dir to account for the direction the sd is facing.
-				if ((tsd->job & MAPID_BASEMASK) == MAPID_ACOLYTE && (dir == 2 || dir == 6) //Must be standing to the left/right of Priest.
-					&& sd->status.sp >= 10)
+			case PR_BENEDICTIO:
+			{
+				enum unit_dir dir = map->calc_dir(&sd->bl, tsd->bl.x, tsd->bl.y);
+				dir = (unit->getdir(&sd->bl) + dir) % UNIT_DIR_MAX; //This adjusts dir to account for the direction the sd is facing.
+				if ((tsd->job & MAPID_BASEMASK) == MAPID_ACOLYTE && (dir == UNIT_DIR_WEST || dir == UNIT_DIR_EAST) //Must be standing to the left/right of Priest.
+				    && sd->status.sp >= 10) {
 					p_sd[(*c)++]=tsd->bl.id;
+				}
 				return 1;
 			}
 			case AB_ADORAMUS:
@@ -15976,11 +15971,11 @@ struct square {
 	int val2[5];
 };
 
-static void skill_brandishspear_first(struct square *tc, uint8 dir, int16 x, int16 y)
+static void skill_brandishspear_first(struct square *tc, enum unit_dir dir, int16 x, int16 y)
 {
 	nullpo_retv(tc);
 
-	if(dir == 0){
+	if (dir == UNIT_DIR_NORTH) {
 		tc->val1[0]=x-2;
 		tc->val1[1]=x-1;
 		tc->val1[2]=x;
@@ -15991,7 +15986,7 @@ static void skill_brandishspear_first(struct square *tc, uint8 dir, int16 x, int
 		tc->val2[2]=
 		tc->val2[3]=
 		tc->val2[4]=y-1;
-	} else if(dir==2){
+	} else if (dir == UNIT_DIR_WEST) {
 		tc->val1[0]=
 		tc->val1[1]=
 		tc->val1[2]=
@@ -16002,7 +15997,7 @@ static void skill_brandishspear_first(struct square *tc, uint8 dir, int16 x, int
 		tc->val2[2]=y;
 		tc->val2[3]=y-1;
 		tc->val2[4]=y-2;
-	} else if(dir==4){
+	} else if (dir == UNIT_DIR_SOUTH) {
 		tc->val1[0]=x-2;
 		tc->val1[1]=x-1;
 		tc->val1[2]=x;
@@ -16013,7 +16008,7 @@ static void skill_brandishspear_first(struct square *tc, uint8 dir, int16 x, int
 		tc->val2[2]=
 		tc->val2[3]=
 		tc->val2[4]=y+1;
-	} else if(dir==6){
+	} else if (dir == UNIT_DIR_EAST) {
 		tc->val1[0]=
 		tc->val1[1]=
 		tc->val1[2]=
@@ -16024,7 +16019,7 @@ static void skill_brandishspear_first(struct square *tc, uint8 dir, int16 x, int
 		tc->val2[2]=y;
 		tc->val2[3]=y-1;
 		tc->val2[4]=y-2;
-	} else if(dir==1){
+	} else if (dir == UNIT_DIR_NORTHWEST) {
 		tc->val1[0]=x-1;
 		tc->val1[1]=x;
 		tc->val1[2]=x+1;
@@ -16035,7 +16030,7 @@ static void skill_brandishspear_first(struct square *tc, uint8 dir, int16 x, int
 		tc->val2[2]=y-1;
 		tc->val2[3]=y;
 		tc->val2[4]=y+1;
-	} else if(dir==3){
+	} else if (dir == UNIT_DIR_SOUTHWEST) {
 		tc->val1[0]=x+3;
 		tc->val1[1]=x+2;
 		tc->val1[2]=x+1;
@@ -16046,7 +16041,7 @@ static void skill_brandishspear_first(struct square *tc, uint8 dir, int16 x, int
 		tc->val2[2]=y+1;
 		tc->val2[3]=y+2;
 		tc->val2[4]=y+3;
-	} else if(dir==5){
+	} else if (dir == UNIT_DIR_SOUTHEAST) {
 		tc->val1[0]=x+1;
 		tc->val1[1]=x;
 		tc->val1[2]=x-1;
@@ -16057,7 +16052,7 @@ static void skill_brandishspear_first(struct square *tc, uint8 dir, int16 x, int
 		tc->val2[2]=y+1;
 		tc->val2[3]=y;
 		tc->val2[4]=y-1;
-	} else if(dir==7){
+	} else if (dir == UNIT_DIR_NORTHEAST) {
 		tc->val1[0]=x-3;
 		tc->val1[1]=x-2;
 		tc->val1[2]=x-1;
@@ -16072,36 +16067,27 @@ static void skill_brandishspear_first(struct square *tc, uint8 dir, int16 x, int
 
 }
 
-static void skill_brandishspear_dir(struct square *tc, uint8 dir, int are)
+static void skill_brandishspear_dir(struct square *tc, enum unit_dir dir, int are)
 {
-	int c;
 	nullpo_retv(tc);
+	Assert_retv(dir >= UNIT_DIR_FIRST && dir < UNIT_DIR_MAX);
 
-	for( c = 0; c < 5; c++ ) {
-		switch( dir ) {
-			case 0:                   tc->val2[c]+=are; break;
-			case 1: tc->val1[c]-=are; tc->val2[c]+=are; break;
-			case 2: tc->val1[c]-=are;                   break;
-			case 3: tc->val1[c]-=are; tc->val2[c]-=are; break;
-			case 4:                   tc->val2[c]-=are; break;
-			case 5: tc->val1[c]+=are; tc->val2[c]-=are; break;
-			case 6: tc->val1[c]+=are;                   break;
-			case 7: tc->val1[c]+=are; tc->val2[c]+=are; break;
-		}
+	for (int c = 0; c < 5; c++) {
+		tc->val1[c] += dirx[dir] * are;
+		tc->val2[c] += diry[dir] * are;
 	}
 }
 
 static void skill_brandishspear(struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int64 tick, int flag)
 {
 	int c,n=4;
-	uint8 dir;
 	struct square tc;
 	int x, y;
 
 	nullpo_retv(bl);
 	x = bl->x;
 	y = bl->y;
-	dir = map->calc_dir(src, x, y);
+	enum unit_dir dir = map->calc_dir(src, x, y);
 	skill->brandishspear_first(&tc,dir,x,y);
 	skill->brandishspear_dir(&tc,dir,4);
 	skill->area_temp[1] = bl->id;
@@ -21764,7 +21750,6 @@ void skill_defaults(void)
 	skill->attack_combo2_unknown = skill_attack_combo2_unknown;
 	skill->attack_display_unknown = skill_attack_display_unknown;
 	skill->attack_copy_unknown = skill_attack_copy_unknown;
-	skill->attack_dir_unknown = skill_attack_dir_unknown;
 	skill->attack_blow_unknown = skill_attack_blow_unknown;
 	skill->attack_post_unknown = skill_attack_post_unknown;
 	skill->timerskill_dead_unknown = skill_timerskill_dead_unknown;
diff --git a/src/map/skill.h b/src/map/skill.h
index eff9ed7fc..03062b199 100644
--- a/src/map/skill.h
+++ b/src/map/skill.h
@@ -23,6 +23,7 @@
 
 #include "map/map.h" // struct block_list
 #include "map/status.h" // enum sc_type
+#include "map/unitdefines.h" // enum unit_dir
 #include "common/hercules.h"
 #include "common/db.h"
 #include "common/mmo.h" // MAX_SKILL_DB, struct square
@@ -2002,7 +2003,7 @@ struct skill_interface {
 	int (*addtimerskill) (struct block_list *src, int64 tick, int target, int x, int y, uint16 skill_id, uint16 skill_lv, int type, int flag);
 	int (*additional_effect) (struct block_list* src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int attack_type, int dmg_lv, int64 tick);
 	int (*counter_additional_effect) (struct block_list* src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int attack_type, int64 tick);
-	int (*blown) (struct block_list* src, struct block_list* target, int count, int8 dir, int flag);
+	int (*blown) (struct block_list* src, struct block_list* target, int count, enum unit_dir dir, int flag);
 	int (*break_equip) (struct block_list *bl, unsigned short where, int rate, int flag);
 	int (*strip_equip) (struct block_list *bl, unsigned short where, int rate, int lv, int time);
 	struct skill_unit_group* (*id2group) (int group_id);
@@ -2085,8 +2086,8 @@ struct skill_interface {
 	bool (*dance_switch) (struct skill_unit* su, int flag);
 	int (*check_condition_char_sub) (struct block_list *bl, va_list ap);
 	int (*check_condition_mob_master_sub) (struct block_list *bl, va_list ap);
-	void (*brandishspear_first) (struct square *tc, uint8 dir, int16 x, int16 y);
-	void (*brandishspear_dir) (struct square* tc, uint8 dir, int are);
+	void (*brandishspear_first) (struct square *tc, enum unit_dir dir, int16 x, int16 y);
+	void (*brandishspear_dir) (struct square* tc, enum unit_dir dir, int are);
 	int (*get_fixed_cast) (int skill_id, int skill_lv);
 	int (*sit_count) (struct block_list *bl, va_list ap);
 	int (*sit_in) (struct block_list *bl, va_list ap);
@@ -2162,8 +2163,7 @@ struct skill_interface {
 	void (*attack_combo2_unknown) (int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *combo);
 	void (*attack_display_unknown) (int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type, struct Damage *dmg, int64 *damage);
 	int (*attack_copy_unknown) (int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
-	int (*attack_dir_unknown) (int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
-	void (*attack_blow_unknown) (int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type, struct Damage *dmg, int64 *damage, int8 *dir);
+	void (*attack_blow_unknown) (int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type, struct Damage *dmg, int64 *damage, enum unit_dir *dir);
 	void (*attack_post_unknown) (int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
 	bool (*timerskill_dead_unknown) (struct block_list *src, struct unit_data *ud, struct skill_timerskill *skl);
 	void (*timerskill_target_unknown) (int tid, int64 tick, struct block_list *src, struct block_list *target, struct unit_data *ud, struct skill_timerskill *skl);
diff --git a/src/map/unit.c b/src/map/unit.c
index 3a940665d..19ad5423d 100644
--- a/src/map/unit.c
+++ b/src/map/unit.c
@@ -150,10 +150,11 @@ static int unit_walktoxy_sub(struct block_list *bl)
 		// Trim the last part of the path to account for range,
 		// but always move at least one cell when requested to move.
 		for (int i = ud->chaserange * 10 - 10; i > 0 && ud->walkpath.path_len > 1;) {
-			uint8 dir;
+			enum unit_dir dir;
 			ud->walkpath.path_len--;
 			dir = ud->walkpath.path[ud->walkpath.path_len];
-			if ((dir & 1) != 0)
+			Assert_retr(1, dir >= UNIT_DIR_FIRST && dir < UNIT_DIR_MAX);
+			if (unit_is_diagonal_dir(dir))
 				i -= MOVE_COST * 20; // When chasing, units will target a diamond-shaped area in range [Playtester]
 			else
 				i -= MOVE_COST;
@@ -305,16 +306,15 @@ static int unit_walktoxy_timer(int tid, int64 tick, int id, intptr_t data)
 	if (ud->walkpath.path_pos >= ud->walkpath.path_len)
 		return 1;
 
-	uint8 dir = ud->walkpath.path[ud->walkpath.path_pos];
-	if (ud->walkpath.path[ud->walkpath.path_pos] >= 8)
-		return 1;
+	enum unit_dir dir = ud->walkpath.path[ud->walkpath.path_pos];
+	Assert_retr(1, dir >= UNIT_DIR_FIRST && dir < UNIT_DIR_MAX);
 	int x = bl->x;
 	int y = bl->y;
 
 	ud->dir = dir;
 
-	int dx = dirx[(int) dir];
-	int dy = diry[(int) dir];
+	int dx = dirx[dir];
+	int dy = diry[dir];
 
 	// Get icewall walk block depending on boss mode (players can't be trapped)
 	unsigned char icewall_walk_block = 0;
@@ -759,9 +759,9 @@ static bool unit_run(struct block_list *bl, struct map_session_data *sd, enum sc
 //Makes bl attempt to run dist cells away from target. Uses hard-paths.
 static int unit_escape(struct block_list *bl, struct block_list *target, short dist)
 {
-	uint8 dir;
 	nullpo_ret(bl);
-	dir = map->calc_dir(target, bl->x, bl->y);
+	enum unit_dir dir = map->calc_dir(target, bl->x, bl->y);
+	Assert_retr(1, dir >= UNIT_DIR_FIRST && dir < UNIT_DIR_MAX);
 	while (dist > 0 && map->getcell(bl->m, bl, bl->x + dist * dirx[dir], bl->y + dist * diry[dir], CELL_CHKNOREACH))
 		dist--;
 	return ( dist > 0 && unit->walktoxy(bl, bl->x + dist*dirx[dir], bl->y + dist*diry[dir], 0) );
@@ -771,7 +771,6 @@ static int unit_escape(struct block_list *bl, struct block_list *target, short d
 static int unit_movepos(struct block_list *bl, short dst_x, short dst_y, int easy, bool checkpath)
 {
 	short dx,dy;
-	uint8 dir;
 	struct unit_data        *ud = NULL;
 	struct map_session_data *sd = NULL;
 
@@ -790,7 +789,7 @@ static int unit_movepos(struct block_list *bl, short dst_x, short dst_y, int eas
 	ud->to_x = dst_x;
 	ud->to_y = dst_y;
 
-	dir = map->calc_dir(bl, dst_x, dst_y);
+	enum unit_dir dir = map->calc_dir(bl, dst_x, dst_y);
 	ud->dir = dir;
 
 	dx = dst_x - bl->x;
@@ -2100,14 +2099,13 @@ static bool unit_can_reach_bl(struct block_list *bl, struct block_list *tbl, int
 /*==========================================
  * Calculates position of Pet/Mercenary/Homunculus/Elemental
  *------------------------------------------*/
-static int unit_calc_pos(struct block_list *bl, int tx, int ty, uint8 dir)
+static int unit_calc_pos(struct block_list *bl, int tx, int ty, enum unit_dir dir)
 {
 	int dx, dy, x, y;
 	struct unit_data *ud = unit->bl2ud(bl);
 	nullpo_ret(ud);
 
-	if(dir > 7)
-		return 1;
+	Assert_retr(1, dir >= UNIT_DIR_FIRST && dir < UNIT_DIR_MAX);
 
 	ud->to_x = tx;
 	ud->to_y = ty;
@@ -2124,7 +2122,7 @@ static int unit_calc_pos(struct block_list *bl, int tx, int ty, uint8 dir)
 		if (!unit->can_reach_pos(bl, x, y, 0)) {
 			int i;
 			for (i = 0; i < 12; i++) {
-				int k = rnd()%8; // Pick a Random Dir
+				enum unit_dir k = rnd() % UNIT_DIR_MAX; // Pick a Random Dir
 				dx = -dirx[k] * 2;
 				dy = -diry[k] * 2;
 				x = tx + dx;
diff --git a/src/map/unit.h b/src/map/unit.h
index bdee032f8..7c9dc1095 100644
--- a/src/map/unit.h
+++ b/src/map/unit.h
@@ -139,7 +139,7 @@ struct unit_interface {
 	int (*cancel_combo) (struct block_list *bl);
 	bool (*can_reach_pos) (struct block_list *bl, int x, int y, int easy);
 	bool (*can_reach_bl) (struct block_list *bl, struct block_list *tbl, int range, int easy, short *x, short *y);
-	int (*calc_pos) (struct block_list *bl, int tx, int ty, uint8 dir);
+	int (*calc_pos) (struct block_list *bl, int tx, int ty, enum unit_dir dir);
 	int (*attack_timer_sub) (struct block_list *src, int tid, int64 tick);
 	int (*skillcastcancel) (struct block_list *bl, int type);
 	void (*dataset) (struct block_list *bl);