126 lines
3.4 KiB
TypeScript
126 lines
3.4 KiB
TypeScript
import { mp5 } from '../main';
|
|
import { SCREEN_HEIGHT, SCREEN_WIDTH } from './constants/screen';
|
|
import { Edge } from './sketchObjects/Edge';
|
|
import { Revealable, RevealableInterface, RevealableTypes } from './sketchObjects/Revealable';
|
|
import { Coordinates, JSONSubproject, SubProject } from './types';
|
|
|
|
export function getEdgeDimensions({ size }: JSONSubproject): number {
|
|
const radius = size * 0.05;
|
|
return radius > 150 ? 150 : radius;
|
|
}
|
|
|
|
export function generateRandomEdgeCoordinates(): Coordinates {
|
|
return {
|
|
x: mp5.random(200, SCREEN_WIDTH - 200),
|
|
y: mp5.random(200, SCREEN_HEIGHT - 200),
|
|
};
|
|
}
|
|
|
|
export function isColliding(
|
|
coordinatesToTest: Coordinates,
|
|
existingCoordinates: Coordinates[]
|
|
): boolean {
|
|
return existingCoordinates.some(
|
|
(existingCoordinate) =>
|
|
mp5.dist(
|
|
existingCoordinate.x,
|
|
existingCoordinate.y,
|
|
coordinatesToTest.x,
|
|
coordinatesToTest.y
|
|
) < 300
|
|
);
|
|
}
|
|
|
|
export function generateEdgeCoords(existingEdges: Edge[]): Coordinates {
|
|
let newCoords: Coordinates;
|
|
const existingCoordinates = existingEdges.map(({ x, y }) => ({ x, y }));
|
|
|
|
do {
|
|
newCoords = generateRandomEdgeCoordinates();
|
|
} while (isColliding(newCoords, existingCoordinates));
|
|
|
|
return newCoords;
|
|
}
|
|
|
|
export function generateEdges(subprojects: JSONSubproject[]): Edge[] {
|
|
let edges = [];
|
|
|
|
subprojects.forEach((subproject) => {
|
|
const coordinates = generateEdgeCoords(edges);
|
|
edges.push({
|
|
x: coordinates.x,
|
|
y: coordinates.y,
|
|
r: getEdgeDimensions(subproject),
|
|
name: subproject.name,
|
|
});
|
|
});
|
|
|
|
return edges.map(
|
|
(edge) =>
|
|
new Edge({
|
|
x: edge.x,
|
|
y: edge.y,
|
|
r: edge.r,
|
|
name: edge.name,
|
|
})
|
|
);
|
|
}
|
|
|
|
export function getTypedSubproject(name: string, projects: JSONSubproject[]): SubProject {
|
|
return projects
|
|
.filter((project) => project.name === name)
|
|
.map((project) => ({
|
|
...project,
|
|
revealables: project.revealables.map((revealable) => ({
|
|
...revealable,
|
|
type: RevealableTypes[revealable.type],
|
|
})),
|
|
}))[0];
|
|
}
|
|
|
|
export function getRevealablesforSubproject(
|
|
subProjectName: string,
|
|
subProjects: JSONSubproject[]
|
|
): RevealableInterface[] {
|
|
return subProjects
|
|
.filter((subproject) => subproject.name === subProjectName)[0]
|
|
.revealables.map((revealable) => ({
|
|
...revealable,
|
|
type: RevealableTypes[revealable.type],
|
|
}));
|
|
}
|
|
|
|
export function generateRevealableCoords(existingRevealables: Revealable[]): Coordinates {
|
|
let newCoords: Coordinates;
|
|
const existingCoordinates = existingRevealables.map(({ area }) => ({ x: area.x, y: area.y }));
|
|
|
|
if (existingRevealables.length === 0) {
|
|
return generateRandomEdgeCoordinates();
|
|
} else {
|
|
do {
|
|
newCoords = generateRandomEdgeCoordinates();
|
|
} while (isColliding(newCoords, existingCoordinates));
|
|
}
|
|
|
|
return newCoords;
|
|
}
|
|
|
|
export function generateRevealables(revealables: RevealableInterface[]): Revealable[] {
|
|
let revObjs = [];
|
|
|
|
revealables.forEach((revealable) => {
|
|
const coordinates = generateRevealableCoords(revObjs);
|
|
revObjs.push({
|
|
revealable,
|
|
area: {
|
|
x: coordinates.x,
|
|
y: coordinates.y,
|
|
w: revealable.size < 50 ? 50 : revealable.size > 400 ? 400 : revealable.size,
|
|
},
|
|
});
|
|
});
|
|
|
|
console.log(revObjs);
|
|
|
|
return revObjs.map((revObj) => new Revealable(revObj.revealable, revObj.area));
|
|
}
|