@nice2dev/game-engine 1.0.28 → 1.1.6

package/dist/types/templates/MetroidvaniaTemplate.d.ts

@@ -0,0 +1,174 @@
+import type { Vec2 } from '../core/types';
+export type Ability = 'double_jump' | 'wall_jump' | 'dash' | 'air_dash' | 'grapple' | 'swim' | 'dive' | 'morph_ball' | 'super_jump' | 'phase' | 'float';
+export type Weapon = 'default' | 'charged_shot' | 'missiles' | 'super_missiles' | 'bombs' | 'power_bombs' | 'ice_beam' | 'fire_beam' | 'wave_beam';
+export type UpgradeType = 'health_tank' | 'energy_tank' | 'ammo_expansion' | 'damage_up' | 'defense_up';
+export interface MapRoom {
+    id: string;
+    name: string;
+    zone: string;
+    position: Vec2;
+    size: {
+        width: number;
+        height: number;
+    };
+    connections: RoomConnection[];
+    requirements: Ability[];
+    items: MapItem[];
+    enemies: RoomEnemy[];
+    isSaveRoom: boolean;
+    isBossRoom: boolean;
+    boss?: string;
+    discovered: boolean;
+    cleared: boolean;
+    secretWalls: SecretWall[];
+}
+export interface RoomConnection {
+    direction: 'north' | 'south' | 'east' | 'west' | 'up' | 'down';
+    targetRoomId: string;
+    targetEntrance: string;
+    requirement?: Ability;
+    locked: boolean;
+    keyRequired?: string;
+}
+export interface SecretWall {
+    id: string;
+    position: Vec2;
+    size: {
+        width: number;
+        height: number;
+    };
+    revealMethod: 'bomb' | 'super_bomb' | 'attack' | 'scan' | 'walk_through';
+    revealed: boolean;
+    leadsTo?: string;
+}
+export interface MapItem {
+    id: string;
+    type: 'ability' | 'weapon' | 'upgrade' | 'key' | 'collectible';
+    subtype: Ability | Weapon | UpgradeType | string;
+    position: Vec2;
+    collected: boolean;
+    hidden: boolean;
+    description: string;
+}
+export interface RoomEnemy {
+    id: string;
+    type: string;
+    position: Vec2;
+    health: number;
+    maxHealth: number;
+    respawns: boolean;
+    drops?: string;
+    defeated: boolean;
+}
+export interface Zone {
+    id: string;
+    name: string;
+    theme: string;
+    color: string;
+    rooms: string[];
+    boss: string;
+    bossDefeated: boolean;
+    requiredAbilities: Ability[];
+}
+export interface PlayerStats {
+    maxHealth: number;
+    currentHealth: number;
+    maxEnergy: number;
+    currentEnergy: number;
+    attackPower: number;
+    defense: number;
+    moveSpeed: number;
+    jumpHeight: number;
+}
+export interface MetroidvaniaState {
+    playerStats: PlayerStats;
+    position: Vec2;
+    currentRoom: string;
+    velocity: Vec2;
+    facing: 1 | -1;
+    abilities: Ability[];
+    weapons: Weapon[];
+    activeWeapon: Weapon;
+    ammo: {
+        [key in Weapon]?: number;
+    };
+    maxAmmo: {
+        [key in Weapon]?: number;
+    };
+    keys: string[];
+    collectibles: string[];
+    map: Map<string, MapRoom>;
+    zones: Zone[];
+    totalCompletion: number;
+    playTime: number;
+    deaths: number;
+    lastSaveRoom: string;
+    bossesDefeated: string[];
+}
+export interface MetroidvaniaConfig {
+    baseHealth: number;
+    baseEnergy: number;
+    healthPerTank: number;
+    energyPerTank: number;
+    baseDamage: number;
+    baseDefense: number;
+    baseMoveSpeed: number;
+    baseJumpHeight: number;
+    doubleJumpMultiplier: number;
+    dashSpeed: number;
+    dashDuration: number;
+    dashCooldown: number;
+    grappleSpeed: number;
+    grappleRange: number;
+    respawnInvincibility: number;
+    itemRespawnOnDeath: boolean;
+}
+export declare const DEFAULT_METROIDVANIA_CONFIG: MetroidvaniaConfig;
+export declare function createMetroidvaniaState(config: MetroidvaniaConfig): MetroidvaniaState;
+export declare function hasAbility(state: MetroidvaniaState, ability: Ability): boolean;
+export declare function grantAbility(state: MetroidvaniaState, ability: Ability): void;
+export declare function canUseAbility(state: MetroidvaniaState, ability: Ability): boolean;
+export declare function useAbility(state: MetroidvaniaState, ability: Ability): boolean;
+export declare function hasWeapon(state: MetroidvaniaState, weapon: Weapon): boolean;
+export declare function grantWeapon(state: MetroidvaniaState, weapon: Weapon): void;
+export declare function getDefaultMaxAmmo(weapon: Weapon): number;
+export declare function canFire(state: MetroidvaniaState, weapon: Weapon): boolean;
+export declare function fireWeapon(state: MetroidvaniaState, weapon: Weapon): boolean;
+export declare function getWeaponDamage(baseAttack: number, weapon: Weapon, charged?: boolean): number;
+export declare function canDoubleJump(state: MetroidvaniaState, hasJumped: boolean): boolean;
+export declare function canWallJump(state: MetroidvaniaState, touchingWall: boolean): boolean;
+export declare function canDash(state: MetroidvaniaState, onGround: boolean, dashCooldownRemaining: number): boolean;
+export declare function canGrapple(state: MetroidvaniaState, grappleTarget: Vec2 | null): boolean;
+export declare function canSwim(state: MetroidvaniaState): boolean;
+export declare function canDive(state: MetroidvaniaState): boolean;
+export declare function canMorph(state: MetroidvaniaState): boolean;
+export declare function canEnterRoom(state: MetroidvaniaState, room: MapRoom): boolean;
+export declare function canUseConnection(state: MetroidvaniaState, connection: RoomConnection): boolean;
+export declare function discoverRoom(state: MetroidvaniaState, roomId: string): void;
+export declare function clearRoom(state: MetroidvaniaState, roomId: string): void;
+export declare function revealSecretWall(room: MapRoom, secretId: string): SecretWall | undefined;
+export declare function collectItem(state: MetroidvaniaState, room: MapRoom, itemId: string, config: MetroidvaniaConfig): MapItem | undefined;
+export declare function applyUpgrade(state: MetroidvaniaState, type: UpgradeType, config: MetroidvaniaConfig): void;
+export declare function isBossDefeated(state: MetroidvaniaState, bossId: string): boolean;
+export declare function defeatBoss(state: MetroidvaniaState, bossId: string, zoneId: string): void;
+export declare function saveGame(state: MetroidvaniaState): void;
+export declare function respawn(state: MetroidvaniaState, config: MetroidvaniaConfig): void;
+export declare function updateCompletion(state: MetroidvaniaState): void;
+export declare function getMapCompletion(state: MetroidvaniaState): {
+    roomsDiscovered: number;
+    totalRooms: number;
+    roomsCleared: number;
+    itemsCollected: number;
+    totalItems: number;
+    bossesDefeated: number;
+    totalBosses: number;
+};
+export declare function createMapRoom(partial: Partial<MapRoom>): MapRoom;
+export declare function createZone(partial: Partial<Zone>): Zone;
+export declare function createMapItem(type: MapItem['type'], subtype: string, position: Vec2, options?: Partial<MapItem>): MapItem;
+export declare function createRoomEnemy(type: string, position: Vec2, health: number, options?: Partial<RoomEnemy>): RoomEnemy;
+export declare function createConnection(direction: RoomConnection['direction'], targetRoomId: string, targetEntrance: string, options?: Partial<RoomConnection>): RoomConnection;
+export declare function createSecretWall(position: Vec2, size: {
+    width: number;
+    height: number;
+}, revealMethod: SecretWall['revealMethod'], options?: Partial<SecretWall>): SecretWall;

package/dist/types/templates/SurvivalTemplate.d.ts

@@ -0,0 +1,208 @@
+import type { Vec2 } from '../core/types';
+export interface SurvivalNeeds {
+    health: number;
+    maxHealth: number;
+    hunger: number;
+    maxHunger: number;
+    thirst: number;
+    maxThirst: number;
+    stamina: number;
+    maxStamina: number;
+    temperature: number;
+    sanity?: number;
+    maxSanity?: number;
+}
+export type ResourceType = 'wood' | 'stone' | 'iron' | 'coal' | 'gold' | 'diamond' | 'fiber' | 'leather' | 'cloth' | 'meat' | 'fish' | 'berries' | 'water' | 'herbs' | 'bone' | 'feather' | 'oil' | 'sulfur';
+export interface ResourceNode {
+    id: string;
+    type: ResourceType;
+    position: Vec2;
+    amount: number;
+    maxAmount: number;
+    respawnTime: number;
+    lastHarvested: number;
+    tool?: string;
+    harvestTime: number;
+}
+export interface CraftingIngredient {
+    resourceType: ResourceType;
+    amount: number;
+}
+export interface CraftingRecipe {
+    id: string;
+    name: string;
+    category: 'tool' | 'weapon' | 'armor' | 'building' | 'consumable' | 'material' | 'furniture';
+    ingredients: CraftingIngredient[];
+    output: {
+        itemId: string;
+        amount: number;
+    };
+    craftingTime: number;
+    requiredStation?: string;
+    requiredSkillLevel?: number;
+    unlocked: boolean;
+}
+export interface CraftingStation {
+    id: string;
+    name: string;
+    tier: number;
+    position: Vec2;
+    recipes: string[];
+    fuel?: {
+        current: number;
+        max: number;
+        burnRate: number;
+        acceptedFuel: ResourceType[];
+    };
+    inputSlots: number;
+    outputSlots: number;
+}
+export interface BuildingBlueprint {
+    id: string;
+    name: string;
+    category: 'foundation' | 'wall' | 'floor' | 'roof' | 'door' | 'window' | 'furniture' | 'storage' | 'crafting' | 'defense';
+    size: {
+        width: number;
+        height: number;
+    };
+    ingredients: CraftingIngredient[];
+    health: number;
+    snapPoints: Vec2[];
+    placementRules: PlacementRule[];
+}
+export interface PlacementRule {
+    type: 'requires_foundation' | 'requires_support' | 'water_only' | 'land_only' | 'minimum_distance' | 'maximum_height';
+    value?: number;
+}
+export interface PlacedBuilding {
+    id: string;
+    blueprintId: string;
+    position: Vec2;
+    rotation: number;
+    health: number;
+    maxHealth: number;
+    ownerPlayerId: string;
+    storedItems?: Array<{
+        itemId: string;
+        amount: number;
+    }>;
+}
+export interface WeatherType {
+    id: string;
+    name: string;
+    temperatureModifier: number;
+    visibility: number;
+    wetness: number;
+    windSpeed: number;
+    effects: WeatherEffect[];
+}
+export type WeatherEffect = {
+    type: 'damage';
+    damagePerSecond: number;
+} | {
+    type: 'slow';
+    multiplier: number;
+} | {
+    type: 'resource_bonus';
+    resourceType: ResourceType;
+    multiplier: number;
+};
+export interface DayNightCycle {
+    currentTime: number;
+    dayLength: number;
+    dawnTime: number;
+    duskTime: number;
+    nightDangerMultiplier: number;
+}
+export interface EnvironmentalHazard {
+    id: string;
+    type: 'fire' | 'poison' | 'radiation' | 'cold' | 'heat' | 'drowning';
+    position: Vec2;
+    radius: number;
+    damagePerSecond: number;
+    effectDuration: number;
+}
+export interface SurvivalConfig {
+    hungerDecayRate: number;
+    thirstDecayRate: number;
+    staminaRegenRate: number;
+    staminaDecayOnRun: number;
+    healthRegenRate: number;
+    healthRegenThreshold: number;
+    deathOnZeroHunger: boolean;
+    deathOnZeroThirst: boolean;
+    temperatureComfortRange: {
+        min: number;
+        max: number;
+    };
+    temperatureDamageRate: number;
+    respawnPenalty: {
+        hungerPercent: number;
+        inventoryDrop: boolean;
+    };
+}
+export interface SurvivalState {
+    needs: SurvivalNeeds;
+    inventory: Array<{
+        itemId: string;
+        amount: number;
+        durability?: number;
+    }>;
+    hotbar: (string | null)[];
+    equipment: {
+        head?: string;
+        body?: string;
+        legs?: string;
+        feet?: string;
+        mainHand?: string;
+        offHand?: string;
+    };
+    unlockedRecipes: string[];
+    placedBuildings: PlacedBuilding[];
+    discoveredNodes: string[];
+    currentWeather: string;
+    dayNight: DayNightCycle;
+    worldSeed: number;
+    playTime: number;
+    deaths: number;
+}
+export declare const DEFAULT_SURVIVAL_CONFIG: SurvivalConfig;
+export declare const DEFAULT_DAY_NIGHT: DayNightCycle;
+export declare const WEATHER_CLEAR: WeatherType;
+export declare const WEATHER_RAIN: WeatherType;
+export declare const WEATHER_STORM: WeatherType;
+export declare const WEATHER_SNOW: WeatherType;
+export declare const WEATHER_HEATWAVE: WeatherType;
+export declare const RECIPE_WORKBENCH: CraftingRecipe;
+export declare const RECIPE_CAMPFIRE: CraftingRecipe;
+export declare const RECIPE_STONE_AXE: CraftingRecipe;
+export declare const RECIPE_STONE_PICKAXE: CraftingRecipe;
+export declare const RECIPE_COOKED_MEAT: CraftingRecipe;
+export declare const RECIPE_WOODEN_WALL: CraftingRecipe;
+export declare const RECIPE_IRON_AXE: CraftingRecipe;
+export declare function createSurvivalNeeds(config?: Partial<SurvivalNeeds>): SurvivalNeeds;
+export declare function createSurvivalState(worldSeed?: number): SurvivalState;
+export declare function updateSurvivalNeeds(state: SurvivalState, dt: number, config: SurvivalConfig, isRunning: boolean): void;
+export declare function updateDayNight(state: SurvivalState, realDeltaSeconds: number): void;
+export declare function isNight(dayNight: DayNightCycle): boolean;
+export declare function getDaylightLevel(dayNight: DayNightCycle): number;
+export declare function canCraft(recipe: CraftingRecipe, inventory: Array<{
+    itemId: string;
+    amount: number;
+}>, nearbyStations: string[]): boolean;
+export declare function craft(state: SurvivalState, recipe: CraftingRecipe): boolean;
+export declare function harvestResource(node: ResourceNode, tool: string | undefined, harvestAmount?: number): {
+    resourceType: ResourceType;
+    amount: number;
+} | null;
+export declare function respawnResources(nodes: ResourceNode[], currentTime: number): void;
+export declare function canPlaceBuilding(blueprint: BuildingBlueprint, position: Vec2, existingBuildings: PlacedBuilding[]): {
+    canPlace: boolean;
+    reason?: string;
+};
+export declare function placeBuilding(state: SurvivalState, blueprint: BuildingBlueprint, position: Vec2, rotation: number, playerId: string): PlacedBuilding | null;
+export declare function damageBuilding(building: PlacedBuilding, damage: number): boolean;
+export declare function createResourceNode(type: ResourceType, position: Vec2, amount: number, options?: Partial<ResourceNode>): ResourceNode;
+export declare function createCraftingRecipe(partial: Partial<CraftingRecipe>): CraftingRecipe;
+export declare function createBuildingBlueprint(partial: Partial<BuildingBlueprint>): BuildingBlueprint;
+export declare function createEnvironmentalHazard(type: EnvironmentalHazard['type'], position: Vec2, radius: number, damagePerSecond: number): EnvironmentalHazard;

package/dist/types/tutorials/TutorialBranching.d.ts

@@ -1,6 +1,6 @@
 import { EventBus } from '../core/EventBus';
-import type { TutorialProgress } from './TutorialEngine';
 import type { Locale } from '../i18n/I18n';
+import type { TutorialProgress } from './TutorialEngine';
 export type BranchConditionType = 'quiz-correct' | 'quiz-incorrect' | 'quiz-answer' | 'code-valid' | 'code-invalid' | 'always';
 export interface BranchCondition {
     type: BranchConditionType;
@@ -120,7 +120,7 @@ export declare class AchievementEngine {
     /** Total XP from unlocked achievements. */
     getTotalXP(): number;
     /** Get visible achievements (not hidden, or hidden but unlocked). */
-    getVisible(locale?: Locale): Array<AchievementDefinition & {
+    getVisible(_locale?: Locale): Array<AchievementDefinition & {
         unlocked: boolean;
         progress: number;
     }>;

package/dist/types/ui/GameUI.d.ts

@@ -1,5 +1,5 @@
-import type { Vec2, Color } from '../core/types';
 import { EventBus } from '../core/EventBus';
+import type { Vec2, Color } from '../core/types';
 export type UIAnchor = 'top-left' | 'top-center' | 'top-right' | 'center-left' | 'center' | 'center-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
 export type UIElementType = 'text' | 'bar' | 'image' | 'panel' | 'button' | 'container';
 export interface UIStyle {