Differential D2079 Diff 10303 binaries/data/mods/public/simulation/helpers/BuildingPlacement.js

Changeset View

Standalone View

binaries/data/mods/public/simulation/helpers/BuildingPlacement.js

				class BuildingSnapping
				StanUnsubmitted Not Done Inline Actions BuildingSnapper ? SnappingManager ? Stan: BuildingSnapper ? SnappingManager ?
				{
				constructor()
				{
				}

				getValidEdges(allEdges, position, maxSide)
				{
				const minimalDistanceToSnap = 5;
				let edges = [];
				for (let edge of allEdges)
				{
				let signedDistance = Vector2D.dot(edge.normal, position) - Vector2D.dot(edge.normal, edge.begin);
				// Negative signed distance means that the template position
				// is lying behind the edge.
				if (signedDistance < -minimalDistanceToSnap - maxSide \|\|
				signedDistance > minimalDistanceToSnap + maxSide)
				continue;
				let dir1 = Vector2D.sub(edge.begin, edge.end).normalize();
				let dir2 = new Vector2D(-dir1.x, -dir1.y);
				let offsetDistance = Math.max(
				Vector2D.dot(dir1, position) - Vector2D.dot(dir1, edge.begin),
				Vector2D.dot(dir2, position) - Vector2D.dot(dir2, edge.end)
				);
				if (offsetDistance > minimalDistanceToSnap + maxSide)
				continue;
				// If a projection of the template position on the edge is
				// lying inside the edge then obviously we don't need to
				// account the offset distance.
				if (offsetDistance < 0)
				offsetDistance = 0;
				edge.signedDistance = signedDistance;
				edge.offsetDistance = offsetDistance;
				edges.push(edge);
				}
				return edges;
				}

				getPosition(data, template)
				{
				if (!data.snapToEdges \|\| !template.Obstruction \|\| !template.Obstruction.Static)
				return undefined;

				let width = template.Obstruction.Static["@depth"] / 2;
				let depth = template.Obstruction.Static["@width"] / 2;
				const maxSide = Math.max(width, depth);
				let templatePos = new Vector2D(data.x, data.z);
				let templateAngle = data.angle ? data.angle : 0;

				let edges = this.getValidEdges(data.snapToEdges, templatePos, maxSide);
				if (edges.length)
				{
				// Pick a base edge, it will be the first axis and fix the angle.
				// We can't just pick an edge by signed distance, because we might have
				// a case when one segment is closer by signed distance than another
				// one but much farther by actual (euclid) distance.
				const compare = (a, b) => {
				const EPS = 1e-3;
				const behindA = a.signedDistance < -EPS;
				const behindB = b.signedDistance < -EPS;
				const scoreA = Math.abs(a.signedDistance) + a.offsetDistance;
				const scoreB = Math.abs(b.signedDistance) + b.offsetDistance;
				if (Math.abs(scoreA - scoreB) < EPS)
				{
				if (behindA != behindB)
				return behindA - behindB;
				if (!behindA)
				return a.offsetDistance - b.offsetDistance;
				return -a.signedDistance - -b.signedDistance;
				}
				return scoreA - scoreB;
				};

				let baseEdge = edges[0];
				for (let edge of edges)
				if (compare(edge, baseEdge) < 0)
				baseEdge = edge;
				// Now we have the normal, we need to determine an angle,
				// which side will be snapped first.
				for (let dir = 0; dir < 4; ++dir)
				{
				const EPS = 1e-3;
				const angleCandidate = baseEdge.angle + dir * Math.PI / 2;
				// We need to find a minimal angle difference.
				let difference = Math.abs(angleCandidate - templateAngle);
				difference = Math.min(difference, Math.PI * 2 - difference);
				if (difference < Math.PI / 4 + EPS)
				{
				// We need to swap sides for orthogonal cases.
				if (dir % 2 == 0)
				[width, depth] = [depth, width];
				templateAngle = angleCandidate;
				break;
				}
				}

				// We need a small padding to avoid unnecessary collisions
				// because of loss of accuracy.
				const getPadding = (edge) => {
				const snapPadding = 0.05;
				// We don't need to padding for edges with normals directed inside
				// its entity, as we try to snap from an internal side of the edge.
				return edge.order == 'ccw' ? 0.0 : snapPadding;
				};

				let distance = Vector2D.dot(baseEdge.normal, templatePos) - Vector2D.dot(baseEdge.normal, baseEdge.begin);
				templatePos.sub(Vector2D.mult(baseEdge.normal, distance - width - getPadding(baseEdge)));
				edges = this.getValidEdges(data.snapToEdges, templatePos, maxSide);
				if (edges.length > 1)
				{
				let pairedEdges = [];
				for (let edge of edges)
				{
				const EPS = 1e-3;
				// We have to place a rectangle, so the angle between
				// edges should be 90 degrees.
				if (Math.abs(Vector2D.dot(baseEdge.normal, edge.normal)) > EPS)
				continue;
				let newEdge = {
				'begin': edge.end,
				'end': edge.begin,
				'normal': Vector2D.mult(edge.normal, -1),
				'signedDistance': -edge.signedDistance,
				'offsetDistance': edge.offsetDistance,
				'order': 'ccw',
				};
				pairedEdges.push(edge);
				pairedEdges.push(newEdge);
				}
				pairedEdges.sort(compare);
				if (pairedEdges.length)
				{
				let secondEdge = pairedEdges[0];
				for (let edge of pairedEdges)
				if (compare(edge, secondEdge) < 0.0)
				secondEdge = edge;
				let distance = Vector2D.dot(secondEdge.normal, templatePos) - Vector2D.dot(secondEdge.normal, secondEdge.begin);
				templatePos.sub(Vector2D.mult(secondEdge.normal, distance - depth - getPadding(secondEdge)));
				}
				}
				return {
				"x": templatePos.x,
				"z": templatePos.y,
				"angle": templateAngle
				};
				}
				}
				}

				Engine.RegisterGlobal("BuildingSnapping", BuildingSnapping);