From b393de530ef8fbd0d1e0afec977565112a2600bd Mon Sep 17 00:00:00 2001 From: Moriz Wahl Date: Wed, 18 Sep 2024 23:46:46 +0200 Subject: [PATCH] stars can be distributed up to 896 stars, for some reason, the next iteration to 1536 stars breaks --- backend/prisma/seed.ts | 2 +- .../graphql/resolvers/starmap/starmap.spec.ts | 125 ++++++++++++++- .../src/graphql/resolvers/starmap/starmap.ts | 142 ++++++++---------- 3 files changed, 187 insertions(+), 82 deletions(-) diff --git a/backend/prisma/seed.ts b/backend/prisma/seed.ts index e5ce0c6142..19b56803e6 100644 --- a/backend/prisma/seed.ts +++ b/backend/prisma/seed.ts @@ -27,7 +27,7 @@ const seedUsers = async () => { name: 'Räuber Hotzenplotz', referenceId: faker.string.alphanumeric({ length: 8, casing: 'upper', exclude: 'O' }), }, - ...Array.from(new Array(100), () => ({ + ...Array.from(new Array(891), () => ({ name: faker.person.fullName(), username: faker.internet.userName(), referenceId: faker.string.alphanumeric({ length: 8, casing: 'upper', exclude: 'O' }), diff --git a/backend/src/graphql/resolvers/starmap/starmap.spec.ts b/backend/src/graphql/resolvers/starmap/starmap.spec.ts index 4b65f08f55..0841a84e8d 100644 --- a/backend/src/graphql/resolvers/starmap/starmap.spec.ts +++ b/backend/src/graphql/resolvers/starmap/starmap.spec.ts @@ -168,14 +168,129 @@ describe('distributeStarsToSectorsRecursive', () => { expect(stars[0].sectorIdx).toBe(0) }) - // ToDo: fix - it('has 13th star in sector 1', () => { - expect(stars[12].sectorIdx).not.toBe(0) + it('has 12th star in sector 11', () => { + expect(stars[11].sectorIdx).toBe(11) + }) + + it('has 13th star in sector 0', () => { + expect(stars[12].sectorIdx).toBe(0) }) - // ToDo: fix it('has 14th star in sector 1', () => { - expect(stars[13].sectorIdx).not.toBe(1) + expect(stars[13].sectorIdx).toBe(1) + }) + }) + + describe('distribute 16 stars', () => { + const stars = distributeStarsToSectorsRecursive(16) + + it('has 16 stars', () => { + expect(stars).toHaveLength(16) + }) + + it('has last star in sector 3', () => { + expect(stars[15].sectorIdx).toBe(3) + }) + }) + + describe('distribute 17 stars', () => { + const stars = distributeStarsToSectorsRecursive(17) + + it('has 17 stars', () => { + expect(stars).toHaveLength(17) + }) + + it('has last star in sector 12', () => { + expect(stars[16].sectorIdx).toBe(12) + }) + }) + + describe('distribute 48 stars', () => { + const stars = distributeStarsToSectorsRecursive(48) + + it('has 48 stars', () => { + expect(stars).toHaveLength(48) + }) + + it('has star at index 39 in sector 11', () => { + expect(stars[39].sectorIdx).toBe(11) + }) + + it('has star at index 40 in sector 0', () => { + expect(stars[40].sectorIdx).toBe(0) + }) + + it('has the last 4 stars in sector 0, 1, 2, 3', () => { + expect(stars[44].sectorIdx).toBe(0) + expect(stars[45].sectorIdx).toBe(1) + expect(stars[46].sectorIdx).toBe(2) + expect(stars[47].sectorIdx).toBe(3) + }) + }) + + describe('distribute 116 stars', () => { + const stars = distributeStarsToSectorsRecursive(116) + + it('has 116 stars', () => { + expect(stars).toHaveLength(116) + }) + + it('has star at index 48 in sector 28', () => { + expect(stars[48].sectorIdx).toBe(28) + }) + + it('has star at index 71 in sector 51', () => { + expect(stars[71].sectorIdx).toBe(51) + }) + + it('has star at index 72 in sector 12', () => { + expect(stars[72].sectorIdx).toBe(12) + }) + + it('has star at index 88 in sector 4', () => { + expect(stars[88].sectorIdx).toBe(4) + }) + + it('has star at index 96 in sector 4', () => { + expect(stars[96].sectorIdx).toBe(4) + }) + + it('has the last 4 stars in sector 0, 1, 2, 3', () => { + expect(stars[112].sectorIdx).toBe(0) + expect(stars[113].sectorIdx).toBe(1) + expect(stars[114].sectorIdx).toBe(2) + expect(stars[115].sectorIdx).toBe(3) + }) + }) + + describe('distribute 256 stars', () => { + const stars = distributeStarsToSectorsRecursive(256) + + it('has 256 stars', () => { + expect(stars).toHaveLength(256) + }) + + it('has the last 4 stars in sector 0, 1, 2, 3', () => { + expect(stars[252].sectorIdx).toBe(0) + expect(stars[253].sectorIdx).toBe(1) + expect(stars[254].sectorIdx).toBe(2) + expect(stars[255].sectorIdx).toBe(3) + }) + }) + + describe('distribute 496 stars', () => { + const stars = distributeStarsToSectorsRecursive(496) + + it('has 496 stars', () => { + expect(stars).toHaveLength(496) + }) + }) + + describe('distribute 896 stars', () => { + const stars = distributeStarsToSectorsRecursive(896) + + it('has 896 stars', () => { + expect(stars).toHaveLength(896) }) }) }) diff --git a/backend/src/graphql/resolvers/starmap/starmap.ts b/backend/src/graphql/resolvers/starmap/starmap.ts index a00e6ed1b8..287b8a59d5 100644 --- a/backend/src/graphql/resolvers/starmap/starmap.ts +++ b/backend/src/graphql/resolvers/starmap/starmap.ts @@ -38,6 +38,7 @@ const fibonacci = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] const sectors: Sector[] = [] const starDistribution: StarDistribution[] = [] const sectorsPerIteration: number[] = [] +const starInSector: number[] = [] /* @@ -277,47 +278,75 @@ export const getStarDistribution = (): StarDistribution[] => { } const getNextSectorIdx = (starsPlaced: number): number => { - // const sectorIterationLength = 4 + MAX_VERTICAL_SECTORS + if (starInSector[starsPlaced] || starInSector[starsPlaced] === 0) { + return starInSector[starsPlaced] + } + + const pushAndReturn = (n: number): number => { + starInSector.push(n) + return n + } + + if (starsPlaced === 0) { + return pushAndReturn(0) + } + const starDistribution = getStarDistribution() const sectors = getSectors() - const iteration = starDistribution.findIndex((sD) => sD.starsPlacedInIteration > starsPlaced) - const difference = starDistribution[iteration].starsPlacedInIteration - starsPlaced + let iteration: number = 0 - // const length = Math.min(sectorIterationLength, iteration + 1) - /* - console.log({ - starsPlaced, - iteration, - difference, - }) - */ + if ( + (iteration = starDistribution.findIndex((sD) => sD.starsPlacedInIteration === starsPlaced)) > -1 + ) { + return pushAndReturn( + sectors.findIndex( + (s: Sector) => + s.iteration === starDistribution[iteration + 1].starsPlacedInSectorIteration.length, + ), + ) + } + + iteration = starDistribution.findIndex((sD) => sD.starsPlacedInIteration > starsPlaced) + const starsAddedInPreviousIterations = + iteration === 0 ? 0 : starDistribution[iteration - 1].starsPlacedInIteration - if (difference === 0) { - return sectors.findLastIndex((s: Sector) => s.iteration === iteration + 1) + const starsToPlace = starsPlaced - starsAddedInPreviousIterations + + let sectorIterationIdx = 0 + let starsAddedInSectorIterations = 0 + const { starsPlacedInSectorIteration } = starDistribution[iteration] + while (starsToPlace > starsAddedInSectorIterations) { + starsAddedInSectorIterations += starsPlacedInSectorIteration[sectorIterationIdx] + sectorIterationIdx++ } - let sectorIdx = 0 - let starsAdded = 0 - while (difference > starsAdded) { - starsAdded += starDistribution[iteration].starsPlacedInSectorIteration[sectorIdx] - sectorIdx++ - /* - console.log({ - sectorIdx, - starsAdded, - }) - */ + if (starsToPlace === starsAddedInSectorIterations) { + return pushAndReturn( + sectors.findIndex( + (s: Sector) => s.iteration === starsPlacedInSectorIteration.length - sectorIterationIdx, + ), + ) } - /* - console.log('result', ( - sectors.findIndex((s) => s.iteration === sectorIdx) + - starsAdded - difference - )) - */ + const f = fibonacci[sectorIterationIdx - 1] + + if (f > 1) { + const starsPlacedInThisSectorIteration = starsPlacedInSectorIteration + .slice(0, sectorIterationIdx - 1) + .reduce((acc, curr) => acc + curr, 0) + const starsToPlcaeInThisSectorIteration = starsToPlace - starsPlacedInThisSectorIteration + + const sectorsPerIteration = + getSectorsPerIteration()[starsPlacedInSectorIteration.length - sectorIterationIdx] - return sectors.findIndex((s) => s.iteration === sectorIdx) + starsAdded - difference + if (starsToPlcaeInThisSectorIteration % sectorsPerIteration === 0) { + return pushAndReturn(starInSector[starsPlaced - 1] - sectorsPerIteration + 1) + } + return pushAndReturn(starInSector[starsPlaced - 1] + 1) + } + + return pushAndReturn(starInSector[starsPlaced - 1] + 1) } export const distributeStarsToSectorsRecursive = ( @@ -343,8 +372,12 @@ const addRandomStarToSector = (sectorIdx: number, stars: Star[]): Star => { altitudes.push(s.coordinates.altitude) }) - const azimuthMaxIdx = getMaxDistance(azimuths) - const altitudeMaxIdx = getMaxDistance(altitudes) + const sortFn = (a: number, b: number): number => { + return a - b + } + + const azimuthMaxIdx = getMaxDistance(azimuths.sort(sortFn)) + const altitudeMaxIdx = getMaxDistance(altitudes.sort(sortFn)) const azimuth = randomBetween( azimuths[azimuthMaxIdx] + DELTA_MIN, @@ -363,46 +396,3 @@ const addRandomStarToSector = (sectorIdx: number, stars: Star[]): Star => { }, } } - -/* - -type StarsInSector = { - sectorIdx: number - coordinates: Coordinates -} - -export const randomStarsinSector = (sectorIdx: number, count: number): StarsInSector => { - const starsInSector: StarsInSector = { - sectorIdx, - stars: [], - } - const azimuths: number[] = [ - sectors[sectorIdx].bottomLeft.azimuth, - sectors[sectorIdx].topRight.azimuth, - ] - const altitudes: number[] = [ - sectors[sectorIdx].bottomLeft.altitude, - sectors[sectorIdx].topRight.altitude, - ] - for (let n = 0; n < count; n++) { - const azimuthMaxIdx = getMaxDistance(azimuths) - const altitudeMaxIdx = getMaxDistance(altitudes) - const azimuth = randomBetween( - azimuths[azimuthMaxIdx] + DELTA_MIN, - azimuths[azimuthMaxIdx + 1] - DELTA_MIN, - ) - const altitude = randomBetween( - altitudes[altitudeMaxIdx] + DELTA_MIN, - altitudes[altitudeMaxIdx + 1] - DELTA_MIN, - ) - starsInSector.stars.push({ - azimuth, - altitude, - }) - azimuths.splice(azimuthMaxIdx, 0, azimuth) - altitudes.splice(altitudeMaxIdx, 0, altitude) - } - return starsInSector -} - -*/