js/source/systems/interaction/InteractionSystem.js - master - RaskolnickOFF/3D

js/source/systems/interaction/InteractionSystem.js
120 строк5 KB
RaskolnickOFF
Structure update
06 июн 2026, 03:18
06 июн 2026, 03:189bc1c25
// js/source/systems/interaction/InteractionSystem.js — подбор предметов по E (симуляция)

import { Components } from '../../core/Components.js';
import { GameEvents } from '../../core/GameEvents.js';

export class InteractionSystem {

    constructor(ctx, inputSystem) {
        this.engine = ctx.engine;
        this.input = inputSystem;
        this.eventBus = ctx.eventBus;
        this.interactRadius = 2;
        this._wasEPressed = false;
        this.settings = ctx.settings;
    }

    update(engine, dt) {
        const ePressed = this.input.isPressed('e');
        const justPressed = ePressed && !this._wasEPressed;
        this._wasEPressed = ePressed;

        if (!justPressed) return;

        let player = null;
        for (const entity of this.engine.with(Components.PLAYER)) {
            player = entity;
            break;
        }
        if (!player) return;

        const playerTransform = player.get(Components.TRANSFORM);
        if (!playerTransform) return;

        const entities = this.engine.with(Components.MESH);
        const items = entities.filter(e => !e.has(Components.PLAYER)
            && !e.has(Components.ENEMY)
            && !e.has(Components.TREE));

        let closestEntity = null;
        let closestDist = this.interactRadius;

        for (const entity of items) {
            const pos = entity.get(Components.TRANSFORM);
            if (!pos) continue;

            const dx = playerTransform.x - pos.x;
            const dz = playerTransform.z - pos.z;
            const dist = Math.sqrt(dx * dx + dz * dz);

            if (dist < closestDist) {
                closestDist = dist;
                closestEntity = entity;
            }
        }

        if (closestEntity) {
            const itemType = closestEntity.get(Components.ITEM_TYPE);

            if (itemType && itemType.startsWith('berry')) {
                // === СБОР ЯГОД С КУСТА ===
                const bush = closestEntity.get(Components.BERRY_BUSH);
                if (bush && bush.growthProgress >= 1 && !bush.isGrowing) {
                    const mesh = closestEntity.get(Components.MESH);
                    const berryGroup = mesh.getObjectByName('berryGroup');
                    if (berryGroup) {
                        berryGroup.scale.setScalar(0);
                    }
                    closestEntity.add(Components.BERRY_BUSH, { growthProgress: 0, isGrowing: false });

                    // Выдать ягоды
                    const bushType = closestEntity.get(Components.BERRY_BUSH_TYPE)
                        || closestEntity.get(Components.ITEM_TYPE)
                        || 'berryRed';
                    const berryName = this.settings.food?.[bushType]?.name || 'Ягоды';
                    this.eventBus.emit(GameEvents.ITEM_PICKED_UP, {
                        itemName: berryName,
                        amount: 1,
                        entity: closestEntity,
                    });
                    console.log(`Picked ${berryName} from bush ${closestEntity.id}`);
                    // НЕ удаляем куст
                }
            } else {
                // === ОБЫЧНЫЙ ПРЕДМЕТ (синий шар) ===
                const mesh = closestEntity.get(Components.MESH);
                this.eventBus.emit(GameEvents.ITEM_PICKED_UP, {
                    itemName: 'Синий шар',
                    amount: 1,
                    entity: closestEntity,
                });
                console.log(`Picked up entity ${closestEntity.id}, distance: ${closestDist.toFixed(2)}`);
                closestEntity.add(Components.PENDING_DESTROY, true);
            }
        }

        // Отдельная проверка для деревьев
        const treeEntities = this.engine.with(Components.TREE);
        let closestTree = null;
        let closestTreeDist = this.interactRadius;

        for (const entity of treeEntities) {
            const pos = entity.get(Components.TRANSFORM);
            if (!pos) continue;

            const dx = playerTransform.x - pos.x;
            const dz = playerTransform.z - pos.z;
            const dist = Math.sqrt(dx * dx + dz * dz);

            if (dist < closestTreeDist) {
                closestTreeDist = dist;
                closestTree = entity;
            }
        }

        if (closestTree) {
            const treeType = closestTree.get(Components.TREE_TYPE) || 'неизвестное';
            console.log(`🌲 Обнаружено дерево: ${treeType}, distance: ${closestTreeDist.toFixed(2)}, id:${closestTree.id}`);
        }
    }
}