import { Direction, RaycastHit, Entity } from '@rpgjs/common';
import { RpgPlayer } from './Player/Player';
import { RpgMap } from './rooms/map';
export type ProjectileTrajectory = {
    type?: "linear";
    speed: number;
    range: number;
    ttl?: number;
} | {
    type: "instant";
    range: number;
};
export interface ProjectileRepeatOptions {
    count: number;
    interval?: number;
    spread?: number;
    seed?: number | true;
}
export type ProjectilePatternOptions = {
    type: "cone";
    count: number;
    angle: number;
} | {
    type: "circle";
    count: number;
};
export interface ProjectileCollisionOptions {
    collisionMask?: number;
    ignoreOwner?: boolean;
    predictImpact?: boolean;
}
export interface ProjectileEmitOptions {
    id?: string;
    type: string;
    origin?: {
        x: number;
        y: number;
    };
    direction?: Direction | {
        x: number;
        y: number;
    };
    /**
     * Random direction offset in degrees, applied as +/- half this value.
     * Use it for inaccurate shots, arrows, spells, or bullets.
     */
    spreadDegrees?: number;
    /**
     * Convenience precision value from 0 to 1. Ignored when `spreadDegrees` is set.
     * `1` is perfectly accurate, `0` can deviate up to 30 degrees.
     */
    accuracy?: number;
    trajectory: ProjectileTrajectory;
    collision?: ProjectileCollisionOptions;
    repeat?: ProjectileRepeatOptions;
    pattern?: ProjectilePatternOptions;
    payload?: Record<string, unknown>;
    params?: Record<string, unknown>;
    canHit?: (context: ProjectileCanHitContext) => boolean;
}
export interface ProjectileCanHitContext {
    projectile: ProjectileServerState;
    owner?: RpgPlayer;
    target?: RpgPlayer | any;
    entity: Entity;
    map: RpgMap;
}
export interface ProjectileServerState {
    id: string;
    type: string;
    ownerId?: string;
    origin: {
        x: number;
        y: number;
    };
    direction: {
        x: number;
        y: number;
    };
    speed: number;
    range: number;
    ttl: number;
    spawnTick: number;
    delay: number;
    index: number;
    count: number;
    payload?: Record<string, unknown>;
    params?: Record<string, unknown>;
}
export interface ProjectileHookContext {
    projectile: ProjectileServerState;
    owner?: RpgPlayer;
    map: RpgMap;
}
export interface ProjectileImpactHookContext extends ProjectileHookContext {
    target?: RpgPlayer | any;
    hit: RaycastHit;
}
export interface ProjectileDestroyHookContext extends ProjectileHookContext {
    reason: string;
    hit?: RaycastHit;
}
export type NetworkProjectile = Omit<ProjectileServerState, "payload"> & ProjectileCollisionOptions;
export declare class RpgMapProjectiles {
    private readonly map;
    private readonly system;
    private readonly pending;
    private readonly runtime;
    private readonly networkRuntime;
    private readonly spawnQueue;
    private readonly impactQueue;
    private readonly destroyQueue;
    constructor(map: RpgMap);
    emit(options: ProjectileEmitOptions, owner?: RpgPlayer): ProjectileServerState[];
    step(dt?: number): void;
    clear(): void;
    /** Return client-safe descriptors for projectiles that are still authoritative. */
    getActiveNetworkProjectiles(): NetworkProjectile[];
    private createStates;
    private resolveIndexedDirection;
    private spawnNow;
    private spawnInstant;
    private canHit;
    private handleHit;
    private handleHitState;
    private handleDestroy;
    private handleDestroyState;
    private flush;
    private callHook;
}
export declare class RpgPlayerProjectiles {
    private readonly player;
    constructor(player: RpgPlayer);
    emit(options: ProjectileEmitOptions): ProjectileServerState[];
}