diff --git a/client/src/components/user-interface/common/Checkbox.tsx b/client/src/components/user-interface/common/Checkbox.tsx
new file mode 100644
index 0000000..318cc68
--- /dev/null
+++ b/client/src/components/user-interface/common/Checkbox.tsx
@@ -0,0 +1,22 @@
+import colours from '../../../utils/colours';
+
+type CheckboxProps = {
+  title: string;
+  value: boolean;
+  onChange: (value: boolean) => void;
+};
+
+const Checkbox = ({ title, value, onChange }: CheckboxProps) => (
+  <div className="flex flex-col items-center gap-2 ml-4">
+    <p className="text-sm">{title}</p>
+    <button
+      type="button"
+      aria-label={title}
+      className="w-6 h-6 rounded border-4"
+      style={{ backgroundColor: value ? colours.uiHighlight : colours.uiOverlay }}
+      onClick={() => onChange(!value)}
+    />
+  </div>
+);
+
+export default Checkbox;
diff --git a/client/src/components/world/boards/Board.tsx b/client/src/components/world/boards/Board.tsx
index c4f377d..ef6700d 100644
--- a/client/src/components/world/boards/Board.tsx
+++ b/client/src/components/world/boards/Board.tsx
@@ -13,13 +13,11 @@ import colours from '../../../utils/colours';
 
 type BoardProps = {
   board: BoardData;
-  isActive: boolean;
   winner: Nation | null;
 };
 
-const Board = ({ board, isActive, winner }: BoardProps) => {
+const Board = ({ board, winner }: BoardProps) => {
   const { phase } = board;
-  const showWinner = isActive && winner;
 
   const width = phase === Phase.Winter ? minorBoardWidth : majorBoardWidth;
 
@@ -41,12 +39,12 @@ const Board = ({ board, isActive, winner }: BoardProps) => {
           minHeight: width,
           height: width,
           borderWidth: boardBorderWidth,
-          borderColor: showWinner ? getNationColour(winner) : colours.boardBorder,
-          boxShadow: showWinner ? `0px 0px 100px 50px ${getNationColour(winner)}` : '',
+          borderColor: winner ? getNationColour(winner) : colours.boardBorder,
+          boxShadow: winner ? `0px 0px 100px 50px ${getNationColour(winner)}` : '',
         }}
       >
         <p className="text-md -mt-7">{getBoardName(board)}</p>
-        <Map board={board} isActive={isActive && !winner} />
+        <Map board={board} />
       </div>
       {phase === Phase.Winter && <Adjustment board={board} />}
     </div>
diff --git a/client/src/components/world/boards/BoardGhost.tsx b/client/src/components/world/boards/BoardGhost.tsx
index 00aa18c..669ae21 100644
--- a/client/src/components/world/boards/BoardGhost.tsx
+++ b/client/src/components/world/boards/BoardGhost.tsx
@@ -7,12 +7,15 @@ import Map from './Map';
 import TextInput from '../../user-interface/common/TextInput';
 import Select from '../../user-interface/common/Select';
 import { isInteger } from '../../../utils/numberUtils';
+import Checkbox from '../../user-interface/common/Checkbox';
 
 type LocationInputProps = {
   board: Board;
   onTimelineEntered: (value: string) => void;
   onYearEntered: (value: string) => void;
   onPhaseEntered: (value: Phase) => void;
+  isShowingCoasts: boolean;
+  onCoastsToggled: (value: boolean) => void;
 };
 
 const LocationInput = ({
@@ -20,8 +23,10 @@ const LocationInput = ({
   onTimelineEntered,
   onYearEntered,
   onPhaseEntered,
+  isShowingCoasts,
+  onCoastsToggled,
 }: LocationInputProps) => (
-  <div className="absolute -mt-20 flex flex-row gap-4 w-full justify-center">
+  <div className="absolute -mt-20 flex flex-row gap-4 w-full justify-center items-center">
     <TextInput placeholder="Timeline" onChange={onTimelineEntered} />
     <Select
       options={[
@@ -38,6 +43,7 @@ const LocationInput = ({
       setValue={onPhaseEntered}
     />
     <TextInput placeholder="Year" onChange={onYearEntered} />
+    <Checkbox title="Show coasts" value={isShowingCoasts} onChange={onCoastsToggled} />
   </div>
 );
 
@@ -51,6 +57,7 @@ const BoardGhost = ({ initialTimeline, initialYear, initialPhase }: BoardGhostPr
   const [timeline, setTimeline] = useState(initialTimeline);
   const [year, setYear] = useState(initialYear);
   const [phase, setPhase] = useState(initialPhase);
+  const [isShowingCoasts, setIsShowingCoasts] = useState(false);
 
   const board = {
     timeline,
@@ -95,6 +102,8 @@ const BoardGhost = ({ initialTimeline, initialYear, initialPhase }: BoardGhostPr
         onTimelineEntered={onTimelineEntered}
         onYearEntered={onYearEntered}
         onPhaseEntered={setPhase}
+        isShowingCoasts={isShowingCoasts}
+        onCoastsToggled={setIsShowingCoasts}
       />
       <div
         className="relative rounded-xl"
@@ -109,7 +118,7 @@ const BoardGhost = ({ initialTimeline, initialYear, initialPhase }: BoardGhostPr
         }}
       >
         <p className="text-md -mt-7">{getBoardName(board)}</p>
-        <Map board={board} isActive={false} />
+        <Map board={board} isShowingCoasts={isShowingCoasts} />
       </div>
     </div>
   );
diff --git a/client/src/components/world/boards/BoardLayer.tsx b/client/src/components/world/boards/BoardLayer.tsx
index 35e8718..f529600 100644
--- a/client/src/components/world/boards/BoardLayer.tsx
+++ b/client/src/components/world/boards/BoardLayer.tsx
@@ -1,5 +1,5 @@
 import { useContext } from 'react';
-import { getNextMajorPhase, getNextPhase } from '../../../types/enums/phase';
+import { getNextMajorPhase } from '../../../types/enums/phase';
 import { filterUnique } from '../../../utils/listUtils';
 import Board from './Board';
 import BoardSkip from './BoardSkip';
@@ -17,9 +17,6 @@ const BoardLayer = () => {
   const boards = filterUnique(world.boards.map(({ year, phase }) => ({ year, phase })));
 
   const { winner } = world;
-  const hasRetreats = world.boards.some((board) =>
-    Object.values(board.units).some((unit) => unit.mustRetreat),
-  );
 
   const selectedLocation = currentOrder?.location;
   const showGhostBoard =
@@ -46,21 +43,9 @@ const BoardLayer = () => {
             );
 
             const key = `${board.year}-${board.phase}`;
-            const nextBoard = getNextPhase(year, phase);
-            const hasNextBoard = world.boards.find(
-              (otherBoard) =>
-                otherBoard.timeline === timeline &&
-                otherBoard.year === nextBoard.year &&
-                otherBoard.phase === nextBoard.phase,
-            );
 
             return possibleBoard ? (
-              <Board
-                key={key}
-                board={possibleBoard}
-                isActive={!hasNextBoard && !hasRetreats}
-                winner={winner}
-              />
+              <Board key={key} board={possibleBoard} winner={winner} />
             ) : (
               <BoardSkip key={key} board={{ ...board, timeline }} />
             );
diff --git a/client/src/components/world/boards/Map.tsx b/client/src/components/world/boards/Map.tsx
index 24e55ad..c570d66 100644
--- a/client/src/components/world/boards/Map.tsx
+++ b/client/src/components/world/boards/Map.tsx
@@ -5,13 +5,18 @@ import regions from '../../../data/regions';
 import OrderEntryContext from '../../context/OrderEntryContext';
 import UnitType from '../../../types/enums/unitType';
 import InputMode from '../../../types/enums/inputMode';
+import { OrderType } from '../../../types/order';
+import WorldContext from '../../context/WorldContext';
+import { findUnit } from '../../../types/world';
+import Phase from '../../../types/enums/phase';
 
 type MapProps = {
   board: Board;
-  isActive: boolean;
+  isShowingCoasts?: boolean;
 };
 
-const Map = ({ board, isActive }: MapProps) => {
+const Map = ({ board, isShowingCoasts }: MapProps) => {
+  const { world } = useContext(WorldContext);
   const { currentMode, currentOrder } = useContext(OrderEntryContext);
 
   return (
@@ -30,17 +35,25 @@ const Map = ({ board, isActive }: MapProps) => {
               phase={board.phase}
               owner={board.centres[region]}
               unit={board.units[region]}
-              isActive={isActive}
             />
           );
         }
 
-        // TODO fix for fleet supporting army on space with coasts and army supporting fleet to coast
-        const showCoast =
-          currentOrder?.unit?.type !== UnitType.Army &&
-          ((currentOrder?.unit?.type === UnitType.Fleet && currentMode !== InputMode.Convoy) ||
-            board.units[region] !== undefined ||
-            currentMode === InputMode.Build);
+        const hasFleet = board.units[region]?.type === UnitType.Fleet;
+
+        const showCoast = {
+          [InputMode.None]: hasFleet || board.phase === Phase.Winter,
+          [InputMode.Hold]: hasFleet,
+          [InputMode.Move]: currentOrder?.unit?.type === UnitType.Fleet,
+          [InputMode.Support]:
+            currentOrder?.$type === OrderType.Support &&
+            ((!currentOrder.supportLocation && hasFleet) ||
+              (currentOrder.supportLocation !== null &&
+                findUnit(world, currentOrder.supportLocation)?.type === UnitType.Fleet)),
+          [InputMode.Convoy]: hasFleet,
+          [InputMode.Build]: true,
+          [InputMode.Disband]: hasFleet,
+        }[currentMode];
 
         return (
           <Region
@@ -51,8 +64,7 @@ const Map = ({ board, isActive }: MapProps) => {
             phase={board.phase}
             owner={board.centres[baseRegion]}
             unit={board.units[region]}
-            isActive={isActive}
-            isVisible={showCoast}
+            isVisible={showCoast || isShowingCoasts}
           />
         );
       })}
diff --git a/client/src/components/world/boards/Region.tsx b/client/src/components/world/boards/Region.tsx
index 5c48071..93a5227 100644
--- a/client/src/components/world/boards/Region.tsx
+++ b/client/src/components/world/boards/Region.tsx
@@ -1,4 +1,4 @@
-import { useContext, useState } from 'react';
+import { useContext, useEffect, useState } from 'react';
 import Nation, { getNationColour } from '../../../types/enums/nation';
 import OrderEntryContext from '../../context/OrderEntryContext';
 import { OrderEntryActionType } from '../../../types/context/orderEntryAction';
@@ -11,9 +11,9 @@ import UnitIcon from './UnitIcon';
 import { compareLocations, getLocationKey } from '../../../types/location';
 import { OrderType } from '../../../types/order';
 import BuildOptions from '../../user-interface/BuildOption';
-import InputMode from '../../../types/enums/inputMode';
 import colours from '../../../utils/colours';
 import RegionType from '../../../types/enums/regionType';
+import useSelectLocation from '../../../hooks/useSelectLocation';
 
 const getRegionColour = (
   isHovering: boolean,
@@ -33,42 +33,17 @@ type RegionProps = {
   phase: Phase;
   owner?: Nation;
   unit?: Unit;
-  isActive: boolean;
   isVisible?: boolean;
 };
 
-const Region = ({
-  id,
-  timeline,
-  year,
-  phase,
-  owner,
-  unit,
-  isActive,
-  isVisible = true,
-}: RegionProps) => {
-  const { dispatch, currentOrder, currentMode } = useContext(OrderEntryContext);
+const Region = ({ id, timeline, year, phase, owner, unit, isVisible = true }: RegionProps) => {
+  const { dispatch, currentOrder } = useContext(OrderEntryContext);
 
   const location = { timeline, year, phase, region: id };
   const Svg = useRegionSvg(id)!;
-  const { x, y, type, homeNation } = regions[id];
+  const { x, y, type } = regions[id];
 
-  const canRetreat = unit?.mustRetreat;
-  const canMove = isActive && phase !== Phase.Winter && unit !== undefined;
-  const canBuild =
-    isActive &&
-    phase === Phase.Winter &&
-    currentMode !== InputMode.Disband &&
-    unit === undefined &&
-    homeNation !== undefined &&
-    owner === homeNation;
-  const canDisband = isActive && phase === Phase.Winter && unit !== undefined;
-
-  const canCreateOrder = canRetreat || canMove || canBuild || canDisband;
-
-  const hasUnfinishedOrder =
-    currentOrder?.location !== undefined && currentOrder.$type !== OrderType.Build;
-  const canSelect = canCreateOrder || hasUnfinishedOrder;
+  const canSelect = useSelectLocation(location, owner, unit);
 
   const scaleFactor =
     phase === Phase.Winter
@@ -77,12 +52,16 @@ const Region = ({
 
   const [isHovering, setIsHovering] = useState(false);
 
-  let isSelected = compareLocations(currentOrder?.location, location);
-  if (currentOrder?.$type === OrderType.Support) {
-    isSelected ||= compareLocations(currentOrder.supportLocation, location);
-  } else if (currentOrder?.$type === OrderType.Convoy) {
-    isSelected ||= compareLocations(currentOrder.convoyLocation, location);
-  }
+  useEffect(() => {
+    if (!isVisible) setIsHovering(false);
+  }, [isVisible]);
+
+  const isSelected =
+    compareLocations(currentOrder?.location, location) ||
+    (currentOrder?.$type === OrderType.Support &&
+      compareLocations(currentOrder.supportLocation, location)) ||
+    (currentOrder?.$type === OrderType.Convoy &&
+      compareLocations(currentOrder.convoyLocation, location));
 
   const colour = getRegionColour(isHovering, isSelected, owner, type === RegionType.Sea);
 
diff --git a/client/src/components/world/orders/Disband.tsx b/client/src/components/world/orders/Disband.tsx
index 1b715f2..1c62d3d 100644
--- a/client/src/components/world/orders/Disband.tsx
+++ b/client/src/components/world/orders/Disband.tsx
@@ -12,7 +12,7 @@ const Disband = ({ location, status, isHighlighted }: DisbandProps) => {
   const radius = 10;
 
   return (
-    <svg className="z-20 fixed overflow-visible pointer-events-none">
+    <svg className="z-30 fixed overflow-visible pointer-events-none">
       <path
         d={`M ${coordinates.x - radius},${coordinates.y} ${coordinates.x + radius},${coordinates.y}`}
         stroke={getOrderColour(status, isHighlighted)}
diff --git a/client/src/hooks/useOrderEntryReducer.tsx b/client/src/hooks/useOrderEntryReducer.tsx
index 417196f..793340b 100644
--- a/client/src/hooks/useOrderEntryReducer.tsx
+++ b/client/src/hooks/useOrderEntryReducer.tsx
@@ -21,18 +21,17 @@ const handleAdjustmentOrderCreation = (
   const { player, currentMode, currentOrder } = state;
   const { unit, location } = action;
   const filteredOrders = state.orders.filter(
-    (order) => !compareLocations(order.location, action.location),
+    (order) => !compareLocations(order.location, action.location, true),
   );
   const nation = regions[location.region].homeNation;
 
   const isPlayerUnit = unit && (!player || unit.owner === player);
   const isPlayerNation = nation && (!player || nation === player);
 
-  // TODO fix builds in coasts
   // Beginning a build order
   if (
-    currentMode !== InputMode.Disband &&
-    (!currentOrder || !compareLocations(currentOrder.location, location))
+    (currentMode === InputMode.Build || (!unit && currentMode === InputMode.None)) &&
+    !currentOrder
   ) {
     if (!isPlayerNation) return state;
 
@@ -63,6 +62,10 @@ const handleAdjustmentOrderCreation = (
         ...filteredOrders,
         {
           ...currentOrder,
+          location:
+            action.unit?.type === UnitType.Army
+              ? { ...currentOrder.location, region: currentOrder.location.region.split('_')[0] }
+              : currentOrder.location,
           unit: {
             owner: nation,
             type: unit.type,
@@ -75,10 +78,8 @@ const handleAdjustmentOrderCreation = (
     };
   }
 
-  // TODO disband by default if selecting an existing unit on a winter board
-
   // Setting a disband order
-  if (currentMode === InputMode.Disband) {
+  if (currentMode === InputMode.Disband || (unit && currentMode === InputMode.None)) {
     if (!isPlayerUnit) return state;
 
     return {
@@ -291,6 +292,26 @@ const handleBasicOrderCreation = (
     };
   }
 
+  // Setting a disband order (for retreats)
+  if (currentMode === InputMode.Disband && unit?.mustRetreat) {
+    if (!isPlayerUnit) return state;
+
+    return {
+      ...state,
+      orders: [
+        ...filteredOrders,
+        {
+          $type: OrderType.Disband,
+          status: OrderStatus.New,
+          unit,
+          location,
+        },
+      ],
+      currentMode: InputMode.None,
+      currentOrder: null,
+    };
+  }
+
   return state;
 };
 
diff --git a/client/src/hooks/useSelectLocation.tsx b/client/src/hooks/useSelectLocation.tsx
new file mode 100644
index 0000000..e17430a
--- /dev/null
+++ b/client/src/hooks/useSelectLocation.tsx
@@ -0,0 +1,129 @@
+import { useContext } from 'react';
+import WorldContext from '../components/context/WorldContext';
+import OrderEntryContext from '../components/context/OrderEntryContext';
+import Location from '../types/location';
+import Phase from '../types/enums/phase';
+import World, { findUnit } from '../types/world';
+import Order from '../types/order';
+import InputMode from '../types/enums/inputMode';
+import regions from '../data/regions';
+import { getActiveBoards } from '../types/board';
+import GameContext from '../components/context/GameContext';
+import Nation from '../types/enums/nation';
+import Unit from '../types/unit';
+
+const isRetreatTurn = (world: World) =>
+  world.boards.some((board) => Object.values(board.units).some((unit) => unit.mustRetreat));
+
+const canSelectMajorLocation = (
+  player: Nation | null,
+  world: World,
+  currentOrder: Order | null,
+  currentMode: InputMode,
+  unit: Unit | undefined,
+  isActiveBoard: boolean,
+) => {
+  if (currentMode === InputMode.Build) return false;
+
+  if (isRetreatTurn(world)) {
+    const canStartRetreat =
+      isActiveBoard &&
+      (currentOrder === null || currentOrder.unit === null) &&
+      (currentMode === InputMode.None ||
+        currentMode === InputMode.Move ||
+        currentMode === InputMode.Disband) &&
+      unit !== undefined &&
+      unit.mustRetreat;
+    const canFinishRetreat =
+      currentOrder !== null && currentOrder.unit !== null && currentMode === InputMode.Move;
+
+    return canStartRetreat || canFinishRetreat;
+  }
+
+  if (currentMode === InputMode.Disband) return false;
+
+  const canStartOrder =
+    isActiveBoard &&
+    unit !== undefined &&
+    (!player || player === unit?.owner) &&
+    (currentOrder === null || currentOrder.unit === undefined) &&
+    !unit.mustRetreat;
+  const canFinishOrder = currentOrder !== null && currentOrder.unit !== null;
+
+  return canStartOrder || canFinishOrder;
+};
+
+const canSelectMinorLocation = (
+  player: Nation | null,
+  world: World,
+  currentOrder: Order | null,
+  currentMode: InputMode,
+  location: Location,
+  owner: Nation | undefined,
+  unit: Unit | undefined,
+  isActiveBoard: boolean,
+) => {
+  if (!isActiveBoard || isRetreatTurn(world)) return false;
+
+  const coasts = Object.keys(regions).filter(
+    (region) => region !== location.region && region.includes(location.region),
+  );
+  const unitIncludingCoasts =
+    unit ?? coasts.find((coast) => findUnit(world, { ...location, region: coast }));
+
+  if (!unitIncludingCoasts && (currentMode === InputMode.Build || currentMode === InputMode.None)) {
+    const baseRegion = location.region.split('_')[0];
+    const { isSupplyCentre, homeNation } = regions[baseRegion];
+    return (
+      isSupplyCentre === true &&
+      homeNation !== undefined &&
+      (!player || player === homeNation) &&
+      owner === homeNation &&
+      currentOrder === null
+    );
+  }
+
+  if (
+    currentMode === InputMode.Disband ||
+    (unitIncludingCoasts && currentMode === InputMode.None)
+  ) {
+    return unit !== undefined && (!player || player === unit.owner);
+  }
+
+  return false;
+};
+
+const useSelectLocation = (
+  location: Location,
+  owner: Nation | undefined,
+  unit: Unit | undefined,
+): boolean => {
+  const { game } = useContext(GameContext);
+  const { world, isLoading } = useContext(WorldContext);
+  const { currentOrder, currentMode } = useContext(OrderEntryContext);
+
+  if (!game || !world || isLoading) return false;
+
+  const { player } = game;
+  const { timeline, year, phase } = location;
+  const isActiveBoard =
+    !world.winner &&
+    getActiveBoards(world.boards).some(
+      (board) => board.timeline === timeline && board.year === year && board.phase === phase,
+    );
+
+  return location.phase === Phase.Winter
+    ? canSelectMinorLocation(
+        player,
+        world,
+        currentOrder,
+        currentMode,
+        location,
+        owner,
+        unit,
+        isActiveBoard,
+      )
+    : canSelectMajorLocation(player, world, currentOrder, currentMode, unit, isActiveBoard);
+};
+
+export default useSelectLocation;
diff --git a/client/src/hooks/useSetAvailableInputModes.tsx b/client/src/hooks/useSetAvailableInputModes.tsx
index 10cbf16..963539d 100644
--- a/client/src/hooks/useSetAvailableInputModes.tsx
+++ b/client/src/hooks/useSetAvailableInputModes.tsx
@@ -15,11 +15,14 @@ const useSetAvailableInputModes = () => {
 
   const activeBoards = getActiveBoards(boards);
 
+  const hasRetreats = activeBoards.some((board) =>
+    Object.values(board.units).some((unit) => unit.mustRetreat),
+  );
   const hasMajorBoard = !winner && activeBoards.some((board) => board.phase !== Phase.Winter);
   const hasMinorBoard = !winner && activeBoards.some((board) => board.phase === Phase.Winter);
 
   useEffect(() => {
-    // TODO allow disband during retreats
+    const retreatModes = [InputMode.Move, InputMode.Disband];
     const majorModes = [InputMode.Hold, InputMode.Move, InputMode.Support, InputMode.Convoy];
     const minorModes = [InputMode.Build, InputMode.Disband];
 
@@ -27,11 +30,12 @@ const useSetAvailableInputModes = () => {
       $type: OrderEntryActionType.SetAvailableModes,
       modes: [
         InputMode.None,
-        ...(hasMajorBoard ? majorModes : []),
-        ...(hasMinorBoard ? minorModes : []),
+        ...(hasRetreats ? retreatModes : []),
+        ...(hasMajorBoard && !hasRetreats ? majorModes : []),
+        ...(hasMinorBoard && !hasRetreats ? minorModes : []),
       ],
     });
-  }, [dispatch, hasMajorBoard, hasMinorBoard]);
+  }, [dispatch, hasRetreats, hasMajorBoard, hasMinorBoard]);
 };
 
 export default useSetAvailableInputModes;
diff --git a/client/src/types/location.ts b/client/src/types/location.ts
index b99d2b7..3f84a1c 100644
--- a/client/src/types/location.ts
+++ b/client/src/types/location.ts
@@ -26,11 +26,17 @@ export const displayLocation = (location: Location | null) =>
 export const getLocationKey = (location: Location) =>
   `${location.timeline} ${location.year} ${location.phase} ${location.region}`;
 
-export const compareLocations = (location1?: Location | null, location2?: Location | null) =>
+export const compareLocations = (
+  location1?: Location | null,
+  location2?: Location | null,
+  includeCoasts: boolean = false,
+) =>
   location1?.timeline === location2?.timeline &&
   location1?.year === location2?.year &&
   location1?.phase === location2?.phase &&
-  location1?.region === location2?.region;
+  (includeCoasts
+    ? location1?.region.split('_')[0] === location2?.region.split('_')[0]
+    : location1?.region === location2?.region);
 
 const getBaseCoordinates = (board: Omit<Location, 'region'>) => {
   const margin = boardSeparation / 2;
diff --git a/server/Adjudication/Adjudicator.cs b/server/Adjudication/Adjudicator.cs
index 1427822..96ff4ad 100644
--- a/server/Adjudication/Adjudicator.cs
+++ b/server/Adjudication/Adjudicator.cs
@@ -12,7 +12,14 @@ public void Adjudicate(World world, List<Region> regions, bool hasStrictAdjacenc
     {
         validator.Validate(world, regions, hasStrictAdjacencies);
 
-        var previousBoard = world.Boards.Last();
+        // BEGIN TEMP
+
+        foreach (var order in world.Orders.Where(o => o.Status == OrderStatus.New))
+        {
+            order.Status = OrderStatus.Success;
+        }
+
+        var previousBoard = world.Boards.MaxBy(b => 3 * b.Year + (int)b.Phase)!;
 
         var year = previousBoard.Phase == Phase.Winter ? previousBoard.Year + 1 : previousBoard.Year;
         var phase = previousBoard.Phase.NextPhase();
@@ -49,6 +56,8 @@ public void Adjudicate(World world, List<Region> regions, bool hasStrictAdjacenc
             }).ToList(),
         });
 
+        // END TEMP
+
         world.Iteration++;
     }
 }
diff --git a/server/Adjudication/Validation/Validator.cs b/server/Adjudication/Validation/Validator.cs
index 663a6f0..a30af92 100644
--- a/server/Adjudication/Validation/Validator.cs
+++ b/server/Adjudication/Validation/Validator.cs
@@ -62,14 +62,18 @@ private void ValidateConvoys()
 
         foreach (var convoy in convoys)
         {
-            // TODO fix for convoying to/from land regions with child coasts
             var locationRegion = regions.First(r => r.Id == convoy.Location.RegionId);
             var midpointRegion = regions.First(r => r.Id == convoy.Midpoint.RegionId);
             var destinationRegion = regions.First(r => r.Id == convoy.Destination.RegionId);
 
+            var midpointRegionChildren = regions.Where(r => r.ParentId == midpointRegion.Id);
+            var destinationRegionChildren = regions.Where(r => r.ParentId == destinationRegion.Id);
+
             if (locationRegion.Type != RegionType.Sea
                 || midpointRegion.Type != RegionType.Coast
-                || destinationRegion.Type != RegionType.Coast)
+                    && (!midpointRegionChildren.Any() || midpointRegionChildren.All(r => r.Type != RegionType.Coast))
+                || destinationRegion.Type != RegionType.Coast
+                    && (!destinationRegionChildren.Any() || destinationRegionChildren.All(r => r.Type != RegionType.Coast)))
             {
                 convoy.Status = OrderStatus.Invalid;
                 continue;
@@ -99,7 +103,7 @@ private void ValidateBuilds()
             var board = world.Boards
                 .FirstOrDefault(b => b.Timeline == build.Location.Timeline && b.Year == build.Location.Year && b.Phase == Phase.Winter);
             var region = regions.First(r => r.Id == build.Location.RegionId);
-            var centre = homeCentres.FirstOrDefault(c => c.Location == build.Location);
+            var centre = homeCentres.FirstOrDefault(c => c.Location.RegionId == build.Location.RegionId);
             var unit = build.Unit!;
 
             if (board == null || centre == null)
diff --git a/server/Mappers/ModelMapper.cs b/server/Mappers/ModelMapper.cs
index a464b00..16273ce 100644
--- a/server/Mappers/ModelMapper.cs
+++ b/server/Mappers/ModelMapper.cs
@@ -70,7 +70,7 @@ public class ModelMapper(GameContext context)
     {
         var existingUnit = await context.Units
             .Where(u => u.Board.World.GameId == gameId)
-            .FirstAsync(u => u.Location == location);
+            .FirstOrDefaultAsync(u => u.Location == location);
 
         if (existingUnit != null)
         {