dunno what to write, this is a non-clean state...

src/main/java/de/srsoftware/web4rail/Route.java

@@ -92,6 +92,8 @@ public class Route extends BaseClass {
 	public  Direction 					   startDirection;
 	private HashSet<Contact>			   triggeredContacts = new HashSet<>();
 
+	private Route nextRoute;
+	
 	public Route() {
 		conditions = new ConditionList();
 		conditions.parent(this);
@@ -404,6 +406,10 @@ public class Route extends BaseClass {
 		return sb.toString().trim();
 	}
 	
+	public Route getNextRoute() {
+		return nextRoute;
+	}
+	
 	public Id id() {
 		if (isNull(id)) id = new Id(""+(generateName().hashCode()));
 		return id;
@@ -775,6 +781,11 @@ public class Route extends BaseClass {
 		if (lastTile instanceof Turnout) addTurnout((Turnout) lastTile,state);
 	}
 	
+	public void setNextRoute(Route nextRoute) {
+		this.nextRoute = nextRoute;
+	}
+
+	
 	public boolean setSignals(String state) {
 		LOG.debug("{}.setSignals({})",this,state);
 		for (Signal signal : signals) {
@@ -862,4 +873,8 @@ public class Route extends BaseClass {
 		super.update(params);
 		return properties();
 	}
+
+	public Integer waitTime() {
+		return isNull(context) ? null : context.waitTime();
+	}
 }

src/main/java/de/srsoftware/web4rail/actions/PreserveRoute.java

@@ -30,7 +30,6 @@ public class PreserveRoute extends Action {
 			return false; // train is expected to wait in next block.
 		}
 
-		train.reserveRouteAfter(route);
-		return true;
+		return route.prepareNext(train);
 	}
 }

src/main/java/de/srsoftware/web4rail/moving/Train.java

@@ -37,6 +37,7 @@ import de.srsoftware.web4rail.tags.Select;
 import de.srsoftware.web4rail.tags.Table;
 import de.srsoftware.web4rail.tags.Window;
 import de.srsoftware.web4rail.threads.RouteManager;
+import de.srsoftware.web4rail.threads.RouteManager.Callback;
 import de.srsoftware.web4rail.tiles.Block;
 import de.srsoftware.web4rail.tiles.Contact;
 import de.srsoftware.web4rail.tiles.Tile;
@@ -61,7 +62,7 @@ public class Train extends BaseClass implements Comparable<Train> {
 	private Route route;	
 		
 	private Direction direction;
-	
+	private boolean autopilot;
 	private static final String PUSH_PULL = "pushPull";
 	public boolean pushPull = false;
 	
@@ -93,6 +94,8 @@ public class Train extends BaseClass implements Comparable<Train> {
 
 	private HashSet<Tile> stuckTrace = null;
 
+	private Route nextRoute;
+
 	public static Object action(HashMap<String, String> params, Plan plan) throws IOException {
 		String action = params.get(ACTION);
 		if (isNull(action)) return t("No action passed to Train.action!");
@@ -403,12 +406,18 @@ public class Train extends BaseClass implements Comparable<Train> {
 	
 	public void endRoute(Block endBlock, Direction endDirection) {
 		setSpeed(0);
+		nextRoute = route.getNextRoute();
+		Integer waitTime = route.waitTime();
 		route = null;
 		direction = endDirection;		
 		endBlock.add(this, direction);		
 		currentBlock = endBlock;
 		trace.add(endBlock);
 		stuckTrace = null;
+		if (autopilot) {			
+			if (isSet(waitTime) && waitTime > 0) sleep(waitTime);
+			start(false);
+		}
 	}
 
 	private Tag faster(int steps) {
@@ -715,10 +724,6 @@ public class Train extends BaseClass implements Comparable<Train> {
 		return tags().iterator();
 	}
 
-	public void reserveRouteAfter(Route r) {
-		LOG.debug("reserveRouteAfter({})",r);
-	}
-
 	/**
 	 * This turns the train as if it went through a loop. Example:
 	 * before: CabCar→ MiddleCar→ Loco→
@@ -864,9 +869,20 @@ public class Train extends BaseClass implements Comparable<Train> {
 
 
 	public String start(boolean auto) {
-		if (isNull(routeManager)) routeManager = new RouteManager(this);
-		routeManager.setAuto(auto).start();
-		plan.stream(t("Started {}",this));
+		autopilot |= auto;
+		if (isSet(nextRoute) && nextRoute.start()) {
+			nextRoute = null;
+			return null;
+		}
+		if (isNull(routeManager)) routeManager = new RouteManager();
+		routeManager.setContext(new Context(this).block(currentBlock).direction(direction));
+		routeManager.start(new Callback() {
+			@Override
+			public void routePrepared(Route route) {
+				route.start();
+				plan.stream(t("Started {}",Train.this));
+			}		
+		});		
 		return null;
 	}
 
@@ -999,6 +1015,6 @@ public class Train extends BaseClass implements Comparable<Train> {
 	}
 
 	public boolean usesAutopilot() {
-		return isSet(routeManager) && routeManager.autoEnabled();
+		return autopilot;
 	}
 }

src/main/java/de/srsoftware/web4rail/threads/RouteManager.java

@@ -16,21 +16,19 @@ import de.srsoftware.web4rail.moving.Train;
 import de.srsoftware.web4rail.tiles.Block;
 import de.srsoftware.web4rail.tiles.Tile;
 
-public class RouteManager extends BaseClass implements Runnable {
+public class RouteManager extends BaseClass {
 
-	enum State {
-		ENDED,IDLE,STARTED;
+	public static abstract class Callback {
+		public abstract void routePrepared(Route route);
 	}
+
 	private static final Logger LOG = LoggerFactory.getLogger(RouteManager.class);
-	private static final int DEFAULT_PAUSE_TIME = 250; // ms
-	private State state = State.IDLE;
-	private boolean autopilot;
-	private Context context;
-	private int time = 0;
+	private Context ctx;
+	private Callback callback;
+	private boolean active;
 
-	public RouteManager(Train train) {
-		context = new Context(train);
-		state = State.STARTED;
+	public RouteManager() {
+		active = false;
 	}
 
 	private static TreeMap<Integer, List<Route>> availableRoutes(Context context, HashSet<Route> visitedRoutes) {
@@ -45,8 +43,10 @@ public class RouteManager extends BaseClass implements Runnable {
 		TreeMap<Integer, List<Route>> availableRoutes = new TreeMap<Integer, List<Route>>();
 
 		boolean error = false;
-		if (isNull(block) && (error = true)) LOG.warn("{} → {}.availableRoutes called without context.block!",inset,Train.class.getSimpleName());
-		if (isNull(train) && (error = true)) LOG.warn("{}→ {}.availableRoutes called without context.train!", inset,Train.class.getSimpleName());
+		if (isNull(block) && (error = true))
+			LOG.warn("{} → {}.availableRoutes called without context.block!", inset, Train.class.getSimpleName());
+		if (isNull(train) && (error = true))
+			LOG.warn("{}→ {}.availableRoutes called without context.train!", inset, Train.class.getSimpleName());
 		if (error) return availableRoutes;
 
 		Block destination = train.destination();
@@ -65,7 +65,9 @@ public class RouteManager extends BaseClass implements Runnable {
 				continue;
 			}
 
-			HashSet<Tile> stuckTrace = train.stuckTrace(); // if train has been stopped in between two blocks lastly: only allow routes that do not conflict with current train position
+			HashSet<Tile> stuckTrace = train.stuckTrace(); // if train has been stopped in between two blocks lastly:
+															// only allow routes that do not conflict with current train
+															// position
 			if (isSet(stuckTrace) && !routeCandidate.path().containsAll(stuckTrace)) {
 				LOG.debug("Stuck train occupies tiles ({}) outside of {} – not allowed.", stuckTrace, routeCandidate);
 				continue;
@@ -80,12 +82,16 @@ public class RouteManager extends BaseClass implements Runnable {
 			}
 
 			int priority = 0;
-			if (isSet(startDirection) && routeCandidate.startDirection != startDirection) { // Route startet entgegen der aktuellen Fahrtrichtung des Zuges 
+			if (isSet(startDirection) && routeCandidate.startDirection != startDirection) { // Route startet entgegen
+																							// der aktuellen
+																							// Fahrtrichtung des Zuges
 				if (!train.pushPull) continue; // Zug kann nicht wenden
 				if (!block.turnAllowed) continue; // Wenden im Block nicht gestattet
 				priority -= 5;
 			}
-			if (routeCandidate == currentRoute) priority-=10; // möglichst andere Route als zuvor wählen // TODO: den Routen einen "last-used" Zeitstempel hinzufügen, und diesen mit in die Priorisierung einbeziehen
+			if (routeCandidate == currentRoute) priority -= 10; // möglichst andere Route als zuvor wählen // TODO: den
+																// Routen einen "last-used" Zeitstempel hinzufügen, und
+																// diesen mit in die Priorisierung einbeziehen
 
 			if (isSet(destination)) {
 				if (routeCandidate.endBlock() == destination) { // route goes directly to destination
@@ -93,11 +99,13 @@ public class RouteManager extends BaseClass implements Runnable {
 					priority = 1_000_000;
 				} else {
 					LOG.debug("{}- Candidate: {}", inset, routeCandidate.shortName());
-					Context forwardContext = new Context(train).block(routeCandidate.endBlock()).route(null).direction(routeCandidate.endDirection);
+					Context forwardContext = new Context(train).block(routeCandidate.endBlock()).route(null)
+						.direction(routeCandidate.endDirection);
 					visitedRoutes.add(routeCandidate);
 					TreeMap<Integer, List<Route>> forwardRoutes = availableRoutes(forwardContext, visitedRoutes);
 					visitedRoutes.remove(routeCandidate);
-					if (forwardRoutes.isEmpty()) continue; // the candidate does not lead to a block, from which routes to the destination exist
+					if (forwardRoutes.isEmpty()) continue; // the candidate does not lead to a block, from which routes
+															// to the destination exist
 					Entry<Integer, List<Route>> entry = forwardRoutes.lastEntry();
 					LOG.debug("{}→ The following routes have connections to {}:", inset, destination);
 					for (Route rt : entry.getValue()) LOG.debug("{}  - {}", inset, rt.shortName());
@@ -111,9 +119,11 @@ public class RouteManager extends BaseClass implements Runnable {
 				availableRoutes.put(priority, routeSet);
 			}
 			routeSet.add(routeCandidate);
-			if (routeCandidate.endBlock() == destination) break; // direct connection to destination discovered, quit search
+			if (routeCandidate.endBlock() == destination) break; // direct connection to destination discovered, quit
+																	// search
 		}
-		if (!availableRoutes.isEmpty())	LOG.debug("{}→ Routes from {}: {}",inset,block,availableRoutes.isEmpty()?"none":"");
+		if (!availableRoutes.isEmpty())
+			LOG.debug("{}→ Routes from {}: {}", inset, block, availableRoutes.isEmpty() ? "none" : "");
 		for (Entry<Integer, List<Route>> entry : availableRoutes.entrySet()) {
 			LOG.debug("{} - Priority {}:", inset, entry.getKey());
 			for (Route r : entry.getValue()) LOG.debug("{}    - {}", inset, r.shortName());
@@ -121,10 +131,6 @@ public class RouteManager extends BaseClass implements Runnable {
 		return availableRoutes;
 	}
 
-	public boolean autoEnabled() {
-		return autopilot && isActive();
-	}
-
 	public static Route chooseRoute(Context context) {
 		LOG.debug("{}.chooseRoute({})", RouteManager.class.getSimpleName(), context);
 		TreeMap<Integer, List<Route>> availableRoutes = availableRoutes(context, new HashSet<Route>());
@@ -147,71 +153,56 @@ public class RouteManager extends BaseClass implements Runnable {
 		return null;
 	}
 
-	public boolean isActive() {
-		switch (state) {
-		case ENDED:
-			return false;
-		case IDLE:
-			return false;
-		default:
-			return true;
-		}
-	}
-	
-	private void pause(){
-		if (time == 0) {
-			time  = DEFAULT_PAUSE_TIME;
-		} else sleep(time);
-	}
-	
 	public void quit() {
 		LOG.debug("{}.quit", this);
-		autopilot = false;
-		context.invalidate();		
+		callback = null;
+		if (isSet(ctx)) ctx.invalidate();
 	}
 
-	@Override
-	public void run() {
-		Train train = context.train();
+	public Route prepareRoute(Context context) {
 		try {
-			do {
-				pause();
-				if (isSet(train.route())) continue;
-				if (context.invalidated()) return;
-				context.block(train.currentBlock()).direction(train.direction());
+			if (isNull(context) || context.invalidated()) return null;
 			Route route = chooseRoute(context);
-				if (isNull(route)) continue;
+			if (isNull(route)) return null;
 			context.route(route);
 			if (!route.reserveFor(context)) {
 				route.reset();
-					continue;
+				return null;
 			}
 			if (!route.prepareAndLock()) {
 				route.reset();
-					continue;
-				}
-				// Route reserved, prepared and locked:
-				if (!route.start()) {
-					route.reset();
-					continue;
+				return null;
 			}
-			} while (autopilot);			
+
+			return route;
 		} finally {
-			// do not invalidate context here: may be used in delayed actions called from (successful) start
-			state = State.ENDED;
-			train.removeChild(this);
+			active = false;
 		}
 	}
 
-	public RouteManager setAuto(boolean auto) {
-		LOG.debug("{}abled autopilot of {}",auto?"En":"Dis");
-		autopilot = auto;
-		return this;
+	public void setContext(Context context) {
+		ctx = context;
 	}
 
-	public void start() {
-		Thread thread = new Thread(this);
-		thread.setName(context.train().name());
+	public void setCallback(Callback callback) {
+		if (ctx.invalidated()) return;
+		if (isNull(this.callback)) {
+			Route route = prepareRoute(ctx);
+			if (isSet(route) && isSet(callback)) callback.routePrepared(route);
+		}
+	}
+
+	public boolean isActive() {
+		return active;
+	}
+
+	public void start(Callback callback) {
+		Thread thread = new Thread() {
+			public void run() {
+				setCallback(callback);
+			};
+		};
+		thread.setName(getClass().getSimpleName() + "(" + ctx.train() + ")");
 		thread.start();
 	}
 }