@dchighs/dc-config-mapper 0.1.4 → 0.2.0

package/dist/mappers/index.d.ts

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

package/dist/mappers/index.js

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

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

@@ -86,6 +86,7 @@ export declare class MazeIslandsMapper {
         islands: import("@dchighs/dc-localization/dist/types").Translated<{
             id: number;
             name: string;
+            name_key: string;
             availability: {
                 from: string;
                 to: string;

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

@@ -0,0 +1,97 @@
+import { Localization } from "@dchighs/dc-localization";
+import { GameConfigDto } from "@dchighs/dc-config";
+export type TowerIslandsDto = GameConfigDto["game_data"]["config"]["tower_island"];
+export declare class TowerIslandsMapper {
+    readonly localization: Localization;
+    constructor(localization: Localization);
+    map(data: TowerIslandsDto): {
+        islands: import("@dchighs/dc-localization/dist/types").Translated<{
+            id: number;
+            name_key: string;
+            availability: {
+                from: string;
+                to: string;
+            };
+            initial_square_id: number;
+            pool: {
+                size: number;
+                time: number;
+            };
+            initial_points: number;
+            currency_id: number;
+            min_level: number;
+            tower_size: number[];
+            zip_file_name: string;
+            sound_tag: string;
+            max_die_roll: number;
+            help_view_id: number;
+            square_ids: number[];
+            floor_ids: number[];
+        }>[];
+        floors: import("@dchighs/dc-localization/dist/types").Translated<{
+            id: number;
+            y: number;
+            x_flip: boolean;
+            floor_image: string;
+            area: number;
+            roll_die_price: number;
+        }>[];
+        squares: import("@dchighs/dc-localization/dist/types").Translated<{
+            id: number;
+            type: string;
+            is_highlight: boolean;
+            x: number;
+            y: number;
+            ixy: string;
+            rewards: {
+                chest?: number | undefined;
+                egg?: number | undefined;
+            }[] | undefined;
+            wall: string | undefined;
+            catapult_destination_square_id: number | undefined;
+            piece_reward_id: number | undefined;
+        }>[];
+        rewards: import("@dchighs/dc-localization/dist/types").Translated<{
+            id: number;
+            dragon_id: number;
+            last_piece_cost: number;
+            pieces_count: number;
+            show_new_badge: boolean;
+            area: number;
+        }>[];
+        happy_hours: import("@dchighs/dc-localization/dist/types").Translated<{
+            id: number;
+            availability: {
+                from: number;
+                to: number;
+            };
+            island_id: number;
+            discount: number;
+        }>[];
+        parameters: import("@dchighs/dc-localization/dist/types").Translated<{
+            id: number;
+            name: string;
+            value: any;
+        }>[];
+        currencies: import("@dchighs/dc-localization/dist/types").Translated<{
+            id: number;
+            tid_name: string;
+            actions: Array<number>;
+        }>[];
+        actions: import("@dchighs/dc-localization/dist/types").Translated<{
+            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;
+            };
+        }>[];
+    };
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TowerIslandsMapper = void 0;
+const island_schema_1 = require("../schemas/islands/tower-islands/island.schema");
+const square_schema_1 = require("../schemas/islands/tower-islands/square.schema");
+const floor_schema_1 = require("../schemas/islands/tower-islands/floor.schema");
+const reward_schema_1 = require("../schemas/islands/tower-islands/reward.schema");
+class TowerIslandsMapper {
+    constructor(localization) {
+        this.localization = localization;
+    }
+    map(data) {
+        return {
+            islands: data.islands.map(island => {
+                const squareIds = data.squares.filter(square => square.island_id === island.id).map(square => square.id);
+                const floorIds = data.floors.filter(floor => floor.island_id === island.id).map(floor => floor.id);
+                return this.localization.translate(island_schema_1.towerIslandSchema.parse({
+                    ...island,
+                    square_ids: squareIds,
+                    floor_ids: floorIds
+                }));
+            }),
+            floors: data.floors.map(floor => this.localization.translate(floor_schema_1.towerIslandsFloorSchema.parse(floor))),
+            squares: data.squares.map(square => this.localization.translate(square_schema_1.towerIslandsSquareSchema.parse(square))),
+            rewards: data.rewards.map(reward => this.localization.translate(reward_schema_1.towerIslandsRewardSchema.parse(reward))),
+            happy_hours: data.happy_hours.map(happyHour => this.localization.translate(happyHour)),
+            parameters: data.parameters.map(parameter => this.localization.translate(parameter)),
+            currencies: data.currencies.map(currency => this.localization.translate(currency)),
+            actions: data.actions.map(action => this.localization.translate(action)),
+        };
+    }
+}
+exports.TowerIslandsMapper = TowerIslandsMapper;

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

@@ -37,6 +37,7 @@ export declare const mazeIslandSchema: z.ZodPipe<z.ZodObject<{
 }, z.core.$strict>, z.ZodTransform<{
     id: number;
     name: string;
+    name_key: string;
     availability: {
         from: string;
         to: string;

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

@@ -45,6 +45,7 @@ exports.mazeIslandSchema = zod_1.z.object({
     return {
         id: data.id,
         name: data.name,
+        name_key: data.tid_name,
         availability: {
             from: new Date(data.availability.from * 1000).toISOString(),
             to: new Date(data.availability.to * 1000).toISOString(),

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

@@ -0,0 +1,29 @@
+import { z } from "zod";
+export declare const towerIslandsFloorSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodNumber;
+    y: z.ZodNumber;
+    x_flip: z.ZodNumber;
+    floor_image: z.ZodString;
+    area: z.ZodNumber;
+    roll_die_price: z.ZodObject<{
+        ep: z.ZodNumber;
+    }, z.core.$strip>;
+    island_id: z.ZodNumber;
+}, z.core.$strict>, z.ZodTransform<{
+    id: number;
+    y: number;
+    x_flip: boolean;
+    floor_image: string;
+    area: number;
+    roll_die_price: number;
+}, {
+    id: number;
+    y: number;
+    x_flip: number;
+    floor_image: string;
+    area: number;
+    roll_die_price: {
+        ep: number;
+    };
+    island_id: number;
+}>>;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.towerIslandsFloorSchema = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../../utils");
+exports.towerIslandsFloorSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    y: zod_1.z.number(),
+    x_flip: zod_1.z.number(),
+    floor_image: zod_1.z.string(),
+    area: zod_1.z.number(),
+    roll_die_price: zod_1.z.object({
+        ep: zod_1.z.number(),
+    }),
+    island_id: zod_1.z.number(),
+}).strict().transform(data => {
+    return {
+        id: data.id,
+        y: data.y,
+        x_flip: (0, utils_1.numberToBoolean)(data.x_flip),
+        floor_image: data.floor_image,
+        area: data.area,
+        roll_die_price: data.roll_die_price.ep,
+    };
+});

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

@@ -0,0 +1,98 @@
+import { z } from "zod";
+export declare const towerIslandSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodNumber;
+    analytics_id: z.ZodString;
+    tid_name: z.ZodString;
+    start_ts: z.ZodNumber;
+    end_ts: z.ZodNumber;
+    initial_square_id: z.ZodNumber;
+    tutorial_id: z.ZodNumber;
+    tutorial_die_result: z.ZodNumber;
+    pool_size: z.ZodNumber;
+    pool_time: z.ZodNumber;
+    initial_points: z.ZodNumber;
+    currency_id: z.ZodNumber;
+    min_level: z.ZodNumber;
+    building_id: z.ZodNumber;
+    building_position: z.ZodArray<z.ZodNumber>;
+    tower_size: z.ZodArray<z.ZodNumber>;
+    zip_file: z.ZodString;
+    sound_tag: z.ZodString;
+    canvas_assets_url: z.ZodString;
+    mobile_first_floor_position: z.ZodArray<z.ZodNumber>;
+    mobile_floor_height: z.ZodNumber;
+    mobile_interior_wall_margin: z.ZodNumber;
+    mobile_final_dragon_scale: z.ZodArray<z.ZodNumber>;
+    mobile_final_dragon_position: z.ZodArray<z.ZodNumber>;
+    mobile_final_dragon_info_position: z.ZodArray<z.ZodNumber>;
+    max_die_roll: z.ZodNumber;
+    help_view_id: z.ZodNumber;
+    active_platforms: z.ZodObject<{
+        ios: z.ZodArray<z.ZodNumber>;
+        canvas: z.ZodArray<z.ZodNumber>;
+        android: z.ZodArray<z.ZodNumber>;
+        amazon: z.ZodArray<z.ZodNumber>;
+        windows: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>;
+    square_ids: z.ZodArray<z.ZodNumber>;
+    floor_ids: z.ZodArray<z.ZodNumber>;
+}, z.core.$strict>, z.ZodTransform<{
+    id: number;
+    name_key: string;
+    availability: {
+        from: string;
+        to: string;
+    };
+    initial_square_id: number;
+    pool: {
+        size: number;
+        time: number;
+    };
+    initial_points: number;
+    currency_id: number;
+    min_level: number;
+    tower_size: number[];
+    zip_file_name: string;
+    sound_tag: string;
+    max_die_roll: number;
+    help_view_id: number;
+    square_ids: number[];
+    floor_ids: number[];
+}, {
+    id: number;
+    analytics_id: string;
+    tid_name: string;
+    start_ts: number;
+    end_ts: number;
+    initial_square_id: number;
+    tutorial_id: number;
+    tutorial_die_result: number;
+    pool_size: number;
+    pool_time: number;
+    initial_points: number;
+    currency_id: number;
+    min_level: number;
+    building_id: number;
+    building_position: number[];
+    tower_size: number[];
+    zip_file: string;
+    sound_tag: string;
+    canvas_assets_url: string;
+    mobile_first_floor_position: number[];
+    mobile_floor_height: number;
+    mobile_interior_wall_margin: number;
+    mobile_final_dragon_scale: number[];
+    mobile_final_dragon_position: number[];
+    mobile_final_dragon_info_position: number[];
+    max_die_roll: number;
+    help_view_id: number;
+    active_platforms: {
+        ios: number[];
+        canvas: number[];
+        android: number[];
+        amazon: number[];
+        windows: number[];
+    };
+    square_ids: number[];
+    floor_ids: number[];
+}>>;

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

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.towerIslandSchema = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const zod_1 = require("zod");
+exports.towerIslandSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    analytics_id: zod_1.z.string(),
+    tid_name: zod_1.z.string(),
+    start_ts: zod_1.z.number(),
+    end_ts: zod_1.z.number(),
+    initial_square_id: zod_1.z.number(),
+    tutorial_id: zod_1.z.number(),
+    tutorial_die_result: zod_1.z.number(),
+    pool_size: zod_1.z.number(),
+    pool_time: zod_1.z.number(),
+    initial_points: 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()),
+    tower_size: 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(),
+    mobile_first_floor_position: zod_1.z.array(zod_1.z.number()),
+    mobile_floor_height: zod_1.z.number(),
+    mobile_interior_wall_margin: zod_1.z.number(),
+    mobile_final_dragon_scale: zod_1.z.array(zod_1.z.number()),
+    mobile_final_dragon_position: zod_1.z.array(zod_1.z.number()),
+    mobile_final_dragon_info_position: zod_1.z.array(zod_1.z.number()),
+    max_die_roll: zod_1.z.number(),
+    help_view_id: zod_1.z.number(),
+    active_platforms: zod_1.z.object({
+        ios: zod_1.z.array(zod_1.z.number()),
+        canvas: zod_1.z.array(zod_1.z.number()),
+        android: zod_1.z.array(zod_1.z.number()),
+        amazon: zod_1.z.array(zod_1.z.number()),
+        windows: zod_1.z.array(zod_1.z.number()),
+    }),
+    // injected properties
+    square_ids: zod_1.z.array(zod_1.z.number()),
+    floor_ids: zod_1.z.array(zod_1.z.number()),
+}).strict().transform(data => {
+    return {
+        id: data.id,
+        name_key: data.tid_name,
+        availability: {
+            from: new Date(data.start_ts * 1000).toISOString(),
+            to: new Date(data.end_ts * 1000).toISOString(),
+        },
+        initial_square_id: data.initial_square_id,
+        pool: {
+            size: data.pool_size,
+            time: data.pool_time,
+        },
+        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,
+        help_view_id: data.help_view_id,
+        square_ids: data.square_ids,
+        floor_ids: data.floor_ids,
+    };
+});

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

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export declare const towerIslandsRewardSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodNumber;
+    dragon_reward_id: z.ZodNumber;
+    last_piece_cost: z.ZodNumber;
+    num_pieces: z.ZodNumber;
+    show_new_badge: z.ZodNumber;
+    area: z.ZodNumber;
+    island_id: z.ZodNumber;
+}, z.core.$strict>, z.ZodTransform<{
+    id: number;
+    dragon_id: number;
+    last_piece_cost: number;
+    pieces_count: number;
+    show_new_badge: boolean;
+    area: number;
+}, {
+    id: number;
+    dragon_reward_id: number;
+    last_piece_cost: number;
+    num_pieces: number;
+    show_new_badge: number;
+    area: number;
+    island_id: number;
+}>>;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.towerIslandsRewardSchema = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../../utils");
+exports.towerIslandsRewardSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    dragon_reward_id: zod_1.z.number(),
+    last_piece_cost: zod_1.z.number(),
+    num_pieces: zod_1.z.number(),
+    show_new_badge: zod_1.z.number(),
+    area: zod_1.z.number(),
+    island_id: zod_1.z.number(),
+}).strict().transform(data => {
+    return {
+        id: data.id,
+        dragon_id: data.dragon_reward_id,
+        last_piece_cost: data.last_piece_cost,
+        pieces_count: data.num_pieces,
+        show_new_badge: (0, utils_1.numberToBoolean)(data.show_new_badge),
+        area: data.area,
+    };
+});

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

@@ -0,0 +1,46 @@
+import { z } from "zod";
+export declare const towerIslandsSquareSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodNumber;
+    type: z.ZodString;
+    highlight: z.ZodNumber;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    island_id: z.ZodNumber;
+    ixy: z.ZodString;
+    rewards_array: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        chest: z.ZodOptional<z.ZodNumber>;
+        egg: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    wall: z.ZodOptional<z.ZodString>;
+    catapult_destination_square_id: z.ZodOptional<z.ZodNumber>;
+    piece_reward_id: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodTransform<{
+    id: number;
+    type: string;
+    is_highlight: boolean;
+    x: number;
+    y: number;
+    ixy: string;
+    rewards: {
+        chest?: number | undefined;
+        egg?: number | undefined;
+    }[] | undefined;
+    wall: string | undefined;
+    catapult_destination_square_id: number | undefined;
+    piece_reward_id: number | undefined;
+}, {
+    id: number;
+    type: string;
+    highlight: number;
+    x: number;
+    y: number;
+    island_id: number;
+    ixy: string;
+    rewards_array?: {
+        chest?: number | undefined;
+        egg?: number | undefined;
+    }[] | undefined;
+    wall?: string | undefined;
+    catapult_destination_square_id?: number | undefined;
+    piece_reward_id?: number | undefined;
+}>>;

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.towerIslandsSquareSchema = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../../utils");
+/*
+{
+                    id: number;
+                    type: string;
+                    highlight: number;
+                    x: number;
+                    y: number;
+                    island_id: number;
+                    ixy: string;
+                    rewards_array?: Array<{
+                        chest?: number;
+                        egg?: number;
+                    }>;
+                    wall?: string;
+                    catapult_destination_square_id?: number;
+                    piece_reward_id?: number;
+                }
+*/
+exports.towerIslandsSquareSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    type: zod_1.z.string(),
+    highlight: zod_1.z.number(),
+    x: zod_1.z.number(),
+    y: zod_1.z.number(),
+    island_id: zod_1.z.number(),
+    ixy: zod_1.z.string(),
+    rewards_array: zod_1.z.array(zod_1.z.object({
+        chest: zod_1.z.number().optional(),
+        egg: zod_1.z.number().optional(),
+    })).optional(),
+    wall: zod_1.z.string().optional(),
+    catapult_destination_square_id: zod_1.z.number().optional(),
+    piece_reward_id: zod_1.z.number().optional(),
+}).strict().transform(data => {
+    return {
+        id: data.id,
+        type: data.type,
+        is_highlight: (0, utils_1.numberToBoolean)(data.highlight),
+        x: data.x,
+        y: data.y,
+        ixy: data.ixy,
+        rewards: data.rewards_array,
+        wall: data.wall,
+        catapult_destination_square_id: data.catapult_destination_square_id,
+        piece_reward_id: data.piece_reward_id,
+    };
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dchighs/dc-config-mapper",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "A opined library to restructure and populate configuration for Dragon City.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",