@dchighs/dc-config-mapper 0.2.2 → 0.3.1

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./data-compiler";
 export * from "./mappers";
+export { resolveGridDecorationPositions } from "./utils";

package/dist/index.js

@@ -14,5 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveGridDecorationPositions = void 0;
 __exportStar(require("./data-compiler"), exports);
 __exportStar(require("./mappers"), exports);
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "resolveGridDecorationPositions", { enumerable: true, get: function () { return utils_1.resolveGridDecorationPositions; } });

package/dist/mappers/grid-islands.mapper.d.ts

@@ -0,0 +1,108 @@
+import { Localization } from "@dchighs/dc-localization";
+import { GameConfigDto } from "@dchighs/dc-config";
+type GridIslandsDto = GameConfigDto["game_data"]["config"]["grid_island"];
+export declare class GridIslandsMapper {
+    readonly localization: Localization;
+    constructor(localization: Localization);
+    map(gridIslands: GridIslandsDto): {
+        islands: import("@dchighs/dc-localization/dist/types").Translated<{
+            id: number;
+            min_level: number;
+            availability: {
+                from: string;
+                to: string;
+            };
+            name_key: string;
+            sound_tag: string;
+            zip_file_name: string;
+            currency_id: number;
+            pool: {
+                points: number;
+                time: number;
+            };
+            initial_points: number;
+            board_size: {
+                width: number;
+                height: number;
+            };
+            initial_square_id: number;
+            episode_ids: number[];
+        }>[];
+        episodes: import("@dchighs/dc-localization/dist/types").Translated<{
+            id: number;
+            board_size: {
+                width: number;
+                height: number;
+            };
+            initial_square_id: number;
+            final_square_id: number;
+            name_key: string;
+            square_ids: number[];
+            decoration_ids: number[];
+        }>[];
+        squares: {
+            id: number;
+            type: string;
+            reward: {
+                chest_id: number | undefined;
+                type: string;
+            } | {
+                dragon_id: number | undefined;
+                type: string;
+            } | null;
+            highlight: number;
+            x: number;
+            y: number;
+            claim_cost: number;
+            wall: string | undefined;
+            wall_suffix: string | undefined;
+        }[];
+        decorations: {
+            id: number;
+            filename: string;
+            x: number;
+            y: number;
+        }[];
+        encounters: {
+            id: number;
+            enemy_ids: number[];
+            speed_up_price_per_hour: number;
+            fight_background: string;
+            fight_background_id: string;
+        }[];
+        enemies: {
+            id: number;
+            dragon_ids: Array<number>;
+            handicaps: Array<number>;
+            view_type: string;
+            elements_view_type: Array<any>;
+            cooldown: number;
+        }[];
+        currencies: {
+            id: number;
+            tid_name: string;
+            actions: Array<number>;
+        }[];
+        actions: {
+            id: number;
+            type: string;
+            tid_name: string;
+            image: string;
+            pool_percent: number;
+            max_points: number;
+            extra_parameters?: {
+                max_time?: number;
+                cooldown?: number;
+                max_control_level?: number;
+                max_production?: number;
+                max_level?: number;
+            };
+        }[];
+        parameters: {
+            id: number;
+            name: string;
+            value: any;
+        }[];
+    };
+}
+export {};

package/dist/mappers/grid-islands.mapper.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GridIslandsMapper = void 0;
+const island_schema_1 = require("../schemas/islands/grid-islands/island.schema");
+const episode_schema_1 = require("../schemas/islands/grid-islands/episode.schema");
+const square_schema_1 = require("../schemas/islands/grid-islands/square.schema");
+const decoration_schema_1 = require("../schemas/islands/grid-islands/decoration.schema");
+const encounter_schema_1 = require("../schemas/islands/grid-islands/encounter.schema");
+class GridIslandsMapper {
+    constructor(localization) {
+        this.localization = localization;
+    }
+    map(gridIslands) {
+        return {
+            islands: gridIslands.islands.map(island => this.localization.translate(island_schema_1.gridIslandSchema.parse(island))),
+            episodes: gridIslands.episodes.map(episode => {
+                const decorationIds = gridIslands.decorations
+                    .filter(decoration => decoration.episode_id === episode.id)
+                    .map(decoration => decoration.id);
+                return this.localization.translate(episode_schema_1.gridIslandsEpisodeSchema.parse({
+                    ...episode,
+                    decoration_ids: decorationIds
+                }));
+            }),
+            squares: gridIslands.squares.map(square => square_schema_1.gridIslandsSquareSchema.parse(square)),
+            decorations: gridIslands.decorations.map(decoration => decoration_schema_1.gridIslandsDecorationSchema.parse(decoration)),
+            encounters: gridIslands.encounters.map(encounter => encounter_schema_1.gridIslandsEncounterSchema.parse(encounter)),
+            enemies: gridIslands.enemies,
+            currencies: gridIslands.currencies,
+            actions: gridIslands.actions,
+            parameters: gridIslands.parameters,
+        };
+    }
+}
+exports.GridIslandsMapper = GridIslandsMapper;

package/dist/mappers/index.d.ts

@@ -4,3 +4,4 @@ export * from "./skills.mapper";
 export * from "./heroic-races.mapper";
 export * from "./maze-islands.mapper";
 export * from "./tower-islands.mapper";
+export * from "./grid-islands.mapper";

package/dist/mappers/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./skills.mapper"), exports);
 __exportStar(require("./heroic-races.mapper"), exports);
 __exportStar(require("./maze-islands.mapper"), exports);
 __exportStar(require("./tower-islands.mapper"), exports);
+__exportStar(require("./grid-islands.mapper"), exports);

package/dist/mappers/maze-islands.mapper.d.ts

@@ -99,7 +99,6 @@ export declare class MazeIslandsMapper {
             };
             initial_points: number;
             min_level: number;
-            mobile_tutorial_id: number;
             zip_file_name: string;
             sound_tag: string;
         }>[];

package/dist/mappers/tower-islands.mapper.d.ts

@@ -20,7 +20,6 @@ export declare class TowerIslandsMapper {
             initial_points: number;
             currency_id: number;
             min_level: number;
-            tower_size: number[];
             zip_file_name: string;
             sound_tag: string;
             max_die_roll: number;
@@ -28,6 +27,10 @@ export declare class TowerIslandsMapper {
             square_ids: number[];
             floor_ids: number[];
             reward_ids: number[];
+            board_size: {
+                width: number;
+                height: number;
+            };
         }>[];
         floors: import("@dchighs/dc-localization/dist/types").Translated<{
             id: number;

package/dist/schemas/islands/grid-islands/decoration.schema.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const gridIslandsDecorationSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodNumber;
+    file: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    island_id: z.ZodNumber;
+    episode_id: z.ZodNumber;
+}, z.core.$strict>, z.ZodTransform<{
+    id: number;
+    filename: string;
+    x: number;
+    y: number;
+}, {
+    id: number;
+    file: string;
+    x: number;
+    y: number;
+    island_id: number;
+    episode_id: number;
+}>>;

package/dist/schemas/islands/grid-islands/decoration.schema.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gridIslandsDecorationSchema = void 0;
+const zod_1 = require("zod");
+exports.gridIslandsDecorationSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    file: zod_1.z.string(),
+    x: zod_1.z.number(),
+    y: zod_1.z.number(),
+    island_id: zod_1.z.number(),
+    episode_id: zod_1.z.number(),
+}).strict().transform(data => {
+    return {
+        id: data.id,
+        filename: data.file,
+        x: data.x,
+        y: data.y,
+    };
+});

package/dist/schemas/islands/grid-islands/encounter.schema.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export declare const gridIslandsEncounterSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodNumber;
+    enemies: z.ZodArray<z.ZodNumber>;
+    speed_up_price_per_hour: z.ZodNumber;
+    fight_background: z.ZodString;
+    fight_background_id: z.ZodString;
+}, z.core.$strict>, z.ZodTransform<{
+    id: number;
+    enemy_ids: number[];
+    speed_up_price_per_hour: number;
+    fight_background: string;
+    fight_background_id: string;
+}, {
+    id: number;
+    enemies: number[];
+    speed_up_price_per_hour: number;
+    fight_background: string;
+    fight_background_id: string;
+}>>;

package/dist/schemas/islands/grid-islands/encounter.schema.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gridIslandsEncounterSchema = void 0;
+const zod_1 = require("zod");
+exports.gridIslandsEncounterSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    enemies: zod_1.z.array(zod_1.z.number()),
+    speed_up_price_per_hour: zod_1.z.number(),
+    fight_background: zod_1.z.string(),
+    fight_background_id: zod_1.z.string(),
+}).strict().transform(data => {
+    return {
+        id: data.id,
+        enemy_ids: data.enemies,
+        speed_up_price_per_hour: data.speed_up_price_per_hour,
+        fight_background: data.fight_background,
+        fight_background_id: data.fight_background_id,
+    };
+});

package/dist/schemas/islands/grid-islands/episode.schema.d.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+export declare const gridIslandsEpisodeSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodNumber;
+    island_id: z.ZodNumber;
+    board_size: z.ZodArray<z.ZodNumber>;
+    initial_square_id: z.ZodNumber;
+    final_square_id: z.ZodNumber;
+    tid_title: z.ZodString;
+    mobile_begin_tutorial_id: z.ZodNumber;
+    mobile_end_tutorial_id: z.ZodNumber;
+    canvas_background: z.ZodString;
+    backgrounds: z.ZodArray<z.ZodString>;
+    background_plist: z.ZodString;
+    foregrounds: z.ZodArray<z.ZodAny>;
+    foregrounds_plists: z.ZodArray<z.ZodAny>;
+    squares: z.ZodArray<z.ZodNumber>;
+    decoration_ids: z.ZodArray<z.ZodNumber>;
+}, z.core.$strict>, z.ZodTransform<{
+    id: number;
+    board_size: {
+        width: number;
+        height: number;
+    };
+    initial_square_id: number;
+    final_square_id: number;
+    name_key: string;
+    square_ids: number[];
+    decoration_ids: number[];
+}, {
+    id: number;
+    island_id: number;
+    board_size: number[];
+    initial_square_id: number;
+    final_square_id: number;
+    tid_title: string;
+    mobile_begin_tutorial_id: number;
+    mobile_end_tutorial_id: number;
+    canvas_background: string;
+    backgrounds: string[];
+    background_plist: string;
+    foregrounds: any[];
+    foregrounds_plists: any[];
+    squares: number[];
+    decoration_ids: number[];
+}>>;

package/dist/schemas/islands/grid-islands/episode.schema.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gridIslandsEpisodeSchema = void 0;
+const zod_1 = require("zod");
+exports.gridIslandsEpisodeSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    island_id: zod_1.z.number(),
+    board_size: zod_1.z.array(zod_1.z.number()),
+    initial_square_id: zod_1.z.number(),
+    final_square_id: zod_1.z.number(),
+    tid_title: zod_1.z.string(),
+    mobile_begin_tutorial_id: zod_1.z.number(),
+    mobile_end_tutorial_id: zod_1.z.number(),
+    canvas_background: zod_1.z.string(),
+    backgrounds: zod_1.z.array(zod_1.z.string()),
+    background_plist: zod_1.z.string(),
+    foregrounds: zod_1.z.array(zod_1.z.any()),
+    foregrounds_plists: zod_1.z.array(zod_1.z.any()),
+    squares: zod_1.z.array(zod_1.z.number()),
+    // injected props
+    decoration_ids: zod_1.z.array(zod_1.z.number())
+}).strict().transform((data) => {
+    return {
+        id: data.id,
+        board_size: {
+            width: data.board_size[0],
+            height: data.board_size[1],
+        },
+        initial_square_id: data.initial_square_id,
+        final_square_id: data.final_square_id,
+        name_key: data.tid_title,
+        square_ids: data.squares,
+        decoration_ids: data.decoration_ids,
+    };
+});

package/dist/schemas/islands/grid-islands/island.schema.d.ts

@@ -0,0 +1,188 @@
+import { z } from "zod";
+export declare const gridIslandSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodNumber;
+    analytics_id: z.ZodString;
+    tid_name: z.ZodString;
+    tutorial_id: z.ZodNumber;
+    tutorial_claimable_cell_id: z.ZodNumber;
+    pool_points: z.ZodNumber;
+    pool_time: z.ZodNumber;
+    initial_points: z.ZodNumber;
+    start_ts: z.ZodNumber;
+    end_ts: z.ZodNumber;
+    currency_id: z.ZodNumber;
+    min_level: z.ZodNumber;
+    building_id: z.ZodNumber;
+    building_position: z.ZodArray<z.ZodNumber>;
+    zip_file: z.ZodString;
+    sound_tag: z.ZodString;
+    canvas_assets_url: z.ZodString;
+    ui_configuration: z.ZodObject<{
+        cell_contents_config: z.ZodObject<{
+            blocked_dragon_position_offset: z.ZodArray<z.ZodNumber>;
+            blocked_opacity: z.ZodNumber;
+            claimable_dragon_position_offset: z.ZodArray<z.ZodNumber>;
+            default_dragon_scale: z.ZodArray<z.ZodNumber>;
+            dragon_scale: z.ZodArray<z.ZodNumber>;
+            dragon_scale_by_id: z.ZodRecord<z.ZodNumber, z.ZodArray<z.ZodNumber>>;
+            icon_position_offset: z.ZodArray<z.ZodNumber>;
+            label_position_offset: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strip>;
+        cell_highlight_asset: z.ZodString;
+        cell_highlight_index: z.ZodNumber;
+        cell_size: z.ZodArray<z.ZodNumber>;
+        cells_label_config: z.ZodObject<{
+            claimable: z.ZodObject<{
+                color: z.ZodArray<z.ZodNumber>;
+                size: z.ZodNumber;
+                stroke_color: z.ZodArray<z.ZodNumber>;
+                stroke_width: z.ZodNumber;
+            }, z.core.$strip>;
+            unclaimable: z.ZodObject<{
+                color: z.ZodArray<z.ZodNumber>;
+                size: z.ZodNumber;
+                stroke_color: z.ZodArray<z.ZodNumber>;
+                stroke_width: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        dragon_evolution: z.ZodNumber;
+        grey_scale_blocked_cells: z.ZodBoolean;
+        island_title_config: z.ZodObject<{
+            down_color: z.ZodArray<z.ZodNumber>;
+            size: z.ZodNumber;
+            small_stroke_color: z.ZodArray<z.ZodNumber>;
+            small_stroke_width: z.ZodNumber;
+            upper_color: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strip>;
+        layers_z_indexes: z.ZodObject<{
+            additional_layer: z.ZodNumber;
+            cell_backgrounds: z.ZodNumber;
+            cell_contents: z.ZodNumber;
+            decorations: z.ZodNumber;
+            player_token: z.ZodNumber;
+            walls: z.ZodNumber;
+        }, z.core.$strip>;
+        origin_offset: z.ZodArray<z.ZodNumber>;
+        tutorial_scroll_duration: z.ZodNumber;
+        tutorial_scroll_duration_base: z.ZodNumber;
+        tutorial_scroll_duration_factor: z.ZodNumber;
+    }, z.core.$strip>;
+    active_platforms: z.ZodObject<{
+        ios: z.ZodNumber;
+        canvas: z.ZodString;
+        android: z.ZodNumber;
+        amazon: z.ZodNumber;
+        windows: z.ZodNumber;
+    }, z.core.$strip>;
+    episodes: z.ZodArray<z.ZodNumber>;
+    board_size: z.ZodArray<z.ZodNumber>;
+    initial_square_id: z.ZodNumber;
+    backgrounds: z.ZodArray<z.ZodNumber>;
+    background_plist: z.ZodString;
+    foregrounds: z.ZodArray<z.ZodAny>;
+    foregrounds_plists: z.ZodArray<z.ZodAny>;
+}, z.core.$strict>, z.ZodTransform<{
+    id: number;
+    min_level: number;
+    availability: {
+        from: string;
+        to: string;
+    };
+    name_key: string;
+    sound_tag: string;
+    zip_file_name: string;
+    currency_id: number;
+    pool: {
+        points: number;
+        time: number;
+    };
+    initial_points: number;
+    board_size: {
+        width: number;
+        height: number;
+    };
+    initial_square_id: number;
+    episode_ids: number[];
+}, {
+    id: number;
+    analytics_id: string;
+    tid_name: string;
+    tutorial_id: number;
+    tutorial_claimable_cell_id: number;
+    pool_points: number;
+    pool_time: number;
+    initial_points: number;
+    start_ts: number;
+    end_ts: number;
+    currency_id: number;
+    min_level: number;
+    building_id: number;
+    building_position: number[];
+    zip_file: string;
+    sound_tag: string;
+    canvas_assets_url: string;
+    ui_configuration: {
+        cell_contents_config: {
+            blocked_dragon_position_offset: number[];
+            blocked_opacity: number;
+            claimable_dragon_position_offset: number[];
+            default_dragon_scale: number[];
+            dragon_scale: number[];
+            dragon_scale_by_id: Record<number, number[]>;
+            icon_position_offset: number[];
+            label_position_offset: number[];
+        };
+        cell_highlight_asset: string;
+        cell_highlight_index: number;
+        cell_size: number[];
+        cells_label_config: {
+            claimable: {
+                color: number[];
+                size: number;
+                stroke_color: number[];
+                stroke_width: number;
+            };
+            unclaimable: {
+                color: number[];
+                size: number;
+                stroke_color: number[];
+                stroke_width: number;
+            };
+        };
+        dragon_evolution: number;
+        grey_scale_blocked_cells: boolean;
+        island_title_config: {
+            down_color: number[];
+            size: number;
+            small_stroke_color: number[];
+            small_stroke_width: number;
+            upper_color: number[];
+        };
+        layers_z_indexes: {
+            additional_layer: number;
+            cell_backgrounds: number;
+            cell_contents: number;
+            decorations: number;
+            player_token: number;
+            walls: number;
+        };
+        origin_offset: number[];
+        tutorial_scroll_duration: number;
+        tutorial_scroll_duration_base: number;
+        tutorial_scroll_duration_factor: number;
+    };
+    active_platforms: {
+        ios: number;
+        canvas: string;
+        android: number;
+        amazon: number;
+        windows: number;
+    };
+    episodes: number[];
+    board_size: number[];
+    initial_square_id: number;
+    backgrounds: number[];
+    background_plist: string;
+    foregrounds: any[];
+    foregrounds_plists: any[];
+}>>;

package/dist/schemas/islands/grid-islands/island.schema.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gridIslandSchema = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const zod_1 = require("zod");
+exports.gridIslandSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    analytics_id: zod_1.z.string(),
+    tid_name: zod_1.z.string(),
+    tutorial_id: zod_1.z.number(),
+    tutorial_claimable_cell_id: zod_1.z.number(),
+    pool_points: zod_1.z.number(),
+    pool_time: zod_1.z.number(),
+    initial_points: zod_1.z.number(),
+    start_ts: zod_1.z.number(),
+    end_ts: zod_1.z.number(),
+    currency_id: zod_1.z.number(),
+    min_level: zod_1.z.number(),
+    building_id: zod_1.z.number(),
+    building_position: zod_1.z.array(zod_1.z.number()),
+    zip_file: zod_1.z.string(),
+    sound_tag: zod_1.z.string(),
+    canvas_assets_url: zod_1.z.string(),
+    ui_configuration: zod_1.z.object({
+        cell_contents_config: zod_1.z.object({
+            blocked_dragon_position_offset: zod_1.z.array(zod_1.z.number()),
+            blocked_opacity: zod_1.z.number(),
+            claimable_dragon_position_offset: zod_1.z.array(zod_1.z.number()),
+            default_dragon_scale: zod_1.z.array(zod_1.z.number()),
+            dragon_scale: zod_1.z.array(zod_1.z.number()),
+            dragon_scale_by_id: zod_1.z.record(zod_1.z.number(), zod_1.z.array(zod_1.z.number())),
+            icon_position_offset: zod_1.z.array(zod_1.z.number()),
+            label_position_offset: zod_1.z.array(zod_1.z.number()),
+        }),
+        cell_highlight_asset: zod_1.z.string(),
+        cell_highlight_index: zod_1.z.number(),
+        cell_size: zod_1.z.array(zod_1.z.number()),
+        cells_label_config: zod_1.z.object({
+            claimable: zod_1.z.object({
+                color: zod_1.z.array(zod_1.z.number()),
+                size: zod_1.z.number(),
+                stroke_color: zod_1.z.array(zod_1.z.number()),
+                stroke_width: zod_1.z.number(),
+            }),
+            unclaimable: zod_1.z.object({
+                color: zod_1.z.array(zod_1.z.number()),
+                size: zod_1.z.number(),
+                stroke_color: zod_1.z.array(zod_1.z.number()),
+                stroke_width: zod_1.z.number(),
+            }),
+        }),
+        dragon_evolution: zod_1.z.number(),
+        grey_scale_blocked_cells: zod_1.z.boolean(),
+        island_title_config: zod_1.z.object({
+            down_color: zod_1.z.array(zod_1.z.number()),
+            size: zod_1.z.number(),
+            small_stroke_color: zod_1.z.array(zod_1.z.number()),
+            small_stroke_width: zod_1.z.number(),
+            upper_color: zod_1.z.array(zod_1.z.number()),
+        }),
+        layers_z_indexes: zod_1.z.object({
+            additional_layer: zod_1.z.number(),
+            cell_backgrounds: zod_1.z.number(),
+            cell_contents: zod_1.z.number(),
+            decorations: zod_1.z.number(),
+            player_token: zod_1.z.number(),
+            walls: zod_1.z.number(),
+        }),
+        origin_offset: zod_1.z.array(zod_1.z.number()),
+        tutorial_scroll_duration: zod_1.z.number(),
+        tutorial_scroll_duration_base: zod_1.z.number(),
+        tutorial_scroll_duration_factor: zod_1.z.number(),
+    }),
+    active_platforms: zod_1.z.object({
+        ios: zod_1.z.number(),
+        canvas: zod_1.z.string(),
+        android: zod_1.z.number(),
+        amazon: zod_1.z.number(),
+        windows: zod_1.z.number(),
+    }),
+    episodes: zod_1.z.array(zod_1.z.number()),
+    board_size: zod_1.z.array(zod_1.z.number()),
+    initial_square_id: zod_1.z.number(),
+    backgrounds: zod_1.z.array(zod_1.z.number()),
+    background_plist: zod_1.z.string(),
+    foregrounds: zod_1.z.array(zod_1.z.any()),
+    foregrounds_plists: zod_1.z.array(zod_1.z.any()),
+}).strict().transform(data => {
+    return {
+        id: data.id,
+        min_level: data.min_level,
+        availability: {
+            from: new Date(data.start_ts * 1000).toISOString(),
+            to: new Date(data.end_ts * 1000).toISOString(),
+        },
+        name_key: data.tid_name,
+        sound_tag: data.sound_tag,
+        zip_file_name: node_path_1.default.basename(data.zip_file),
+        currency_id: data.currency_id,
+        pool: {
+            points: data.pool_points,
+            time: data.pool_time,
+        },
+        initial_points: data.initial_points,
+        board_size: {
+            width: data.board_size[0],
+            height: data.board_size[1],
+        },
+        initial_square_id: data.initial_square_id,
+        episode_ids: data.episodes,
+    };
+});

package/dist/schemas/islands/grid-islands/square.schema.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+export declare const gridIslandsSquareSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodNumber;
+    type: z.ZodString;
+    type_id: z.ZodOptional<z.ZodNumber>;
+    highlight: z.ZodNumber;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    island_id: z.ZodNumber;
+    episode_id: z.ZodNumber;
+    claim_cost: z.ZodNumber;
+    wall: z.ZodOptional<z.ZodString>;
+    wall_suffix: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodTransform<{
+    id: number;
+    type: string;
+    reward: {
+        chest_id: number | undefined;
+        type: string;
+    } | {
+        dragon_id: number | undefined;
+        type: string;
+    } | null;
+    highlight: number;
+    x: number;
+    y: number;
+    claim_cost: number;
+    wall: string | undefined;
+    wall_suffix: string | undefined;
+}, {
+    id: number;
+    type: string;
+    highlight: number;
+    x: number;
+    y: number;
+    island_id: number;
+    episode_id: number;
+    claim_cost: number;
+    type_id?: number | undefined;
+    wall?: string | undefined;
+    wall_suffix?: string | undefined;
+}>>;

package/dist/schemas/islands/grid-islands/square.schema.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gridIslandsSquareSchema = void 0;
+const zod_1 = require("zod");
+exports.gridIslandsSquareSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    type: zod_1.z.string(),
+    type_id: zod_1.z.number().optional(),
+    highlight: zod_1.z.number(),
+    x: zod_1.z.number(),
+    y: zod_1.z.number(),
+    island_id: zod_1.z.number(),
+    episode_id: zod_1.z.number(),
+    claim_cost: zod_1.z.number(),
+    wall: zod_1.z.string().optional(),
+    wall_suffix: zod_1.z.string().optional()
+}).strict().transform(data => {
+    return {
+        id: data.id,
+        type: data.type,
+        reward: data.type === "NONE" ? null : {
+            type: data.type.toLowerCase(),
+            ...(data.type === "CHEST" ? {
+                chest_id: data.type_id,
+            } : {
+                dragon_id: data.type_id,
+            })
+        },
+        highlight: data.highlight,
+        x: data.x,
+        y: data.y,
+        claim_cost: data.claim_cost,
+        wall: data.wall,
+        wall_suffix: data.wall_suffix,
+    };
+});

package/dist/schemas/islands/maze-islands/island.schema.d.ts

@@ -50,7 +50,6 @@ export declare const mazeIslandSchema: z.ZodPipe<z.ZodObject<{
     };
     initial_points: number;
     min_level: number;
-    mobile_tutorial_id: number;
     zip_file_name: string;
     sound_tag: string;
 }, {

package/dist/schemas/islands/maze-islands/island.schema.js

@@ -58,7 +58,6 @@ exports.mazeIslandSchema = zod_1.z.object({
         },
         initial_points: data.initial_points,
         min_level: data.min_level,
-        mobile_tutorial_id: data.mobile_tutorial_id,
         zip_file_name: node_path_1.default.basename(data.zip_file),
         sound_tag: data.sound_tag,
     };

package/dist/schemas/islands/tower-islands/island.schema.d.ts

@@ -52,7 +52,6 @@ export declare const towerIslandSchema: z.ZodPipe<z.ZodObject<{
     initial_points: number;
     currency_id: number;
     min_level: number;
-    tower_size: number[];
     zip_file_name: string;
     sound_tag: string;
     max_die_roll: number;
@@ -60,6 +59,10 @@ export declare const towerIslandSchema: z.ZodPipe<z.ZodObject<{
     square_ids: number[];
     floor_ids: number[];
     reward_ids: number[];
+    board_size: {
+        width: number;
+        height: number;
+    };
 }, {
     id: number;
     analytics_id: string;

package/dist/schemas/islands/tower-islands/island.schema.js

@@ -61,7 +61,6 @@ exports.towerIslandSchema = zod_1.z.object({
         initial_points: data.initial_points,
         currency_id: data.currency_id,
         min_level: data.min_level,
-        tower_size: data.tower_size,
         zip_file_name: node_path_1.default.basename(data.zip_file),
         sound_tag: data.sound_tag,
         max_die_roll: data.max_die_roll,
@@ -69,5 +68,9 @@ exports.towerIslandSchema = zod_1.z.object({
         square_ids: data.square_ids,
         floor_ids: data.floor_ids,
         reward_ids: data.reward_ids,
+        board_size: {
+            width: data.tower_size[0],
+            height: data.tower_size[1],
+        },
     };
 });

package/dist/utils/index.d.ts

@@ -3,3 +3,4 @@ export * from "./record-keys-conversor.util";
 export * from "./element-map.util";
 export * from "./process-rewards.util";
 export * from "./process-price.util";
+export * from "./resolve-grid-decoration-positions.util";

package/dist/utils/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./record-keys-conversor.util"), exports);
 __exportStar(require("./element-map.util"), exports);
 __exportStar(require("./process-rewards.util"), exports);
 __exportStar(require("./process-price.util"), exports);
+__exportStar(require("./resolve-grid-decoration-positions.util"), exports);

package/dist/utils/resolve-grid-decoration-positions.util.d.ts

@@ -0,0 +1,20 @@
+import { GameConfigDto } from "@dchighs/dc-config";
+type Square = GameConfigDto["game_data"]["config"]["grid_island"]["squares"][number];
+type Decoration = GameConfigDto["game_data"]["config"]["grid_island"]["decorations"][number];
+type resolveGridDecorationpositionsOptions = {
+    squares: Square[];
+    decorations: Decoration[];
+    boardSize: {
+        width: number;
+        height: number;
+    };
+};
+export declare function resolveGridDecorationPositions({ squares, decorations, boardSize }: resolveGridDecorationpositionsOptions): {
+    id: number;
+    file: string;
+    x: number;
+    y: number;
+    island_id: number;
+    episode_id: number;
+}[];
+export {};

package/dist/utils/resolve-grid-decoration-positions.util.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveGridDecorationPositions = resolveGridDecorationPositions;
+function resolveGridDecorationPositions({ squares, decorations, boardSize }) {
+    const squaresBoard = [];
+    for (const square of squares) {
+        squaresBoard.push(`${square.x},${square.y}`);
+    }
+    const decorationPositions = [];
+    const resolvedDecorations = [];
+    for (let x = 1; x < boardSize.width + 1; x++) {
+        for (let y = 1; y < boardSize.height + 1; y++) {
+            if (!squaresBoard.includes(`${x},${y}`)) {
+                decorationPositions.push(`${x},${y}`);
+            }
+        }
+    }
+    if (decorationPositions.length !== decorations.length) {
+        throw new Error("Number of decoration positions does not match number of decorations");
+    }
+    for (let i = 0; i < decorations.length; i++) {
+        const decorationPosition = decorationPositions[i];
+        const [x, y] = decorationPosition.split(",").map(Number);
+        resolvedDecorations.push({
+            ...decorations[i],
+            x: x,
+            y: y
+        });
+    }
+    return resolvedDecorations;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dchighs/dc-config-mapper",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "description": "A opined library to restructure and populate configuration for Dragon City.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -17,7 +17,8 @@
     "dc highs"
   ],
   "scripts": {
-    "build": "tsc"
+    "build": "tsc",
+    "playground": "ts-node ./playground/index.ts"
   },
   "author": "Marcuth",
   "license": "MIT",