@drincs/nqtr 0.3.6 → 0.4.0

package/dist/classes/index.d.mts

@@ -1,31 +1,508 @@
-export { default as ActivityBaseModel } from './ActivityBaseModel.mjs';
-export { default as ActivityStoredClass } from './ActivityStoredClass.mjs';
-export { default as CommitmentBaseModel } from './CommitmentBaseModel.mjs';
-export { default as CommitmentStoredClass } from './CommitmentStoredClass.mjs';
-export { default as LocationBaseModel } from './navigation/LocationBaseModel.mjs';
-export { default as LocationStoredClass } from './navigation/LocationStoredClass.mjs';
-export { default as MapBaseModel } from './navigation/MapBaseModel.mjs';
-export { default as MapStoredClass } from './navigation/MapStoredClass.mjs';
-export { default as RoomBaseModel } from './navigation/RoomBaseModel.mjs';
-export { default as RoomStoredClass } from './navigation/RoomStoredClass.mjs';
-export { default as QuestBaseModel } from './quest/QuestBaseModel.mjs';
-export { default as QuestStoredClass } from './quest/QuestStoredClass.mjs';
-export { default as StageBaseModel } from './quest/StageBaseModel.mjs';
-export { default as StageStoredClass } from './quest/StageStoredClass.mjs';
-import '../interface/ActivityInterface.mjs';
-import '@drincs/nqtr';
-import '../interface/ActivityProps.mjs';
-import '../types/OnRunEvent.mjs';
-import '@drincs/pixi-vn';
-import '../interface/CommitmentProps.mjs';
-import '../RoomInterface-DsZAp6Pv.mjs';
-import '../types/ExecutionType.mjs';
-import '../interface/navigation/NavigationAbstractClass.mjs';
-import '../interface/navigation/LocationBaseModelProps.mjs';
-import './navigation/NavigationAbstractClass.mjs';
-import '../interface/navigation/MapBaseModelProps.mjs';
-import '../interface/navigation/RoomBaseModelProps.mjs';
-import '../interface/quest/QuestProps.mjs';
-import '../StageInterface-DJ7l0ubG.mjs';
-import '../interface/quest/StageProps.mjs';
-import '../interface/quest/StageFlags.mjs';
+import { A as ActivityInterface, a as ActivityBaseInternalInterface, C as CommitmentInterface, b as CommitmentBaseInternalInterface, R as RoomInterface, N as NavigationAbstractInterface, c as LocationInternalInterface, M as MapInterface, d as MapBaseInternalInterface, L as LocationInterface, e as RoomBaseInternalInterface } from '../RoomInterface-BRA386zn.mjs';
+import { A as ActivityProps, C as CommitmentProps, L as LocationBaseModelProps, M as MapBaseModelProps, R as RoomBaseModelProps, Q as QuestProps, S as StageProps, a as StageFlags } from '../index-CJubtUni.mjs';
+import { a as OnRunEvent, O as OnRunAsyncFunction, E as ExecutionType, e as QuestBaseInternalInterface, S as StageInterface, Q as QuestInterface, f as StageBaseInternalInterface, d as QuestsRequiredType } from '../StageInterface-LDgQToad.mjs';
+import { StoredClassModel, CharacterInterface } from '@drincs/pixi-vn';
+import { OnRunProps } from '@drincs/nqtr';
+
+declare class ActivityStoredClass<OnRunEventType = ActivityInterface> extends StoredClassModel implements ActivityBaseInternalInterface {
+    private readonly _onRun;
+    constructor(id: string, _onRun: OnRunEvent<OnRunEventType>, props: {
+        fromHour?: number;
+        toHour?: number;
+        fromDay?: number;
+        toDay?: number;
+    }, category?: string);
+    private _fromHour?;
+    get fromHour(): number | undefined;
+    private _toHour?;
+    get toHour(): number | undefined;
+    private _fromDay?;
+    get fromDay(): number | undefined;
+    private _toDay?;
+    get toDay(): number | undefined;
+    get run(): OnRunAsyncFunction;
+    get expired(): boolean;
+    get isActive(): boolean;
+}
+
+/**
+ * The activity model. It is used to create an activity.
+ * @example
+ * ```tsx
+ * export const nap = new ActivityModel("nap",
+ *     (_, event) => {
+ *         if (event) {
+ *             event.navigate("/game")
+ *             callLabelWithGoNavigationCallBack(napLabel, event)
+ *         }
+ *         else {
+ *             console.error("Event is undefined")
+ *         }
+ *     },
+ *     {
+ *         name: "Nap",
+ *         fromHour: 5,
+ *         toHour: 23,
+ *         icon: "https://icon.jpg",
+ *     }
+ * )
+ * ```
+ */
+declare class ActivityBaseModel extends ActivityStoredClass<ActivityInterface> {
+    /**
+     * @param id The activity id, that must be unique.
+     * @param onRun The function that is called when the activity is runned. Have 2 parameters: the runned activity and the yourParams object, that is an object with the parameters that you want to pass to the onRun function.
+     * @param props The activity properties.
+     */
+    constructor(id: string, onRun: OnRunEvent<ActivityInterface>, props: ActivityProps);
+    private defaultName;
+    /**
+     * The name of the activity.
+     */
+    get name(): string;
+    set name(value: string | undefined);
+    private defaultDisabled;
+    /**
+     * Whether is disabled. If it is a string, it is a Pixi'VN flag name.
+     */
+    get disabled(): boolean;
+    set disabled(value: boolean | string);
+    private defaultHidden;
+    /**
+     * Whether is hidden. If it is a string, it is a Pixi'VN flag name.
+     */
+    get hidden(): boolean;
+    set hidden(value: boolean | string);
+    private _icon?;
+    /**
+     * The icon of the activity.
+     */
+    get icon(): string | undefined;
+}
+
+declare class CommitmentStoredClass extends ActivityStoredClass<CommitmentInterface> implements CommitmentBaseInternalInterface {
+    private readonly _characters;
+    private readonly _room;
+    constructor(id: string, _characters: CharacterInterface[], _room: RoomInterface, onRun: OnRunEvent<CommitmentInterface> | undefined, props: {
+        executionType?: ExecutionType;
+        priority?: number;
+        fromHour?: number;
+        toHour?: number;
+        fromDay?: number;
+        toDay?: number;
+    });
+    private readonly defaultExecutionType;
+    private readonly defaultPriority?;
+    get characters(): CharacterInterface[];
+    get room(): RoomInterface;
+    get executionType(): ExecutionType;
+    set executionType(value: ExecutionType);
+    get priority(): number;
+    set priority(value: number);
+}
+
+/**
+ * The base model of a commitment. I suggest you extend this class to create your own commitment model.
+ * You must use the saveRoom function to save the commitment in the registered commitments.
+ * @example
+ * ```ts
+ * export const mcRoom = new CommitmentBaseModel("test", character, room, {
+ *     name: "Test",
+ *     image: "https://image.jpg",
+ *     executionType: ExecutionTypeEnum.INTERACTION,
+ *     onRun: (commitment) => {
+ *         // Do something
+ *     }
+ * })
+ * saveCommitment(mcRoom)
+ * ```
+ */
+declare class CommitmentBaseModel extends CommitmentStoredClass {
+    /**
+     * @param id The id of the commitment, it must be unique.
+     * @param character The character or characters that are in the commitment and so in the room.
+     * @param room The room where the commitment is.
+     * @param props The properties of the commitment.
+     */
+    constructor(id: string, character: CharacterInterface | CharacterInterface[] | undefined, room: RoomInterface, props: CommitmentProps);
+    private _name;
+    /**
+     * The name of the commitment.
+     */
+    get name(): string;
+    private _image?;
+    /**
+     * The image of the commitment.
+     */
+    get image(): string | undefined;
+    private _icon?;
+    /**
+     * The icon of the commitment.
+     */
+    get icon(): string | undefined;
+    private defaultDisabled;
+    /**
+     * Whether is disabled. You can also pass a Pixi'VN flag name.
+     */
+    get disabled(): boolean;
+    set disabled(value: boolean | string);
+    private defaultHidden;
+    /**
+     * Whether is hidden. You can also pass a Pixi'VN flag name.
+     */
+    get hidden(): boolean;
+    set hidden(value: boolean | string);
+}
+
+declare abstract class NavigationAbstractClass extends StoredClassModel implements NavigationAbstractInterface {
+    private defaultActivities;
+    constructor(categoryId: string, id: string, defaultActivities?: ActivityInterface[]);
+    private get defaultActivitiesIds();
+    private get activeActivityScheduling();
+    private get excludedActivitiesScheduling();
+    private removeActivityScheduling;
+    private editActivityScheduling;
+    private editExcludedActivityScheduling;
+    private get additionalActivitiesIds();
+    private get excludedActivitiesIds();
+    addActivity(activity: ActivityInterface, options?: {
+        /**
+         * the activity will be associated with this class only for the specified hours.
+         * If you set from 3 and to 5, the activity will be associated with this class only for hours 3, 4 and 5. soSo at 2 or 6 it will not be associated with this class.
+         */
+        hours?: {
+            from: number;
+            to: number;
+        };
+        /**
+         * the activity will be associated with this class from the specified day.
+         * If you set 3, the activity will be associated with this class from day 3. So at day 2 it will not be associated with this class.
+         */
+        fromDay?: number;
+        /**
+         * the activity will be associated with this class to the specified day.
+         * If you set 3, the activity will be associated with this class until day 3. So at day 4 it will not be associated with this class.
+         */
+        toDay?: number;
+    }): void;
+    removeActivity(activity: ActivityInterface, options?: {
+        /**
+         * The activity will be excluded from this class only for the specified days.
+         * If to 3, the activity will be excluded from this class only for days 1, 2 and 3. So at day 4 it will be associated with this class.
+         */
+        toDay?: number;
+    }): void;
+    clearExpiredActivities(): void;
+    get activities(): ActivityInterface[];
+}
+
+declare class LocationStoredClass extends NavigationAbstractClass implements LocationInternalInterface {
+    /**
+     * The map where the location is.
+     */
+    private readonly _map;
+    constructor(id: string, 
+    /**
+     * The map where the location is.
+     */
+    _map: MapInterface, activities?: ActivityInterface[]);
+    get map(): MapInterface;
+    get rooms(): RoomInterface[];
+}
+
+/**
+ * The base model of a location. I suggest you extend this class to create your own location model.
+ * @example
+ * ```typescript
+ * export const mcHome = new LocationBaseModel('mc_home', mainMap, {
+ *     name: 'MC Home',
+ *     icon: "https://icon.jpg",
+ * });
+ * ```
+ */
+declare class LocationBaseModel extends LocationStoredClass implements LocationInternalInterface {
+    /**
+     * @param id The id of the location, it must be unique.
+     * @param map The map where the location is.
+     * @param props The properties of the location.
+     */
+    constructor(id: string, map: MapInterface, props?: LocationBaseModelProps);
+    private defaultName;
+    /**
+     * The name of the location.
+     * If you set undefined, it will return the initial value of name.
+     */
+    get name(): string;
+    set name(value: string | undefined);
+    private defaultDisabled;
+    /**
+     * Whether is disabled. If it is a string, it is a Pixi'VN flag name.
+     */
+    get disabled(): boolean;
+    set disabled(value: boolean | string);
+    private defaultHidden;
+    /**
+     * Whether is hidden. If it is a string, it is a Pixi'VN flag name.
+     */
+    get hidden(): boolean;
+    set hidden(value: boolean | string);
+    private _icon?;
+    /**
+     * The icon of the location.
+     */
+    get icon(): string | undefined;
+}
+
+declare class MapStoredClass extends NavigationAbstractClass implements MapBaseInternalInterface {
+    constructor(id: string, activities?: ActivityInterface[]);
+    get locations(): LocationInterface[];
+}
+
+/**
+ * The base model of a map. I suggest you extend this class to create your own map model.
+ * @example
+ * ```typescript
+ * export const mainMap = new MapBaseModel('main_map', {
+ *     name: 'Main Map',
+ *     image: "https://image.jpg",
+ * });
+ * ```
+ */
+declare class MapBaseModel extends MapStoredClass implements MapBaseInternalInterface {
+    /**
+     * @param id The id of the map, it must be unique.
+     * @param props The properties of the map.
+     */
+    constructor(id: string, props?: MapBaseModelProps);
+    private defaultName;
+    /**
+     * The name of the map.
+     * If you set undefined, it will return the initial value of name.
+     */
+    get name(): string;
+    set name(value: string | undefined);
+    private _image?;
+    /**
+     * The image of the map.
+     */
+    get image(): string | undefined;
+}
+
+declare class RoomStoredClass extends NavigationAbstractClass implements RoomBaseInternalInterface {
+    /**
+     * The location where the room is.
+     */
+    private readonly _location;
+    constructor(id: string, 
+    /**
+     * The location where the room is.
+     */
+    _location: LocationInterface, activities?: ActivityInterface[]);
+    get routine(): CommitmentInterface[];
+    get location(): LocationInterface;
+    get characters(): CharacterInterface[];
+    get automaticFunction(): OnRunAsyncFunction | undefined;
+}
+
+/**
+ * The base model of a room. I suggest you extend this class to create your own room model.
+ * **You must use the {@link RegisteredRooms.add} function to save the room in the registered rooms.**
+ * @example
+ * ```ts
+ * export const mcRoom = new RoomBaseModel('mc_room', mcHome, {
+ *     name: "MC Room",
+ *     icon: "https://icon.jpg",
+ *     image: "https://image.jpg",
+ * })
+ * RegisteredRooms.add(mcRoom)
+ * ```
+ */
+declare class RoomBaseModel extends RoomStoredClass {
+    /**
+     * @param id The id of the room, it must be unique.
+     * @param location The location where the room is.
+     * @param props The properties of the room.
+     */
+    constructor(id: string, location: LocationInterface, props?: RoomBaseModelProps);
+    private defaultName;
+    /**
+     * The name.
+     * If you set undefined, it will return the initial value of name.
+     */
+    get name(): string;
+    set name(value: string | undefined);
+    private _image?;
+    /**
+     * The image of the room.
+     */
+    get image(): string | undefined;
+    private defaultDisabled;
+    /**
+     * Whether is disabled. If it is a string, it is a Pixi'VN flag name.
+     */
+    get disabled(): boolean;
+    set disabled(value: boolean | string);
+    private defaultHidden;
+    /**
+     * Whether is hidden. If it is a string, it is a Pixi'VN flag name.
+     */
+    get hidden(): boolean;
+    set hidden(value: boolean | string);
+    private _icon?;
+    /**
+     * The function for rendering the icon of the room.
+     */
+    get icon(): string | undefined;
+    /**
+     * Get the character commitments of the room.
+     * @returns The character commitments of the room.
+     */
+    get routine(): CommitmentInterface[];
+}
+
+declare class QuestStoredClass extends StoredClassModel implements QuestBaseInternalInterface {
+    private readonly _stages;
+    constructor(id: string, _stages: StageInterface[], props?: {
+        /**
+         * The function that will be executed when the quest starts.
+         */
+        onStart?: OnRunEvent<QuestInterface>;
+        /**
+         * The function that will be executed when a stage end in the quest.
+         */
+        onNextStage?: OnRunEvent<QuestInterface>;
+    });
+    get stages(): StageInterface[];
+    get currentStageIndex(): number | undefined;
+    private set currentStageIndex(value);
+    get currentStage(): StageInterface | undefined;
+    get started(): boolean;
+    get completed(): boolean;
+    get inProgress(): boolean;
+    get failed(): boolean;
+    set failed(value: boolean);
+    private _onStart?;
+    get onStart(): undefined | OnRunEvent<QuestInterface>;
+    private _onNextStage?;
+    get onNextStage(): undefined | OnRunEvent<QuestInterface>;
+    start(props: OnRunProps): Promise<void>;
+    tryToGoNextStage(props: OnRunProps): Promise<boolean>;
+    completeCurrentStageAndGoNext(props: OnRunProps): Promise<boolean>;
+    goNextStage(props: OnRunProps): Promise<boolean>;
+    get currentStageMustStart(): boolean;
+    startCurrentStage(props: OnRunProps): Promise<void>;
+}
+
+declare class QuestBaseModel extends QuestStoredClass {
+    constructor(id: string, stages: StageInterface[], props: QuestProps);
+    private _name;
+    /**
+     * The name of the quest.
+     */
+    get name(): string;
+    private _description;
+    /**
+     * The description of the quest.
+     */
+    get description(): string;
+    private _icon?;
+    /**
+     * Icon of the quest.
+     */
+    get icon(): string | undefined;
+    private _image?;
+    /**
+     * Image of the quest.
+     */
+    get image(): string | undefined;
+    private _inDevelopment;
+    /**
+     * If the quest is in development.
+     */
+    get inDevelopment(): boolean;
+}
+
+declare class StageStoredClass extends StoredClassModel implements StageBaseInternalInterface {
+    constructor(id: string, options?: {
+        /**
+         * The function that will be executed when the stage starts.
+         */
+        onStart?: OnRunEvent<StageInterface>;
+        /**
+         * The function that will be executed when the stage ends.
+         */
+        onEnd?: OnRunEvent<StageInterface>;
+        /**
+         * The day required to start the stage.
+         * @example If the value is 3, and the previous stage ends on day 1, the stage will start on day 4.
+         */
+        daysRequiredToStart?: number;
+        /**
+         * The quests required to start the stage.
+         * @default []
+         */
+        questsRequiredToStart?: QuestsRequiredType[];
+    });
+    private _onStart?;
+    get onStart(): undefined | OnRunEvent<StageInterface>;
+    private _onEnd?;
+    get onEnd(): undefined | OnRunEvent<StageInterface>;
+    get completed(): boolean;
+    set completed(value: boolean);
+    get started(): boolean;
+    set started(value: boolean);
+    private get prevStageEndDay();
+    private set prevStageEndDay(value);
+    get startDay(): number | undefined;
+    get canStart(): boolean;
+    inizialize(): void;
+    start(props: OnRunProps): Promise<void>;
+    private _daysRequiredToStart?;
+    get daysRequiredToStart(): number;
+    private _questsRequiredToStart;
+    get questsRequiredToStart(): QuestsRequiredType[];
+}
+
+declare class StageBaseModel extends StageStoredClass {
+    constructor(id: string, props: StageProps);
+    private _name;
+    /**
+     * The name of the stage.
+     */
+    get name(): string;
+    private _description;
+    /**
+     * The description of the stage.
+     */
+    get description(): string;
+    private _adviceDescription;
+    /**
+     * The advice description of the stage.
+     */
+    get adviceDescription(): string;
+    private _image?;
+    /**
+     * The image of the stage.
+     */
+    get image(): string | undefined;
+    private _flags;
+    /**
+     * The list of flags that the player must complete to finish the stage.
+     */
+    get flags(): StageFlags[];
+    private _flagsRequiredToStart;
+    /**
+     * The list of flags required to start the stage.
+     */
+    get flagsRequiredToStart(): StageFlags[];
+    private _requestDescriptionToStart;
+    /**
+     * The description of the request to start the stage.
+     */
+    get requestDescriptionToStart(): string;
+    get completed(): boolean;
+    set completed(value: boolean);
+    get canStart(): boolean;
+}
+
+export { ActivityBaseModel, ActivityStoredClass, CommitmentBaseModel, CommitmentStoredClass, LocationBaseModel, LocationStoredClass, MapBaseModel, MapStoredClass, QuestBaseModel, QuestStoredClass, RoomBaseModel, RoomStoredClass, StageBaseModel, StageStoredClass };