step-sequence-generator/dist/modules/sequence-generator/SequenceGeneratorFactory.js

A step sequence generator for figure skating programs

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.SequenceGeneratorFactory = void 0;
const MovementLibrary_1 = require("../movement/MovementLibrary");
const StepContext_1 = require("./StepContext");
const StepCounter_1 = require("../step-counter/StepCounter");
const StepTracker_1 = require("../sequence-tracker/StepTracker");
const start_coordinates_1 = require("../../shared/constants/start-coordinates");
const vectors_track_1 = require("../../shared/constants/vectors-track");
const vector_angles_1 = require("../../shared/constants/vector-angles");
const generator_type_enum_1 = require("../../shared/enums/generator-type.enum");
const DefaultStepSequenceGenerator_1 = require("./DefaultStepSequenceGenerator");
const ThreeTurnsBlockGenerator_1 = require("./ThreeTurnsBlockGenerator");
const ThreeDifficultTurnsBlockCounter_1 = require("../step-counter/ThreeDifficultTurnsBlockCounter");
const FilterCompositeMapFactory_1 = require("../filter-strategy/FilterCompositeMapFactory");
const filter_stategy_name_enum_1 = require("../../shared/enums/filter-stategy-name.enum");
const VectorKeyChanceRatioMapGenerator_1 = require("../chance-ratio-map-generator/VectorKeyChanceRatioMapGenerator");
const CompassArc_1 = require("../sequence-tracker/CompassArc");
const WeightCalculator_1 = require("../roulette/weight-calculator/WeightCalculator");
const Roulette_1 = require("../roulette/Roulette");
const NumberGenerator_1 = require("../roulette/number-generator/NumberGenerator");
const MovementChanceRatioMapGenerator_1 = require("../chance-ratio-map-generator/MovementChanceRatioMapGenerator");
class SequenceGeneratorFactory {
    static create(type, data) {
        switch (type) {
            case generator_type_enum_1.GeneratorType.DEFAULT:
                return this.createDefaultGenerator(data);
            case generator_type_enum_1.GeneratorType.THREE_TURNS_BLOCK:
                return this.createThreeTurnsBlockGenerator(data);
            default:
                throw new Error(`Unsupported generator type ${type}`);
        }
    }
    static createDefaultGenerator(data) {
        return new DefaultStepSequenceGenerator_1.DefaultStepSequenceGenerator({
            ...this.createBaseConfig(data),
            ...this.createDefaultConfig(),
            threeTurnsBlockGenerator: this.createThreeTurnsBlockGenerator(data),
        });
    }
    static createThreeTurnsBlockGenerator(data) {
        return new ThreeTurnsBlockGenerator_1.ThreeTurnsBlockGenerator({
            ...this.createBaseConfig(data),
            ...this.createThreeTurnsBlockConfig(),
        });
    }
    static createBaseConfig(data) {
        const roulette = new Roulette_1.Roulette({
            weightCalc: new WeightCalculator_1.WeightCalculator(),
            numberGenerator: new NumberGenerator_1.NumberGenerator(),
        });
        return {
            library: new MovementLibrary_1.MovementLibrary(data),
            context: new StepContext_1.StepContext(),
            chanceRatioMapGenerator: new MovementChanceRatioMapGenerator_1.MovementChanceRatioMapGenerator(),
            roulette,
            tracker: new StepTracker_1.StepTracker({
                standardStartCoordinates: start_coordinates_1.START_COORDINATES,
                vectorsTrack: vectors_track_1.VECTORS_TRACK,
                vectorAngles: vector_angles_1.VECTOR_ANGLES,
                vectorKeyChanceRatioMapGenerator: new VectorKeyChanceRatioMapGenerator_1.VectorKeyChanceRatioMapGenerator(),
                roulette,
            }),
            compassArc: new CompassArc_1.CompassArc(),
        };
    }
    static createDefaultConfig() {
        const filterStrategy = FilterCompositeMapFactory_1.FilterCompositeMapFactory.createMap([
            filter_stategy_name_enum_1.FilterStrategyName.DEFAULT,
            filter_stategy_name_enum_1.FilterStrategyName.IS_CHANGE_LEG,
        ]);
        return {
            counter: new StepCounter_1.StepCounter(),
            filterStrategy: filterStrategy,
        };
    }
    static createThreeTurnsBlockConfig() {
        const filterStrategy = FilterCompositeMapFactory_1.FilterCompositeMapFactory.createMap([
            filter_stategy_name_enum_1.FilterStrategyName.THREE_DIFFICULT_TURNS,
        ]);
        return {
            counter: new ThreeDifficultTurnsBlockCounter_1.ThreeDifficultTurnsBlockCounter(),
            filterStrategy: filterStrategy,
        };
    }
    createMapCompositeFilters() { }
}
exports.SequenceGeneratorFactory = SequenceGeneratorFactory;
SequenceGeneratorFactory.generator = new Map([
    [generator_type_enum_1.GeneratorType.DEFAULT, DefaultStepSequenceGenerator_1.DefaultStepSequenceGenerator],
    [generator_type_enum_1.GeneratorType.THREE_TURNS_BLOCK, ThreeTurnsBlockGenerator_1.ThreeTurnsBlockGenerator],
]);