draft: cancel ok in synctam

src/simulator.mjs

@@ -221,14 +221,19 @@ export class Simulator {
 		return true;
 	}
 
-	handleWorkerMessage(e) {
-		if (e.data.msg === "tile-added") {
-			const type = this.tileset.getTileTypeById(e.data.tid);
-			const coords = new Vector2D(e.data.x, e.data.y);
-			this.tileBlockAtlas.add_one(type, coords);
-			this.renderUpdate = true;
-		} else if (e.data.msg === "tiles-added") {
-			const fastForwardBuffer = e.data.buffer;
+    handleWorkerMessage(e) {
+	Logger.log(Logger.INFO, "got message" + e.data.msg);
+	if (e.data.msg === "tile-group-added") {
+	    let attachments = [];
+	    for (let attachment of e.data.tiles) {
+		const type = this.tileset.getTileTypeById(attachment.tid);
+		const coords = new Vector2D(attachment.x, attachment.y);
+		attachments.push({type: type, coords: coords});
+	    }
+	    this.tileBlockAtlas.add_many(attachments);
+	    this.renderUpdate = true;
+	} else if (e.data.msg === "tiles-added") {
+		    const fastForwardBuffer = e.data.buffer;
 			const added = e.data.added * 3;
 			for (let i = 0; i < added; i += 3) {
 				const type = this.tileset.getTileTypeById(fastForwardBuffer[i]);
@@ -295,14 +300,15 @@ export class Simulator {
 			} else {
 				Logger.log(Logger.INFO, `no glues currently have blockers`);
 			}
+		} else {
+		    Logger.log(Logger.WARNING, `unknown message from worker: ${e.data.msg}`);
 		}
 	}
 
-	stepForward() {
-	    let speed = this.ffSpeedInput.value;
-	    console.log(speed);
-	    this.tileWorker.postMessage({ msg: "step-forward", repeat: speed });
-	}
+    stepForward() {
+	let speed = this.ffSpeedInput.value;
+	this.tileWorker.postMessage({ msg: "step-forward", repeat: speed });
+    }
 
 	stepBackward() {
 		this.tileWorker.postMessage({ msg: "step-backward" });
@@ -507,20 +513,16 @@ export class Simulator {
 				} else if (line.toLowerCase().startsWith("temperature")) {
 					temp = parseInt(line.split("=")[1].trim());
 				} else if (line.length > 0) {
-					const data = line.split(" ");
-					if (data.length >= 3) {
-						const name = data[0].trim();
-						const x = parseInt(data[1].trim());
-						const y = parseInt(data[2].trim());
-
-						const type = this.tileset.getTileTypeByName(name);
-						const coords = new Vector2D(x, y);
-
-						// this.addTile(type, coords);
-						// this.tileWorker.postMessage({ msg: 'add-tile', tid: type.id, x: coords.x, y: coords.y});
-						this.tileBlockAtlas.add(type, coords);
-						this.seedTiles.push({type: type, coords: coords});
-					}
+				    const data = line.split(" ");
+				    if (data.length >= 3 && data[0] != "#" ) {
+					const name = data[0].trim();
+					const x = parseInt(data[1].trim());
+					const y = parseInt(data[2].trim());
+
+					const type = this.tileset.getTileTypeByName(name);
+					const coords = new Vector2D(x, y);
+					this.seedTiles.push({type: type, coords: coords});
+				    }
 				}
 			}
 
@@ -530,7 +532,9 @@ export class Simulator {
 				this.tileWorker.postMessage({ msg: 'mode-SyncTAM' });
 			}
 
+		    this.tileBlockAtlas.add_many(this.seedTiles);
 		    console.log(this.seedTiles.length);
+
 		    if (this.seedTiles.length == 0) {
 			let ttypes = this.tileset.tileTypes;
 			let tile = ttypes[Math.floor(Math.random()*ttypes.length)];

src/tileworker.js

@@ -59,20 +59,16 @@ onmessage = function(e) {
 			precomputeSignatures();
 		}
     } else if (e.data.msg === "step-forward") {
-	let n_tiles = e.data.repeat || 1;
-	for (i = 0; i < n_tiles; i++) {
+	let n_steps = e.data.repeat || 1;
+	for (i = 0; i < n_steps; i++) {
 	    const added_list = stepForward();
-	    if (added_list === null) {
+	    if (added_list === []) {
 		postMessage({ msg: "frontier-empty" });
 	    } else {
-		for (let i=0; i<added_list.length; i++) {
-		    postMessage({
-			msg: "tile-added",
-			tid: added_list[i][0],
-			x: added_list[i][1],
-			y: added_list[i][2]
-		    });
-		}
+		postMessage({
+		    msg: "tile-group-added",
+		    tiles: added_list
+		});
 	    }
 	}
     } else if (e.data.msg === "step-backward") {
@@ -100,7 +96,7 @@ onmessage = function(e) {
     	clear(e.data.temperature);
     } else if (e.data.msg === 'set-seed') {
     	for (const tile of e.data.seed) {
-    		addTile(tile.type.id, tile.coords.x, tile.coords.y, b_add_to_frontier=true, b_seed_tile=true);
+    	    addTile(tile.type.id, tile.coords.x, tile.coords.y, b_add_to_frontier=true, b_seed_tile=true);
     	}
     	seedSize = e.data.seed.length;
     } else if (e.data.msg === 'set-temperature') {
@@ -587,92 +583,112 @@ function removeTile(x, y) {
 	}
 }
 
-function stepForward(recursion_level = 0) {
-
+function blockTam_stepForward(recursion_level) {
     const ret_list = Array();
-
-    if ((simulation_mode === 'aTAM') || (simulation_mode === 'BlockTAM')) {
-	let tid;
-    	let loc;
-
-	while (tid === undefined) {
-	    if (frontierMap.size === 0) {
-		if (simulation_mode === 'BlockTAM') {
-		    postMessage({msg: "frontier-empty"});
-		    if (setBlockTAMtemperature() === true) {
-			if (recursion_level < temperatureList.length) {
-			    recursion_level += 1;
-			    return stepForward(recursion_level);
-			}
+    let tid;
+    let loc;
+
+    while (tid === undefined) {
+	if (frontierMap.size === 0) {
+	    if (simulation_mode === 'BlockTAM') {
+		postMessage({msg: "frontier-empty"});
+		if (setBlockTAMtemperature() === true) {
+		    if (recursion_level < temperatureList.length) {
+			recursion_level += 1;
+			return blockTame_stepForward(recursion_level);
 		    }
 		}
-		return null; // no more tiles can be added
 	    }
+	    return null; // no more tiles can be added
+	}
 
-	    const frontierList = Array.from(frontierMap.keys());
-	    const key = frontierList[Math.floor(Math.random() * frontierList.length)];
-	    const sig = signatureMap.get(key);
-	    const fitting = getFittingTileTypes(sig);
+	const frontierList = Array.from(frontierMap.keys());
+	const key = frontierList[Math.floor(Math.random() * frontierList.length)];
+	const sig = signatureMap.get(key);
+	const fitting = getFittingTileTypes(sig);
 
-	    tid = fitting[Math.floor(Math.random() * fitting.length)];
-	    loc = frontierMap.get(key);
+	tid = fitting[Math.floor(Math.random() * fitting.length)];
+	loc = frontierMap.get(key);
 
-	    if (tid === undefined) {
-		postMessage({msg: 'tid-undefined'});
-		frontierMap.delete(key);
-	    }
+	if (tid === undefined) {
+	    postMessage({msg: 'tid-undefined'});
+	    frontierMap.delete(key);
 	}
+    }
 
-	addTile(tid, loc[0], loc[1]);
-	history.push([{tid: tid, x: loc[0], y: loc[1]}]);
-	ret_list.push([tid, loc[0], loc[1]]);
+    addTile(tid, loc[0], loc[1]);
+    let attachment = {tid: tid, x: loc[0], y: loc[1]};
+    history.push([attachment]);
+    ret_list.push([attachment]);
 
-    } else {
-	const frontierList = Array.from(frontierMap.keys());
-	var history_step = [];
-	for (let i=0; i<frontierList.length; i++) {
-	    let tid;
-	    let loc;
-
-	    while (tid === undefined) {
-		if (i === frontierList.length) {
-		    break; // no more tiles can be added
-		}
+    return ret_list;
+}
 
-		const key = frontierList[i];
-		loc = frontierMap.get(key);
+function attachmentAt(key, b_add_to_frontier) {
+    const sig = signatureMap.get(key);
+    const fitting = getFittingTileTypes(sig);
+    if ((fitting.length > 1) && (b_report_nondeterminism === true)) {
+	const type_list = Array();
+	for (let t=0; t<fitting.length; t++) {
+	    type_list.push(tileTypes[fitting[t]].name);
+	}
+	postMessage({ msg: 'nondeterminism', loc: loc, types: type_list});
+    }
 
-		const sig = signatureMap.get(key);
-		const fitting = getFittingTileTypes(sig);
-		if ((fitting.length > 1) && (b_report_nondeterminism === true)) {
-		    const type_list = Array();
-		    for (let t=0; t<fitting.length; t++) {
-			type_list.push(tileTypes[fitting[t]].name);
-		    }
-		    postMessage({ msg: 'nondeterminism', loc: loc, types: type_list});
-		}
 
-		tid = fitting[Math.floor(Math.random() * fitting.length)];
-		if (tid === undefined) {
-		    postMessage({ msg: 'tid-undefined'});
-		    i++;
-		}
-	    }
-	    if (tid !== undefined) {
-		addTile(tid, loc[0], loc[1], false);
-		history_step.push({tid: tid, x: loc[0], y: loc[1]});
-		ret_list.push([tid, loc[0], loc[1]]);
+    const tid = fitting[Math.floor(Math.random() * fitting.length)];
+    const loc = frontierMap.get(key);
+
+    if (tid === undefined) {
+	postMessage({msg: 'tid-undefined'});
+	frontierMap.delete(key);
+	return null;
+    }
+
+    addTile(tid, loc[0], loc[1], b_add_to_frontier=b_add_to_frontier);
+    return {tid: tid, x: loc[0], y: loc[1]};
+}
+
+function stepForward() {
+    if (simulation_mode === 'blockTAM') {
+	return blockTAM_stepForward(0);
+    }
+
+    if (simulation_mode === 'aTAM') {
+	let attachment = null;
+
+	while (attachment === null) {
+	    if (frontierMap.size === 0) {
+		return [];
 	    }
+	    const frontierList = Array.from(frontierMap.keys());
+	    
+	    const key = frontierList[Math.floor(Math.random() * frontierList.length)];
+	    attachment = attachmentAt(key, true);
 	}
-	history.push(history_step);
-	for (let r = 0; r < ret_list.length; r++) {
-	    addNbrsToFrontier(ret_list[r][0], ret_list[r][1], ret_list[r][2]);
-	}
+
+	history.push([attachment]);
+	return [attachment];
+
     }
 
-    // console.log('tile added', history, seedSize);
+    if (simulation_mode === 'SyncTAM') {
+	const frontierList = Array.from(frontierMap.keys());
+	let attachments = [];
 
-    return ret_list;
+	for (let key of frontierList) {
+	    let attachment = attachmentAt(key, false);
+	    if (attachment !== null) {
+		attachments.push(attachment);
+	    }
+	}
+	if (attachments.length > 0)
+	    history.push(attachments);
+	for (let a of attachments) {
+	    addNbrsToFrontier(a.tid, a.x, a.y)
+	}
+	return attachments;
+    }
 }
 
 function stepBackward() {

src/tileworker_3D.js

@@ -52,11 +52,13 @@ onmessage = function(e) {
 		} else {
 			for (let i=0; i<added_list.length; i++) {
 				postMessage({
-					msg: "tile-added",
+				    msg: "tile-group-added",
+				    tiles: [{
 					tid: added_list[i][0],
 					x: added_list[i][1],
 					y: added_list[i][2],
 					z: added_list[i][3]
+				    }]
 				});
 			}
 		}