/
KPattern.ts
98 lines (88 loc) 路 3.03 KB
/
KPattern.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
import type { KPuzzle } from "./KPuzzle";
import type { Alg, Move } from "../alg";
import { applyTransformationDataToKPatternData } from "./combine";
import type { KTransformationSource } from "./KPuzzle";
import type {
KPatternData,
KTransformationData,
KTransformationOrbitData,
} from "./KPuzzleDefinition";
import { KTransformation } from "./KTransformation";
import { isPatternDataIdentical } from "./calculate";
export class KPattern {
constructor(
public readonly kpuzzle: KPuzzle,
public readonly patternData: KPatternData,
) {}
toJSON(): any {
return {
experimentalPuzzleName: this.kpuzzle.name(),
patternData: this.patternData,
};
}
static fromTransformation(transformation: KTransformation): KPattern {
const newPatternData = applyTransformationDataToKPatternData(
transformation.kpuzzle.definition,
transformation.kpuzzle.definition.defaultPattern,
transformation.transformationData,
);
return new KPattern(transformation.kpuzzle, newPatternData);
}
// Convenience function
/** @deprecated */
apply(source: KTransformationSource): KPattern {
return this.applyTransformation(this.kpuzzle.toTransformation(source));
}
applyTransformation(transformation: KTransformation): KPattern {
if (transformation.isIdentityTransformation()) {
return new KPattern(this.kpuzzle, this.patternData);
}
const newPatternData = applyTransformationDataToKPatternData(
this.kpuzzle.definition,
this.patternData,
transformation.transformationData,
);
return new KPattern(this.kpuzzle, newPatternData);
}
applyMove(move: Move | string): KPattern {
return this.applyTransformation(this.kpuzzle.moveToTransformation(move));
}
applyAlg(alg: Alg | string): KPattern {
return this.applyTransformation(this.kpuzzle.algToTransformation(alg));
}
isIdentical(other: KPattern): boolean {
return isPatternDataIdentical(
this.kpuzzle,
this.patternData,
other.patternData,
);
}
/** @deprecated */
experimentalToTransformation(): KTransformation | null {
if (!this.kpuzzle.canConvertDefaultPatternToUniqueTransformation()) {
return null;
}
const transformationData: KTransformationData = {};
for (const [orbitName, patternOrbitData] of Object.entries(
this.patternData,
)) {
const transformationOrbit: KTransformationOrbitData = {
permutation: patternOrbitData.pieces,
orientationDelta: patternOrbitData.orientation,
};
transformationData[orbitName] = transformationOrbit;
}
return new KTransformation(this.kpuzzle, transformationData);
}
experimentalIsSolved(options: {
ignorePuzzleOrientation: boolean;
ignoreCenterOrientation: boolean;
}): boolean {
if (!this.kpuzzle.definition.experimentalIsPatternSolved) {
throw new Error(
"`KPattern.experimentalIsPatternSolved()` is not supported for this puzzle at the moment.",
);
}
return this.kpuzzle.definition.experimentalIsPatternSolved(this, options);
}
}