@nice2dev/game-engine 1.3.12 → 1.3.14

package/dist/types/systems/NiceSeason.d.ts

@@ -1,176 +0,0 @@
-export type SeasonType = 'spring' | 'summer' | 'autumn' | 'winter';
-export type HolidayId = string;
-export type SeasonalContentId = string;
-export interface SeasonDefinition {
-    type: SeasonType;
-    name: string;
-    description: string;
-    startMonth: number;
-    startDay: number;
-    endMonth: number;
-    endDay: number;
-    weatherPatterns: WeatherPattern[];
-    ambientEffects: string[];
-    exclusiveContent: SeasonalContentId[];
-    seasonalMobs: string[];
-    seasonalResources: string[];
-    modifiers: SeasonalModifier[];
-    skyboxId?: string;
-    lightingProfile?: string;
-    musicPlaylist?: string[];
-    theme: string;
-}
-export interface WeatherPattern {
-    type: 'clear' | 'cloudy' | 'rain' | 'storm' | 'snow' | 'fog' | 'heat' | 'wind';
-    probability: number;
-    minDuration: number;
-    maxDuration: number;
-    intensity?: number;
-    effects?: string[];
-}
-export interface SeasonalModifier {
-    type: 'stat' | 'drop_rate' | 'respawn_rate' | 'experience' | 'damage' | 'speed';
-    target?: string;
-    value: number;
-    isPercentage: boolean;
-}
-export interface Holiday {
-    id: HolidayId;
-    name: string;
-    description: string;
-    month: number;
-    day: number;
-    duration: number;
-    season?: SeasonType;
-    exclusiveContent: SeasonalContentId[];
-    specialEvents: string[];
-    decorations: string[];
-    loginRewards?: Array<{
-        day: number;
-        type: 'item' | 'currency' | 'cosmetic';
-        itemId?: string;
-        amount: number;
-    }>;
-    hasShop: boolean;
-    hasBoss: boolean;
-    hasQuests: boolean;
-    theme: string;
-    bannerUrl?: string;
-}
-export interface SeasonalContent {
-    id: SeasonalContentId;
-    name: string;
-    type: 'item' | 'cosmetic' | 'recipe' | 'quest' | 'achievement' | 'area' | 'npc';
-    availableDuring: SeasonType[];
-    holidayId?: HolidayId;
-    levelRequired?: number;
-    questRequired?: string;
-    contentRef: string;
-    metadata?: Record<string, unknown>;
-}
-export interface WeatherState {
-    currentWeather: string;
-    intensity: number;
-    startedAt: number;
-    duration: number;
-    nextChangeAt: number;
-    forecast: Array<{
-        weather: string;
-        startTime: number;
-        duration: number;
-    }>;
-}
-export interface SeasonState {
-    currentSeason: SeasonType;
-    currentDay: number;
-    seasonProgress: number;
-    weather: WeatherState;
-    activeHolidays: HolidayId[];
-    activeModifiers: SeasonalModifier[];
-}
-export interface PlayerSeasonalData {
-    playerId: string;
-    seasonsExperienced: SeasonType[];
-    daysPlayedPerSeason: Record<SeasonType, number>;
-    holidaysParticipated: HolidayId[];
-    holidayLoginDays: Record<HolidayId, number[]>;
-    seasonalItemsCollected: SeasonalContentId[];
-    seasonalAchievements: string[];
-    totalSeasonalQuests: number;
-    totalHolidayEvents: number;
-}
-export type SeasonEventType = 'season-changed' | 'weather-changed' | 'holiday-started' | 'holiday-ended' | 'content-unlocked' | 'content-locked' | 'modifier-applied' | 'modifier-removed' | 'seasonal-login' | 'forecast-updated';
-export interface SeasonEvent {
-    type: SeasonEventType;
-    timestamp: number;
-    data?: unknown;
-}
-export type SeasonEventCallback = (event: SeasonEvent) => void;
-export interface SeasonConfig {
-    useRealWorldTime: boolean;
-    seasonDurationDays: number;
-    weatherUpdateInterval: number;
-    forecastLength: number;
-    hemisphere: 'northern' | 'southern';
-    timezoneOffset: number;
-    storageKey: string;
-}
-export declare const DEFAULT_SEASON_CONFIG: SeasonConfig;
-export declare class NiceSeason {
-    private config;
-    private seasons;
-    private holidays;
-    private content;
-    private playerData;
-    private currentState;
-    private eventListeners;
-    private updateInterval?;
-    constructor(config?: Partial<SeasonConfig>);
-    on(event: SeasonEventType, callback: SeasonEventCallback): () => void;
-    private emit;
-    private initializeState;
-    private startUpdateLoop;
-    registerSeason(definition: SeasonDefinition): void;
-    registerHoliday(holiday: Holiday): void;
-    registerContent(content: SeasonalContent): void;
-    registerDefaultSeasons(): void;
-    private calculateCurrentSeason;
-    private isDateInSeason;
-    private calculateSeasonProgress;
-    update(): void;
-    private onSeasonChanged;
-    private updateWeather;
-    private generateNewWeather;
-    private selectWeatherPattern;
-    private generateForecast;
-    private randomBetween;
-    private updateHolidays;
-    private updateModifiers;
-    recordSeasonalLogin(playerId: string): void;
-    collectSeasonalItem(playerId: string, contentId: SeasonalContentId): boolean;
-    getCurrentState(): SeasonState;
-    getCurrentSeason(): SeasonDefinition | undefined;
-    getSeason(type: SeasonType): SeasonDefinition | undefined;
-    getAllSeasons(): SeasonDefinition[];
-    getHoliday(id: HolidayId): Holiday | undefined;
-    getActiveHolidays(): Holiday[];
-    getAllHolidays(): Holiday[];
-    getUpcomingHolidays(days?: number): Holiday[];
-    getSeasonalContent(contentId: SeasonalContentId): SeasonalContent | undefined;
-    getAvailableContent(): SeasonalContent[];
-    isContentAvailable(contentId: SeasonalContentId): boolean;
-    getWeather(): WeatherState;
-    getActiveModifiers(): SeasonalModifier[];
-    getPlayerSeasonalData(playerId: string): PlayerSeasonalData | undefined;
-    getHolidayLoginReward(playerId: string, holidayId: HolidayId): Array<{
-        day: number;
-        type: 'item' | 'currency' | 'cosmetic';
-        itemId?: string;
-        amount: number;
-    }> | null;
-    private save;
-    private load;
-    reset(): void;
-    destroy(): void;
-}
-export declare function createSeasonSystem(config?: Partial<SeasonConfig>): NiceSeason;

package/dist/types/systems/NiceSerialization.d.ts

@@ -1,89 +0,0 @@
-import { EventEmitter } from 'events';
-export type TypeId = string;
-export type SerializedData = string | ArrayBuffer;
-export interface TypeSerializer<T = unknown> {
-    typeId: TypeId;
-    serialize: (value: T) => unknown;
-    deserialize: (data: unknown) => T;
-    version?: number;
-    migrate?: (data: unknown, fromVersion: number) => unknown;
-}
-export interface SerializationContext {
-    refs: Map<object, number>;
-    refId: number;
-    objects: unknown[];
-}
-export interface DeserializationContext {
-    refs: Map<number, object>;
-    objects: unknown[];
-}
-export interface SerializedObject {
-    $type?: TypeId;
-    $ref?: number;
-    $version?: number;
-    $value?: unknown;
-    [key: string]: unknown;
-}
-export type SchemaType = 'string' | 'number' | 'boolean' | 'array' | 'object' | 'any';
-export interface SchemaProperty {
-    type: SchemaType;
-    required?: boolean;
-    default?: unknown;
-    items?: SchemaProperty;
-    properties?: Record<string, SchemaProperty>;
-    validate?: (value: unknown) => boolean;
-}
-export interface Schema {
-    typeId: TypeId;
-    version: number;
-    properties: Record<string, SchemaProperty>;
-}
-export type SerializationEventType = 'serialize-start' | 'serialize-complete' | 'deserialize-start' | 'deserialize-complete' | 'migration' | 'validation-error';
-export interface SerializationEvent {
-    type: SerializationEventType;
-    typeId?: TypeId;
-    data?: unknown;
-    error?: Error;
-}
-export interface SerializationConfig {
-    format?: 'json' | 'binary';
-    compress?: boolean;
-    validateOnDeserialize?: boolean;
-    handleCircular?: boolean;
-    prettyPrint?: boolean;
-}
-export declare const DEFAULT_SERIALIZATION_CONFIG: SerializationConfig;
-export declare class NiceSerialization extends EventEmitter {
-    private serializers;
-    private schemas;
-    private config;
-    constructor(config?: Partial<SerializationConfig>);
-    private registerBuiltins;
-    registerType<T>(serializer: TypeSerializer<T>): void;
-    unregisterType(typeId: TypeId): boolean;
-    registerSchema(schema: Schema): void;
-    serialize<T>(value: T, typeId?: TypeId): SerializedData;
-    private serializeValue;
-    private getTypeId;
-    deserialize<T>(data: SerializedData, typeId?: TypeId): T;
-    private deserializeValue;
-    validate(data: unknown, schema: Schema): string[];
-    private validateProperties;
-    private checkType;
-    private compress;
-    private decompress;
-    private decompressBuffer;
-    clone<T>(value: T, typeId?: TypeId): T;
-    diff(oldValue: unknown, newValue: unknown): Record<string, unknown>;
-    private diffRecursive;
-    patch<T>(target: T, diff: Record<string, unknown>): T;
-    private setByPath;
-    private getByPath;
-}
-export declare function createSerialization(config?: Partial<SerializationConfig>): NiceSerialization;
-export declare function defineSerializer<T>(typeId: TypeId, serialize: (value: T) => unknown, deserialize: (data: unknown) => T, options?: {
-    version?: number;
-    migrate?: (data: unknown, fromVersion: number) => unknown;
-}): TypeSerializer<T>;
-export declare function defineSchema(typeId: TypeId, version: number, properties: Record<string, SchemaProperty>): Schema;
-export default NiceSerialization;

package/dist/types/systems/NiceServiceLocator.d.ts

@@ -1,94 +0,0 @@
-import { EventEmitter } from 'events';
-export type ServiceId = string | symbol;
-export type ServiceFactory<T> = (container: ServiceContainer) => T;
-export type ServiceLifetime = 'singleton' | 'transient' | 'scoped';
-export interface ServiceDefinition<T = unknown> {
-    id: ServiceId;
-    factory: ServiceFactory<T>;
-    lifetime: ServiceLifetime;
-    dependencies?: ServiceId[];
-    tags?: string[];
-    alias?: ServiceId[];
-}
-export interface ServiceRegistration<T = unknown> {
-    definition: ServiceDefinition<T>;
-    instance?: T;
-    initialized: boolean;
-}
-export type ServiceEventType = 'registered' | 'resolved' | 'disposed' | 'scope-created' | 'scope-disposed' | 'error';
-export interface ServiceEvent {
-    type: ServiceEventType;
-    serviceId?: ServiceId;
-    scopeId?: string;
-    error?: Error;
-}
-export interface Disposable {
-    dispose(): void | Promise<void>;
-}
-export interface Initializable {
-    initialize(): void | Promise<void>;
-}
-export declare class ServiceContainer extends EventEmitter {
-    private registrations;
-    private aliasMap;
-    private tagIndex;
-    private scopes;
-    private parent?;
-    private scopeId?;
-    private scopedInstances;
-    private resolutionStack;
-    private initializing;
-    constructor(parent?: ServiceContainer, scopeId?: string);
-    register<T>(id: ServiceId, factory: ServiceFactory<T>, options?: {
-        lifetime?: ServiceLifetime;
-        dependencies?: ServiceId[];
-        tags?: string[];
-        alias?: ServiceId[];
-    }): this;
-    registerInstance<T>(id: ServiceId, instance: T, tags?: string[]): this;
-    registerClass<T>(id: ServiceId, constructor: new (...args: unknown[]) => T, options?: {
-        lifetime?: ServiceLifetime;
-        tags?: string[];
-        alias?: ServiceId[];
-    }): this;
-    resolve<T>(id: ServiceId): T;
-    tryResolve<T>(id: ServiceId): T | undefined;
-    resolveAll<T>(tag: string): T[];
-    has(id: ServiceId): boolean;
-    private createInstance;
-    private isInitializable;
-    private isDisposable;
-    createScope(scopeId?: string): ServiceContainer;
-    getScope(scopeId: string): ServiceContainer | undefined;
-    disposeScope(scopeId: string): void;
-    disposeAsync(): Promise<void>;
-    dispose(): void;
-    getRegistrations(): ServiceId[];
-    getServicesByTag(tag: string): ServiceId[];
-    clear(): void;
-}
-export declare function getGlobalContainer(): ServiceContainer;
-export declare function resetGlobalContainer(): void;
-export declare function Injectable(id?: ServiceId): ClassDecorator;
-export declare function Inject(id: ServiceId): ParameterDecorator;
-export declare class ContainerBuilder {
-    private container;
-    constructor(parent?: ServiceContainer);
-    addSingleton<T>(id: ServiceId, factory: ServiceFactory<T>, options?: {
-        tags?: string[];
-        alias?: ServiceId[];
-    }): this;
-    addTransient<T>(id: ServiceId, factory: ServiceFactory<T>, options?: {
-        tags?: string[];
-        alias?: ServiceId[];
-    }): this;
-    addScoped<T>(id: ServiceId, factory: ServiceFactory<T>, options?: {
-        tags?: string[];
-        alias?: ServiceId[];
-    }): this;
-    addInstance<T>(id: ServiceId, instance: T, tags?: string[]): this;
-    build(): ServiceContainer;
-}
-export declare function createServiceContainer(parent?: ServiceContainer): ServiceContainer;
-export declare function createContainerBuilder(parent?: ServiceContainer): ContainerBuilder;
-export default ServiceContainer;