@packtrack/layout 1.0.0

package/device/channel.ts

@@ -0,0 +1,14 @@
+import { Device } from "./device";
+
+export class Channel {
+	constructor(
+		public device: Device,
+		public name: string
+	) {}
+
+	dump() {
+		console.log(`Channel '${this.name}' on ${this.device.identifier}`);
+	}
+
+	publish(data: any) {}
+}

package/device/device.ts

@@ -0,0 +1,28 @@
+import { Channel } from "./channel";
+
+export class Device {
+	channels: Channel[] = [];
+
+	lastDiscovery: { date: Date, address: string };
+	
+	constructor(
+		public identifier: string
+	) {}
+
+	dump() {
+		console.group(`Device ${this.identifier}`);
+
+		if (this.lastDiscovery) {
+			console.log(`last discovery: ${this.lastDiscovery.date.toISOString()} ${this.lastDiscovery.address}`);
+		}
+
+		console.group('channels');
+
+		for (let channel of this.channels) {
+			channel.dump();
+		}
+
+		console.groupEnd();
+		console.groupEnd();
+	}
+}

package/district.ts

@@ -0,0 +1,104 @@
+import { Layout } from ".";
+import { PowerDistrict } from "./power-district";
+import { Router } from "./router";
+import { Section } from "./section";
+
+export class District {
+	children: District[] = [];
+	
+	powerDistricts: PowerDistrict[] = [];
+	sections: Section[] = [];
+	routers: Router[] = [];
+	
+	constructor(
+		public name: string,
+		public parent: District | Layout
+	) {}
+
+	get domainName() {
+		if (this.parent instanceof Layout) {
+			return `${this.name}.${this.parent.name}`;
+		}
+
+		return `${this.name}.${this.parent.domainName}`;
+	}
+	
+	dump() {
+		console.group(`District ${this.domainName}`);
+		
+		if (this.powerDistricts.length) {
+			console.group('power districts');
+			
+			for (let district of this.powerDistricts) {
+				district.dump();
+			}
+
+			console.groupEnd();
+		}
+		
+		if (this.sections.length) {
+			console.group('sections');
+			
+			for (let section of this.sections) {
+				section.dump();
+			}
+
+			console.groupEnd();
+		}
+		
+		if (this.children.length) {
+			console.group('children');
+			
+			for (let district of this.children) {
+				district.dump();
+			}
+
+			console.groupEnd();
+		}
+		
+		console.groupEnd();
+	}
+	
+	toDotReference() {
+		return `cluster_${this.name.replace(/-/g, '_')}${this.parent instanceof District ? this.parent.toDotReference() : ''}`;
+	}
+	
+	toDotDefinition() {
+		return `
+			subgraph ${this.toDotReference()} {
+				label = ${JSON.stringify(this.name)}
+				
+				${this.sections.map(section => section.toDotDefinition()).join('')}
+				${this.routers.map(router => router.toDotDefinition()).join('')}
+				
+				${this.children.map(child => child.toDotDefinition()).join('')}
+			}
+		`;
+	}
+	
+	toDotConnection() {
+		return `
+			${this.sections.map(section => section.toDotConnection()).join('')}
+			${this.routers.map(router => router.toDotConnection()).join('')}
+				
+			${this.children.map(child => child.toDotConnection()).join('')}
+		`;
+	}
+
+	toSVG() {
+		return `
+			<g id=${JSON.stringify(this.domainName)}>
+				${this.sections.map(section => section.toSVG()).join('')}
+
+				${this.children.map(child => child.toSVG()).join('')}
+			</g>
+		`;
+	}
+
+	findSVGPositions() {
+		return [
+			...this.sections.map(section => section.findSVGPositions()), 
+			...this.children.map(child => child.findSVGPositions())
+		];
+	}
+}

package/index.ts

@@ -0,0 +1,399 @@
+import { District } from "./district";
+import { PowerDistrict } from "./power-district";
+import { Route } from "./route";
+import { Router } from "./router";
+import { Section } from "./section";
+import { TilePattern, Tile } from "./tile";
+import { Track } from "./track";
+import { PointPositioner } from "./positioner/point";
+import { Device } from "./device/device";
+import { ResponderType } from "./positioner/responder-type";
+import { Channel } from "./device/channel";
+
+export class Layout {
+	name: string;
+	
+	districts: District[] = [];
+	
+	devices: Device[] = [];
+	responderType: ResponderType[] = [];
+
+	get allDistricts() {
+		const districts: District[] = [];
+
+		function walkDistrict(district: District) {
+			districts.push(district);
+
+			for (let child of district.children) {
+				walkDistrict(child);
+			}
+		}
+
+		for (let district of this.districts) {
+			walkDistrict(district);
+		}
+
+		return districts;
+	}
+
+	static from(document: any) {
+		const layout = new Layout();
+
+		const railway = document.firstChild!;
+		layout.name = railway.getAttribute('name');
+
+		const version = railway.getAttribute('version');
+		
+		if (version == '1') {
+			let district = railway.firstChild;
+			
+			while (district) {
+				if (district.tagName == 'district') {
+					layout.districts.push(layout.loadDistrict(district, layout));
+				}
+				
+				district = district.nextSibling;
+			}
+			
+			district = railway.firstChild;
+			let index = 0;
+			
+			while (district) {
+				if (district.tagName == 'district') {
+					layout.linkDistrict(district, layout.districts[index]);
+					
+					index++;
+				}
+				
+				district = district.nextSibling;
+			}
+		} else {
+			throw new Error(`unsupported railway definition file version '${version}'`);
+		}
+
+		return layout;
+	}
+	
+	loadDistrict(source, parent: District | Layout) {
+		const district = new District(source.getAttribute('name'), parent);
+		
+		let child = source.firstChild;
+		
+		while (child) {
+			if (child.tagName == 'power-districts') {
+				let powerDistrict = child.firstChild;
+				
+				while (powerDistrict) {
+					if (powerDistrict.tagName == 'power-district') {
+						district.powerDistricts.push(this.loadPowerDistrict(powerDistrict, district));
+					}
+					
+					powerDistrict = powerDistrict.nextSibling;
+				}
+			}
+			
+			if (child.tagName == 'section') {
+				this.loadSection(child, district);
+			}
+			
+			if (child.tagName == 'router') {
+				district.routers.push(this.loadRouter(child, district));
+			}
+			
+			if (child.tagName == 'district') {
+				district.children.push(this.loadDistrict(child, district));
+			}
+			
+			child = child.nextSibling;
+		}
+		
+		return district;
+	}
+	
+	linkDistrict(source, district: District) {
+		let child = source.firstChild;
+		
+		let sectionIndex = 0;
+		let childIndex = 0;
+		
+		while (child) {
+			if (child.tagName == 'section') {
+				this.linkSection(child, district.sections[sectionIndex]);
+				
+				sectionIndex++;
+			}
+			
+			if (child.tagName == 'router') {
+				this.linkRouter(child, district.routers.find(router => router.name == child.getAttribute('name'))!);
+			}
+			
+			if (child.tagName == 'district') {
+				this.linkDistrict(child, district.children[childIndex]);
+				
+				childIndex++;
+			}
+			
+			child = child.nextSibling;
+		}
+	}
+	
+	loadSection(source, district: District) {
+		const section = new Section(source.getAttribute('name'), district);
+		district.sections.push(section);
+		
+		let child = source.firstChild;
+		
+		while (child) {
+			if (child.tagName == 'tracks') {
+				let trackNode = child.firstChild;
+				
+				while (trackNode) {
+					if (trackNode.tagName == 'track') {
+						const track = new Track(
+							section, 
+							+trackNode.getAttribute('length'), 
+							trackNode.getAttribute('path')
+						);
+
+						section.tracks.push(track);
+						
+						let trackChild = trackNode.firstChild;
+
+						while (trackChild) {
+							if (trackChild.tagName == 'positioners') {
+								let positioner = trackChild.firstChild;
+
+								while (positioner) {
+									if (positioner.tagName == 'point') {
+										const device = this.findDevice(positioner.getAttribute('device'));
+										const channel = this.findChannel(device, positioner.getAttribute('channel'));
+										const responderType = this.findResponderType(positioner.getAttribute('responder'));
+
+										track.positioners.push(new PointPositioner(
+											track, 
+											+positioner.getAttribute('offset'),
+											channel,
+											responderType
+										));
+									}
+
+									positioner = positioner.nextSibling;
+								}
+							}
+
+							trackChild = trackChild.nextSibling;
+						}
+					}
+					
+					trackNode = trackNode.nextSibling;
+				}
+			}
+
+			if (child.tagName == 'tile') {
+				const pattern = child.getAttribute('pattern');
+
+				if (!(pattern in TilePattern.patterns)) {
+					throw new Error(`Unknown tile pattern '${pattern}' in tile ${section.tiles.length + 1} in ${section.domainName}`);
+				}
+
+				section.tiles.push(new Tile(section, +child.getAttribute('x'), +child.getAttribute('y'), TilePattern.patterns[pattern]))
+			}
+			
+			child = child.nextSibling;
+		}
+	}
+
+	findDevice(identifier: string) {
+		let device = this.devices.find(device => device.identifier == identifier);
+
+		if (device) {
+			return device;
+		}
+
+		device = new Device(identifier);
+		this.devices.push(device);
+
+		return device;
+	}
+
+	findChannel(device: Device, name: string) {
+		let channel = device.channels.find(channel => channel.name == name);
+
+		if (channel) {
+			return channel;
+		}
+
+		channel = new Channel(device, name);
+		device.channels.push(channel);
+
+		return channel;
+	}
+
+	findResponderType(name: string) {
+		let type = this.responderType.find(type => type.name == name);
+
+		if (type) {
+			return type;
+		}
+
+		type = new ResponderType(name);
+		this.responderType.push(type);
+
+		return type;
+	}
+	
+	linkSection(source, section: Section) {
+		let child = source.firstChild;
+		
+		while (child) {
+			if (child.tagName == 'out') {
+				const out = this.findSection(child.getAttribute('section'), section.district);
+				
+				section.out = out;
+				out.in = section;
+			}
+			
+			child = child.nextSibling;
+		}
+	}
+	
+	findSection(path: string, base: District, source = base) {
+		const parts = path.split('.');
+		
+		if (parts.length == 0) {
+			throw `section '${path}' not found from '${source.name}': invalid name`;
+		}
+		
+		if (parts.length == 1) {
+			const localSection = base.sections.find(section => section.name == parts[0]);
+			
+			if (!localSection) {
+				throw new Error(`Section '${path}' not found from '${source.name}': section does not exist in '${base.name}'`);
+			}
+			
+			return localSection;
+		}
+		
+		const sectionName = parts.pop()!;
+		
+		let pool: District | Layout = base;
+		
+		for (let index = 0; index < parts.length; index++) {
+			if (pool instanceof Layout || !pool.parent) {
+				throw new Error(`Section '${path}' could not be found from '${source.name}': district '${pool.name}' does not have a parent`);
+			}
+			
+			pool = pool.parent!;
+		}
+		
+		for (let part of parts) {
+			const child = (pool instanceof District ? pool.children : pool.districts).find(child => child.name == part);
+			
+			if (!child) {
+				throw new Error(`Section '${path}' could not be found from '${source.name}': district '${pool.name}' does not have a child named '${part}'`);
+			}
+			
+			pool = child;
+		}
+
+		if (pool instanceof Layout) {
+			throw new Error(`Section '${path}' could not be found from '${source.name}': a layout cannot directly include a section`);
+		}
+		
+		return this.findSection(sectionName, pool, source);
+	}
+	
+	loadRouter(source, district: District) {
+		const router = new Router(source.getAttribute('name'), district);
+		
+		return router;
+	}
+	
+	linkRouter(source, router: Router) {
+		let child = source.firstChild;
+		
+		while (child) {
+			if (child.tagName == 'route') {
+				const route = new Route(child.getAttribute('name'), router);
+				
+				route.in = this.findSection(child.getAttribute('in'), router.district);
+				route.in.out = router;
+				
+				route.out = this.findSection(child.getAttribute('out'), router.district);
+				route.out.in = router;
+				
+				router.routes.push(route);
+			}
+			
+			child = child.nextSibling;
+		}
+	}
+	
+	loadPowerDistrict(source, district: District) {
+		const powerDistrict = new PowerDistrict(source.getAttribute('name'), district);
+		
+		return powerDistrict;
+	}
+
+	toDot() {
+		let dot = 'digraph G {';
+			
+		for (let district of this.districts) {
+			dot += district.toDotDefinition();
+		}
+		
+		for (let district of this.districts) {
+			dot += district.toDotConnection();
+		}
+		
+		return `${dot}}`;
+	}
+
+	toSVG(inject = '') {
+		const positons = this.districts.map(district => district.findSVGPositions()).flat(Infinity);
+
+		const width = Math.max(...positons.map(position => position.x));
+		const height = Math.max(...positons.map(position => position.y));
+
+		let svg = `<svg width="100vw" height="100vh" viewBox="0 0 ${width + 1} ${height + 1}" xmlns="http://www.w3.org/2000/svg">
+			<style>
+
+				path {
+					fill: none;
+					stroke: #000;
+					stroke-width: 0.2;
+				}
+
+			</style>
+		`;
+		
+		for (let district of this.districts) {
+			svg += district.toSVG();
+		}
+			
+		return `${svg}${inject}</svg>`;
+	}
+
+	dump() {
+		console.group(`Layout ${this.name}`);
+		console.log('devices');
+
+		for (let device of this.devices) {
+			device.dump();
+		}
+
+		console.log('responder types');
+
+		for (let type of this.responderType) {
+			type.dump();
+		}
+
+		console.log('districts');
+
+		for (let district of this.districts) {
+			district.dump();
+		}
+
+		console.groupEnd();
+	}
+}

package/package.json

@@ -0,0 +1,4 @@
+{
+	"name": "@packtrack/layout",
+	"version": "1.0.0"
+}

package/positioner/index.ts

@@ -0,0 +1,3 @@
+export class Positioner {
+	
+}

package/positioner/point.ts

@@ -0,0 +1,28 @@
+import { Positioner } from ".";
+import { Channel } from "../device/channel";
+import { Track } from "../track";
+import { ResponderType } from "./responder-type";
+
+export class PointPositioner extends Positioner {
+	constructor(
+		public track: Track,
+		public offset: number,
+		public channel: Channel,
+		public responder: ResponderType
+	) {
+		super();
+	}
+
+	get position() {
+		return this.track.head.advance(this.offset);
+	}
+	
+	dump() {
+		console.group('Point positioner');
+		console.log('offset:', this.offset);
+
+		this.channel.dump();
+
+		console.groupEnd();
+	}
+}

package/positioner/responder-type.ts

@@ -0,0 +1,9 @@
+export class ResponderType {
+	constructor(
+		public name: string
+	) {}
+
+	dump() {
+		console.log(`Responder Type '${this.name}'`);
+	}
+}

package/postion.ts

@@ -0,0 +1,35 @@
+import { Section } from '../layout/section.js';
+
+export class SectionPosition {
+    constructor(
+        public section: Section,
+        public offset: number,
+        public reversed: boolean
+    ) {}
+
+    get absolutePosition() {
+        if (this.reversed) {
+            return this.section.length - this.offset;
+        }
+
+        return this.offset;
+    }
+
+    advance(distance: number) {
+        if (this.offset + distance > this.section.length) {
+            const next = this.section.next(this.reversed);
+
+            if (!next) {
+                throw new Error(`Illegal advancement ${this} + ${distance}`);
+            }
+
+            return new SectionPosition(next, 0, this.reversed).advance(this.offset + distance - this.section.length);
+        }
+        
+        return new SectionPosition(this.section, this.offset + distance, this.reversed);
+    }
+
+    toString() {
+        return `${this.section.name} @ ${this.offset.toFixed(1)} ${this.reversed ? 'backward' : 'forward'}`;
+    }
+}

package/power-district.ts

@@ -0,0 +1,16 @@
+import { District } from "./district";
+
+export class PowerDistrict {
+	constructor(
+		public name: string,
+		public district: District
+	) {}
+
+	get domainName() {
+		return `${this.name}.${this.district.domainName}`;
+	}
+	
+	dump() {
+		console.log(this.name);
+	}
+}

package/route.ts

@@ -0,0 +1,16 @@
+import { Router } from "./router";
+import { Section } from "./section";
+
+export class Route {
+	in: Section;
+	out: Section;
+	
+	constructor(
+		public name: string,
+		public router: Router,
+	) {}
+	
+	dump() {
+		console.log(`Route ${this.name}: ${this.in.domainName} → ${this.out.domainName}`);
+	}
+}

package/router.ts

@@ -0,0 +1,46 @@
+import { District } from "./district";
+import { Route } from "./route";
+
+export class Router {
+	activeRoute?: Route;
+
+	routes: Route[] = [];
+	
+	constructor(
+		public name: string,
+		public district: District
+	) {}
+
+	get domainName() {
+		return `${this.name}.${this.district.domainName}`;
+	}
+	
+	dump() {
+		console.group(`Router ${this.domainName}`);
+
+		for (let route of this.routes) {
+			route.dump();
+		}
+
+		console.groupEnd();
+	}
+	
+	toDotReference() {
+		return `router_${this.name.replace(/-/g, '_')}_${this.district.toDotReference()}`;
+	}
+	
+	toDotDefinition() {
+		return `
+			${this.toDotReference()} [ label = ${JSON.stringify(this.name)}, shape = diamond ]
+		`;
+	}
+	
+	toDotConnection() {
+		return `
+			${this.routes.map(route => `
+				${route.in.toDotReference()} -> ${this.toDotReference()} [ headlabel = ${JSON.stringify(route.name)} ]
+				${this.toDotReference()} -> ${route.out.toDotReference()} [ taillabel = ${JSON.stringify(route.name)} ]
+			`).join('')}
+		`;
+	}
+}

package/section.ts

@@ -0,0 +1,269 @@
+import { District } from "./district";
+import { SectionPosition } from "./postion";
+import { PowerDistrict } from "./power-district";
+import { Router } from "./router";
+import { Tile } from "./tile";
+import { Track } from "./track";
+
+export class Section {
+	powerDistrict: PowerDistrict;
+	
+	tracks: Track[] = [];
+	tiles: Tile[] = [];
+	
+	in?: Router | Section;
+	out?: Router | Section;
+	
+	constructor(
+		public name: string,
+		public district: District
+	) {}
+
+	get domainName() {
+		return `${this.name}.${this.district.domainName}`;
+	}
+
+	// returns the next currently set section
+	next(reverse: boolean) {
+		if (reverse) {
+			if (!this.in) {
+				return null;
+			}
+
+			if (this.in instanceof Section) {
+				return this.in;
+			}
+
+			if (this.in instanceof Router) {
+				const activeRoute = this.in.activeRoute;
+
+				if (!activeRoute) {
+					throw new Error(`Router '${this.in.domainName}' has no active route`);
+				}
+
+				if (activeRoute.in == this) {
+					return activeRoute.out;
+				}
+
+				if (activeRoute.out == this) {
+					return activeRoute.in;
+				}
+
+				throw new Error(`Router '${this.in.domainName}' is not routing from '${this.domainName}'`);
+			}
+		} else {
+			if (!this.out) {
+				return null;
+			}
+
+			if (this.out instanceof Section) {
+				return this.out;
+			}
+
+			if (this.out instanceof Router) {
+				const activeRoute = this.out.activeRoute;
+
+				if (!activeRoute) {
+					throw new Error(`Router '${this.out.domainName}' has no active route`);
+				}
+
+				if (activeRoute.in == this) {
+					return activeRoute.out;
+				}
+
+				if (activeRoute.out == this) {
+					return activeRoute.in;
+				}
+
+				throw new Error(`Router '${this.in?.domainName}' is not routing from '${this.domainName}'`);
+			}
+		}
+	}
+
+	getTilesInRange(startPosition: SectionPosition, endPosition: SectionPosition) {
+		if (startPosition.section != this && endPosition.section != this) {
+			return {
+				offset: {
+					start: 0,
+					end: this.tiles[this.tiles.length - 1].pattern.length
+				},
+			
+				tiles: [...this.tiles]
+			};
+		}
+
+		let start = 0;
+		let end = this.length;
+		
+		// only use the position limit if it is within our section
+		if (startPosition.section == this) {
+			end = startPosition.absolutePosition;
+		}
+
+		if (endPosition.section == this) {
+			start = endPosition.absolutePosition;
+		}
+
+		// flip if the range was reversed
+		if (end < start) {
+			const small = end;
+
+			end = start;
+			start = small;
+		}
+
+		let passed = 0;
+		const tiles: Tile[] = [];
+
+		const tileUnitLength = this.length / this.tileLength;
+
+		const offset = {
+			start: 0,
+			end: 0
+		};
+
+		for (let tile of this.tiles) {
+			const length = tile.pattern.length * tileUnitLength;
+
+			if (start - length <= passed && end + length >= passed) {
+				tiles.push(tile);
+
+				if (start <= passed) {
+					offset.start = (start + length - passed) * tile.pattern.length / length;
+				}
+	
+				if (end >= passed) {
+					offset.end = 0.5; // (start + length - passed) * tile.pattern.length / length;
+				}
+			}
+
+			passed += length;
+		}
+		
+		return {
+			offset,
+			tiles
+		};
+	}
+	
+	dump() {
+		console.group(`Section ${this.domainName}`);
+		
+		console.log('in', this.in?.name ?? 'buffer');
+		console.log('out', this.out?.name ?? 'buffer');
+		
+		console.group(`tracks`);
+		
+		for (let track of this.tracks) {
+			track.dump();
+		}
+		
+		console.groupEnd();
+		console.groupEnd();
+	}
+	
+	get length() {
+		return this.tracks.reduce((accumulator, track) => accumulator + track.length, 0);
+	}
+
+	get tileLength() {
+		return this.tiles.reduce((accumulator, tile) => accumulator + tile.pattern.length, 0);
+	}
+
+	// follow the active path ahead (reverse = true = back)
+	// uses the currently set routes
+	// returns all touched sections
+	trail(offset: number, reversed: boolean, length: number) {
+		let tip: Section = this;
+		const sections: Section[] = [this];
+
+		if (reversed) {
+			length -= offset;
+		} else {
+			length -= this.length - offset;
+		}
+
+		while (length > 0) {
+			let next: Router | Section | undefined;
+
+			if (reversed) {
+				next = tip.in;
+			} else {
+				next = tip.out;
+			}
+
+			if (!next) {
+				return {
+					sections,
+
+					tip: new SectionPosition(tip, tip.length, false)
+				};
+			}
+
+			if (next instanceof Section) {
+				tip = next;
+			}
+
+			if (next instanceof Router) {
+				if (!next.activeRoute) {
+					throw new Error(`Router '${next.domainName}' has no active route (routes: ${next.routes.map(route => `'${route.name}'`).join(', ')})`);
+				}
+
+				// TODO: handle flipped cases
+				if (reversed) {
+					tip = next.activeRoute!.in;
+				} else {
+					tip = next.activeRoute!.out;
+				}
+			}
+
+			sections.push(tip);
+			length -= tip.length;
+		}
+
+		return {
+			sections,
+
+			tip: new SectionPosition(tip, reversed ? -length : tip.length + length, false)
+		};
+	}
+	
+	toDotReference() {
+		return `section_${this.name.replace(/-/g, '_')}_${this.district.toDotReference()}`;
+	}
+	
+	toDotDefinition() {
+		return `
+			${this.toDotReference()} [ label = ${JSON.stringify(`${this.name}\n${this.length}`)}, shape = box ]
+		`;
+	}
+	
+	toDotConnection() {
+		return `
+			${this.out instanceof Section ? `${this.toDotReference()} -> ${this.out.toDotReference()}` : ''}
+		`;
+	}
+
+	toSVG() {
+		return `
+			<g id=${JSON.stringify(this.domainName).split('.').join('_')}>
+				<style>
+
+					g#${this.domainName.split('.').join('_')} path {
+						stroke: hsl(${(this.length / this.tileLength)}deg, 100%, 50%);
+					}
+
+				</style>
+
+				${this.tiles.map(tile => tile.toSVG()).join('')}
+			</g>
+		`;
+	}
+
+	findSVGPositions() {
+		return this.tiles.map(tile => ({ 
+			x: tile.x,
+			y: tile.y
+		}));
+	}
+}

package/tile.ts

@@ -0,0 +1,86 @@
+import { Section } from './section.js';
+
+export class TilePattern {
+    // TODO: replace simple paths with rounded versions
+    static patterns = {
+        'tl-cc': new TilePattern(0.7, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 0}, L ${x + 0.5} ${y + 0.5}`),
+        'tc-cc': new TilePattern(0.5, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0}, L ${x + 0.5} ${y + 0.5}`),
+        'tr-cc': new TilePattern(0.7, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 0}, L ${x + 0.5} ${y + 0.5}`),
+        'cl-cc': new TilePattern(0.5, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 0.5}, L ${x + 0.5} ${y + 0.5}`),
+        'cr-cc': new TilePattern(0.5, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 0.5}, L ${x + 0.5} ${y + 0.5}`),
+        'bl-cc': new TilePattern(0.7, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 1}, L ${x + 0.5} ${y + 0.5}`),
+        'bc-cc': new TilePattern(0.5, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 1}, L ${x + 0.5} ${y + 0.5}`),
+        'br-cc': new TilePattern(0.7, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 1}, L ${x + 0.5} ${y + 0.5}`),
+
+        'cc-tl': new TilePattern(0.7, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0.5}, L ${x + 0} ${y + 0}`),
+        'cc-tc': new TilePattern(0.5, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0.5}, L ${x + 0.5} ${y + 0}`),
+        'cc-tr': new TilePattern(0.7, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 0}`),
+        'cc-cl': new TilePattern(0.5, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0.5}, L ${x + 0} ${y + 0.5}`),
+        'cc-cr': new TilePattern(0.5, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 0.5}`),
+        'cc-bl': new TilePattern(0.7, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0.5}, L ${x + 0} ${y + 1}`),
+        'cc-bc': new TilePattern(0.5, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0.5}, L ${x + 0.5} ${y + 1}`),
+        'cc-br': new TilePattern(0.7, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 1}`),
+
+        'cr-cl': new TilePattern(1, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 0.5}, L ${x + 0} ${y + 0.5}`),
+        'cr-tl': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 0.5}, L ${x + 0.5} ${y + 0.5}, L ${x + 0} ${y + 0}`),
+        'cr-bl': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 0.5}, L ${x + 0.5} ${y + 0.5}, L ${x + 0} ${y + 1}`),
+        
+        'cl-cr': new TilePattern(1, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 0.5}, L ${x + 1} ${y + 0.5}`),
+        'cl-tr': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 0.5}, L ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 0}`),
+        'cl-bl': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 0.5}, L ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 1}`),
+        
+        'tl-bc': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 0}, L ${x + 0.5} ${y + 0.5}, L ${x + 0.5} ${y + 1}`),
+        'tl-br': new TilePattern(1.4, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 0}, L ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 1}`),
+        'tl-cr': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 0}, L ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 0.5}`),
+
+        'tc-bc': new TilePattern(1, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0}, L ${x + 0.5} ${y + 1}`),
+        'tc-br': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0}, L ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 1}`),
+        'tc-bl': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0}, L ${x + 0.5} ${y + 0.5}, L ${x + 0} ${y + 1}`),
+
+        'tr-cl': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 0}, L ${x + 0.5} ${y + 0.5}, L ${x + 0} ${y + 0.5}`),
+        'tr-bc': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 0}, L ${x + 0.5} ${y + 0.5}, L ${x + 0.5} ${y + 1}`),
+        
+        'bl-tr': new TilePattern(1.4, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 1}, L ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 0}`),
+        'bl-tc': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 1}, L ${x + 0.5} ${y + 0.5}, L ${x + 0.5} ${y + 0}`),
+        'bl-cr': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 1}, L ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 0.5}`),
+
+        'bc-tc': new TilePattern(1, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 1}, L ${x + 0.5} ${y + 0.5}, L ${x + 0.5} ${y + 0}`),
+        'bc-tr': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 1}, L ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 0}`),
+        'bc-tl': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 1}, L ${x + 0.5} ${y + 0.5}, L ${x + 0} ${y + 0}`),
+
+        'br-cl': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 1}, L ${x + 0.5} ${y + 0.5}, L ${x + 0} ${y + 0.5}`),
+        'br-tc': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 1}, L ${x + 0.5} ${y + 0.5}, L ${x + 0.5} ${y + 0}`),
+       
+        'br-tl': new TilePattern(1.4, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 1}, L ${x + 0.5} ${y + 0.5}, L ${x + 0} ${y + 0}`),
+
+        // oddities
+        'cl-bc': new TilePattern(0.7, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 0.5}, L ${x + 0.5} ${y + 1}`)
+    };
+
+    constructor(
+        public length: number,
+        public path: (continuous: boolean, x: number, y: number) => string
+    ) {}
+}
+
+export class Tile {
+    constructor(
+        public section: Section,
+
+        public x: number,
+        public y: number,
+
+        public pattern: TilePattern
+    ) {}
+
+    toSVGPath(continuous = false) {
+        return this.pattern.path(continuous, this.x, this.y);
+    }
+
+    toSVG() {
+        return `
+            <path d="${this.toSVGPath()}" />
+            ${this.section.tiles[0] == this ? `<text x="${this.x}" y="${this.y}" font-size="0.2">${this.section.name}</text>` : ''}
+        `;
+    }
+}

package/track.ts

@@ -0,0 +1,30 @@
+import { Positioner } from "./positioner";
+import { Section } from "./section";
+import { SectionPosition } from "./postion";
+
+export class Track {
+	positioners: Positioner[] = [];
+
+	constructor(
+		public section: Section,
+		public length: number,
+		public path: string
+	) {}
+
+	// the start of the track within the section
+	get head() {
+		let offset = 0;
+
+		for (let track of this.section.tracks) {
+			if (track == this) {
+				return new SectionPosition(this.section, offset, false);
+			}
+			
+			offset += track.length;
+		}
+	}
+	
+	dump() {
+		console.log(this.length);
+	}
+}