@nice2dev/game-engine 1.0.28 → 1.1.6

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

@@ -0,0 +1,176 @@
+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

@@ -0,0 +1,89 @@
+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

@@ -0,0 +1,94 @@
+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;