diff --git a/www/js/game.js b/www/js/game.js
index 45f6735..8d53d20 100644
--- a/www/js/game.js
+++ b/www/js/game.js
@@ -627,39 +627,75 @@ GAME.Game = class {
                 } break;
 
                 case GAME.Const.PieceId.Castle: {
-                    let mask_back = 1 << 3;
-                    if(piece.player == GAME.Const.Player.Dusk) {
-                        mask_back = BITWISE.rotate_blocks6(mask_back);
-                    }
-                    let mask_column = mask_back | BITWISE.rotate_blocks6(mask_back);
-
-                    let direction = GAME.Const.get_direction(BITWISE.ffs(mask_back));
-                    let move_hex = hex.copy();
-                    move_hex.add(direction);
-
-                    let status = (block_directions == 0 || (mask_back & block_directions) != 0);
                     
-                    // Check if backward tile meets placement rules.
-                    for(let i = 0; i < 9; ++i) {
-                        move_hex.add(direction);
-                        
-                        if(HEX.is_valid_board(move_hex)) {
-                            let tile_id = HEX.hex_to_tile(move_hex);
-                            let tile_data = this.board.tiles[tile_id];
-                            let target_id = tile_data.piece;
-
-                            let valid = status && this.placable_tile(piece, tile_id);
-
-                            if(target_id !== null) {
-                                if((mask_column & block_directions) != 0) {
-                                    status = false;
+                    // Check all tiles if not blocking.
+                    if(block_directions == 0) {
+                        for(let i = 0; i < GAME_DATA.board.tiles.length; ++i) {
+                            let tile_hex = HEX.tile_to_hex(i);
+                            let valid = 0;
+                            if(piece.player == 0) {
+                                if(tile_hex.x >= hex.x) {
+                                    valid = tile_hex.y <= hex.y;
+                                } else {
+                                    valid = tile_hex.y <= hex.y - (hex.x - tile_hex.x);
+                                }
+                            } else {
+                                if(tile_hex.x >= hex.x) {
+                                    valid = tile_hex.y >= hex.y + (tile_hex.x - hex.x);
+                                } else {
+                                    valid = tile_hex.y >= hex.y;
                                 }
                             }
 
-                            if(valid) {
-                                tiles.push(new GAME.MovementTile(tile_id, true, false, 0, 0));
+                            if(valid && this.placable_tile(piece, i)) {
+                                tiles.push(new GAME.MovementTile(i, true, false, 0, 0));
                             }
-                        } else { break; }
+                        }
+                    }
+
+                    // Check tiles in blocking directions if blocking.
+                    else {
+                        let directions = block_directions;
+                        for(let mask = BITWISE.lsb(directions); directions > 0; mask = BITWISE.lsb(directions)) {
+                            let direction_id = BITWISE.ffs(mask);
+                            let direction = GAME.Const.get_direction(direction_id);
+
+                            let move_hex = hex.copy();
+                
+                            for(let dist = 1; dist <= 9; ++dist) {
+                                move_hex.add(direction);
+
+                                if(HEX.is_valid_board(move_hex)) {
+                                    let tile_id = HEX.hex_to_tile(move_hex);
+                                    let tile_data = this.board.tiles[tile_id];
+                                    let target_id = tile_data.piece;
+
+                                    let tile_hex = HEX.tile_to_hex(i);
+                                    let valid = 0;
+                                    if(piece.player == 0) {
+                                        if(tile_hex.x >= hex.x) {
+                                            valid = tile_hex.y <= hex.y;
+                                        } else {
+                                            valid = tile_hex.y <= hex.y - (hex.x - tile_hex.x);
+                                        }
+                                    } else {
+                                        if(tile_hex.x >= hex.x) {
+                                            valid = tile_hex.y >= hex.y + (tile_hex.x - hex.x);
+                                        } else {
+                                            valid = tile_hex.y >= hex.y;
+                                        }
+                                    }
+
+                                    if(target_id !== null) { break; }
+
+                                    if(valid && this.placable_tile(piece, tile_id)) {
+                                        tiles.push(new GAME.MovementTile(tile_id, true, false, 0, 0));
+                                    }
+                                } else { break; }
+                            }
+
+                            directions &= ~mask;
+                        }
                     }
                 } break;
             }
diff --git a/www/js/interface.js b/www/js/interface.js
index 13ae0dc..0f487fb 100644
--- a/www/js/interface.js
+++ b/www/js/interface.js
@@ -290,24 +290,7 @@ const INTERFACE = {
 
     release() {
         if(INTERFACE_DATA.hover !== null && !INTERFACE.Ui.match_select(INTERFACE_DATA.hover, INTERFACE_DATA.select)) {
-            let is_valid = false;
-            if(INTERFACE_DATA.select !== null && INTERFACE_DATA.hover.source == 0 && INTERFACE_DATA.player == (GAME_DATA.turn & 1)) {
-                let tile_state = INTERFACE_DATA.board_state[INTERFACE_DATA.hover.tile][1];
-                is_valid = (tile_state == INTERFACE.TileStatus.Valid || tile_state == INTERFACE.TileStatus.Threat);
-            }
-
-            // Handle player action.
-            if(is_valid) {
-                let play = new GAME.Play(
-                    INTERFACE_DATA.select.source,
-                    INTERFACE_DATA.select.tile,
-                    INTERFACE_DATA.hover.tile,
-                    INTERFACE_DATA.alt_mode
-                );
-                INTERFACE.process(play);
-                INTERFACE_DATA.select = null;
-                INTERFACE_DATA.alt_mode = false;
-            }
+            this.click();
         }
     },
 
@@ -1087,8 +1070,10 @@ const INTERFACE = {
             } break;
 
             case 1: {
-                let player = play.from / 7;
+                let player = Math.floor(play.from / 7) ^ (INTERFACE_DATA.player & 1);
+                if(INTERFACE_DATA.player == 2) { player ^= INTERFACE_DATA.rotate; }
                 valid = player == (GAME_DATA.turn & 1);
+                play.from %= 7;
             } break;
 
             case 2: {