InputComponent.java

package dev.isxander.controlify.controller.input;

import dev.isxander.controlify.Controlify;
import dev.isxander.controlify.bindings.ControlifyBindApiImpl;
import dev.isxander.controlify.api.bind.InputBinding;
import dev.isxander.controlify.bindings.input.InputType;
import dev.isxander.controlify.config.settings.device.DeviceSettings;
import dev.isxander.controlify.config.settings.profile.InputSettings;
import dev.isxander.controlify.controller.*;
import dev.isxander.controlify.controller.impl.ECSComponentImpl;
import dev.isxander.controlify.controller.input.mapping.ControllerMapping;
import dev.isxander.controlify.utils.CUtil;
import net.minecraft.resources.Identifier;
import org.jetbrains.annotations.Nullable;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

public class InputComponent extends ECSComponentImpl {
    public static final Identifier ID = CUtil.rl("input");

    private final ControllerEntity controller;
    private DeviceSettings deviceSettings; // Cached reference

    private ControllerState
            stateNow = ControllerState.EMPTY,
            stateThen = ControllerState.EMPTY;
    private DeadzoneControllerStateView
            deadzoneStateNow,
            deadzoneStateThen;

    private final int buttonCount, axisCount, hatCount;
    private final Map<Identifier, DeadzoneGroup> deadzoneAxes;
    private final boolean definitelyGamepad;

    private final Map<Identifier, InputBinding> inputBindings;

    public InputComponent(
            ControllerEntity controller,
            int buttonCount, int axisCount, int hatCount,
            boolean definitelyGamepad,
            Set<DeadzoneGroup> deadzoneAxes,
            String mappingId
    ) {
        this.controller = controller;
        this.buttonCount = buttonCount;
        this.axisCount = axisCount;
        this.hatCount = hatCount;
        this.definitelyGamepad = definitelyGamepad;
        this.deadzoneAxes = deadzoneAxes.stream()
                .collect(Collectors.toMap(
                        DeadzoneGroup::name,
                        Function.identity(),
                        (x, y) -> y,
                        LinkedHashMap::new
                ));
        this.inputBindings = new LinkedHashMap<>();

        this.updateDeadzoneView();
    }

    public ControllerStateView stateNow() {
        return this.deadzoneStateNow;
    }
    public ControllerStateView stateThen() {
        return this.deadzoneStateThen;
    }

    public ControllerState rawStateNow() {
        return this.stateNow;
    }

    public ControllerState rawStateThen() {
        return this.stateThen;
    }

    public void pushState(ControllerState state) {
        ControllerMapping mapping = getDeviceMapping();
        if (mapping != null) {
            state = mapping.mapState(state);
        }

        this.stateThen = this.stateNow;
        this.stateNow = state;
        this.updateDeadzoneView();

        // Get all the CompoundInputs from the current inputs.
        List<InputBinding> sortedBindings = this.inputBindings.values().stream()
                .filter(object -> object.boundInput().type() == InputType.COMPOUND)
                .toList();
        List<Identifier> boundIdentifiers = new ArrayList<>();
        // For all the active CompoundInputs, get a list of the underlying active inputs.
        sortedBindings.forEach(inputBinding -> {
            if (inputBinding.boundInput().state(this.deadzoneStateNow) == 1)
                boundIdentifiers.addAll(inputBinding.boundInput().getRelevantInputs());
        });
        Set<Identifier> boundIdentifierSet = new HashSet<>(boundIdentifiers);
        // Prevent those active inputs from being used in a non-compound bind.
        for (InputBinding binding : this.inputBindings.values()) {
            if (binding.boundInput().type() != InputType.COMPOUND) {
                if (boundIdentifierSet.containsAll(binding.boundInput().getRelevantInputs())) {
                    binding.limitActivity();
                }
            }
            binding.pushState(this.deadzoneStateNow);
        }
    }

    public @Nullable InputBinding getBinding(Identifier id) {
        return this.inputBindings.get(id);
    }

    public Collection<InputBinding> getAllBindings() {
        return this.inputBindings.values();
    }

    public void notifyGuiPressOutputsOfNavigate() {
        for (InputBinding binding : this.inputBindings.values()) {
            binding.guiPressed().onNavigate();
        }
    }

    @Override
    public void attach(ControllerEntity controller) {
        super.attach(controller);

        // Cache device settings reference
        this.deviceSettings = Controlify.instance().config().getSettings()
                .getOrCreateDeviceSettings(controller.uid());

        // Populate bindings
        for (InputBinding binding : ControlifyBindApiImpl.INSTANCE.provideBindsForController(controller)) {
            this.inputBindings.put(binding.id(), binding);
        }

        // Note: No need to copy bound inputs from config here since InputBindingImpl.boundInput()
        // now reads directly from the config (via inputComponent.settings().bindings.bindings)
    }

    public int buttonCount() {
        return this.buttonCount;
    }
    public int axisCount() {
        return this.axisCount;
    }
    public int hatCount() {
        return this.hatCount;
    }

    public boolean isDefinitelyGamepad() {
        return this.definitelyGamepad;
    }

    public Map<Identifier, DeadzoneGroup> getDeadzoneGroups() {
        ControllerMapping mapping = getDeviceMapping();
        if (mapping != null) {
            return mapping.deadzones();
        } else {
            return this.deadzoneAxes;
        }
    }

    private @Nullable ControllerMapping getDeviceMapping() {
        // Use cached device settings to avoid repeated lookups
        return deviceSettings.mapping;
    }

    public ControllerEntity getController() {
        return controller();
    }

    public InputSettings settings() {
        return this.controller().settings().input;
    }

    public InputSettings defaultSettings() {
        return this.controller().defaultSettings().input;
    }

    @Override
    public Identifier id() {
        return ID;
    }

    private void updateDeadzoneView() {
        this.deadzoneStateNow = new DeadzoneControllerStateView(this.stateNow, this);
        this.deadzoneStateThen = new DeadzoneControllerStateView(this.stateThen, this);
    }

    Optional<Identifier> getDeadzoneForAxis(Identifier axis) {
        for (DeadzoneGroup group : this.getDeadzoneGroups().values()) {
            if (group.axes().contains(axis)) {
                return Optional.of(group.name());
            }
        }
        return Optional.empty();
    }
}