GamePad.razor

@using Microsoft.AspNetCore.SignalR.Client
@using DanielCarey.Blazor.Controls.Services
@inject NavigationManager NavigationManager
@if (ShowDebug) {
    <div style="border:double 1px black;margin-bottom:.5em;width:auto;">
        <div>Index:&nbsp;@ClientGamepad?.Index</div>
        <div>Id:&nbsp;@ClientGamepad?.Id</div>
        <div>ConnectionId:&nbsp;@ClientGamepad?.ConnectionId</div>
        <div>Mapping:&nbsp;@ClientGamepad?.Mapping</div>
        @if (ClientGamepad?.Buttons.Length > 0) {
            <table style="border:1px double gray;margin-left:5em;">
                <thead>
                    <tr>Buttons</tr>
                    <tr>
                        @for (var x = 0; x < ClientGamepad?.Buttons.Count(); x++) {
                            <td style="text-align:center;min-width:2.5em;border:1px dotted gray;">@x</td>
                        }
                    </tr>
                </thead>
                <tbody>
                    <tr>
                        @foreach (var button in ClientGamepad?.Buttons) {

                            @if (button.Pressed) {
                                <td style="text-align:center;min-width:2.5em;height:1.5em;border:1px solid black;background-color:lime"></td>
                            } else {
                                <td style="text-align:center;min-width:2.5em;height:1.5em;border:1px dotted gray;"></td>
                            }
                        }

                    </tr>
                </tbody>
            </table>
        }
        @if (ClientGamepad?.Axes.Length > 0) {
            <div style="border:1px double gray;margin-left:5em;">
                <p>Axes</p>
                @for (var x = 0; x < ClientGamepad?.Axes.Count(); x++) {
                    <div style="width:5em;text-align:center;min-width:2.5em;border:1px dotted gray;">
                        @x
                    </div>
                    <div style="width:5em;text-align:center;min-width:400px;border:1px dotted gray;">
                        @ClientGamepad?.Axes[x]
                    </div>
                }
            </div>
        }
    </div>
}

@code {

    [Parameter]
    public int Index { get; set; } = -1;

    [Parameter]
    public bool ProcessAllGamePads { get; set; } = false;

    [Parameter]
    public bool OnlyNotifyOnChange { get; set; } = true;

    [Parameter]
    public bool ShowDebug { get; set; } = false;

    [Parameter]
    public EventCallback<ClientGamePadUpdateArgs> OnClientGamepadUpdate { get; set; }


    private GamepadServiceClient? _gamepadServiceClient = null;
    private int GamePadCount { get; set; } = 0;

    private ClientGamepad? ClientGamepad { get; set; } = null;


    private Dictionary<string, ClientGamepad> _allClientGamepads { get; } = new Dictionary<string, ClientGamepad>();

    protected override void OnInitialized() {
        _gamepadServiceClient = new GamepadServiceClient(
        new HubConnectionBuilder()
        .WithUrl(NavigationManager.ToAbsoluteUri(GamepadServiceHub.ChannelName))
        .Build()
    );

        _gamepadServiceClient.OnUpdate += OnGamepadUpdate;
    }

    protected void OnGamepadUpdate(object sender, ClientGamepad[] gamepads) {
        if (ProcessAllGamePads) {
            InternalProcessAllGamePads(sender, gamepads);
        } else {
            InternalProcessSingleGamePad(sender, gamepads);
        }
    }

    private void InternalProcessAllGamePads(object sender, ClientGamepad[] gamepads) {
        bool canInvokeOnClientGamepadUpdate = false;

        // Remember the gamepad count
        var previousGamePadCount = GamePadCount;
        var currentGamePadCount = gamepads.Length;
        GamePadCount = gamepads.Length;

        // Make a list of new keys with gamepad
        var localGamePadList = new Dictionary<string, ClientGamepad>();
        foreach (var gamepad in gamepads) {
            var key = $"{gamepad.Index}{gamepad.ConnectionId}{gamepad.Id}";
            localGamePadList.Add(key, gamepad);
        }

        // Build a list of keys that need to be removed from the current _allClientGames
        var removeKeys = new List<string>();
        foreach (var key in _allClientGamepads.Keys) {
            if (!localGamePadList.ContainsKey(key)) { removeKeys.Add(key); }
        }
        foreach (var key in removeKeys) { _allClientGamepads.Remove(key); }

        // loop through each gamepad and perform the 'do-i-need-to-notify' logic.
        foreach (var item in localGamePadList) {
            var key = item.Key;
            var gamepad = item.Value;
            canInvokeOnClientGamepadUpdate = false;

            // if the key doesn't exist in the previous _allClientGamepads, add a blank
            if (!_allClientGamepads.ContainsKey(key)) {
                var cg = new ClientGamepad { Index = gamepad.Index, ConnectionId = gamepad.ConnectionId, Id = gamepad.Id };
                _allClientGamepads.Add(key, cg);
            };

            var args = new ClientGamePadUpdateArgs {
                PreviousValue = _allClientGamepads[key],
                PreviousGamePadCount = previousGamePadCount,
                CurrentValue = gamepad,
                CurrentGamePadCount = currentGamePadCount,
            };
            _allClientGamepads[key] = gamepad;

            canInvokeOnClientGamepadUpdate = BuildClientGamePadUpdateArgsDiff(ref args);

            if (OnlyNotifyOnChange == true && (args.ChangedAxesIndexes.Count > 0 || args.ChangedButtonIndexes.Count > 0)) {
                canInvokeOnClientGamepadUpdate = true;

            } else if(OnlyNotifyOnChange == false) {
                canInvokeOnClientGamepadUpdate = true;
            }

            if (canInvokeOnClientGamepadUpdate && OnClientGamepadUpdate.HasDelegate) {
                OnClientGamepadUpdate.InvokeAsync(args);
            }

        }

        StateHasChanged();

    }


    private void InternalProcessSingleGamePad(object sender, ClientGamepad[] gamepads) {
        bool canInvokeOnClientGamepadUpdate = false;

        // Remember the gamepad count
        var previousGamePadCount = GamePadCount;
        var currentGamePadCount = gamepads.Length;
        GamePadCount = gamepads.Length;

        // Return if the index is out of range
        if (Index < 0 || Index >= gamepads.Length) {
            //StateHasChanged();
            return;
        }

        // Push the current value into PreviousValue and Set CurrentValue
        var args = new ClientGamePadUpdateArgs {
            PreviousValue = ClientGamepad,
            PreviousGamePadCount = previousGamePadCount,
            CurrentValue = gamepads[Index],
            CurrentGamePadCount = currentGamePadCount,
        };
        ClientGamepad = gamepads[Index];

        canInvokeOnClientGamepadUpdate = BuildClientGamePadUpdateArgsDiff(ref args);

        if (OnlyNotifyOnChange == true && (args.ChangedAxesIndexes.Count > 0 || args.ChangedButtonIndexes.Count > 0)) {
            canInvokeOnClientGamepadUpdate = true;

        } else if(OnlyNotifyOnChange == false) {
            canInvokeOnClientGamepadUpdate = true;
        }

        if (canInvokeOnClientGamepadUpdate && OnClientGamepadUpdate.HasDelegate) {
            OnClientGamepadUpdate.InvokeAsync(args);
        }

        StateHasChanged();
    }

    private bool BuildClientGamePadUpdateArgsDiff(ref ClientGamePadUpdateArgs args) {
        bool canInvokeOnClientGamepadUpdate = false;

        // if this isn't the same input device or signalr channel, return;
        if (args.PreviousValue == null || args.CurrentValue == null ||
        args.PreviousValue.Id != args.CurrentValue.Id ||
        args.PreviousValue.ConnectionId != args.CurrentValue.ConnectionId) {
            return canInvokeOnClientGamepadUpdate;
        }

        // Build the argument parameters that list the differencesbetween PreviousValue and CurrentValue
        if (args.PreviousValue != null && args.PreviousValue.Axes != null) {
            for (int x = 0; x < args.PreviousValue.Axes.Length; x++) {
                if (args.PreviousValue.Axes[x] != args.CurrentValue.Axes[x]) {
                    canInvokeOnClientGamepadUpdate = true;
                    args.ChangedAxesIndexes.Add(x);
                }
            }
        }

        if (args.PreviousValue != null && args.PreviousValue.Buttons != null) {
            for (int x = 0; x < args.PreviousValue.Buttons.Length; x++) {
                if (args.PreviousValue.Buttons[x].Value != args.CurrentValue.Buttons[x].Value) {
                    canInvokeOnClientGamepadUpdate = true;
                    args.ChangedButtonIndexes.Add(x);
                }
            }
        }

        return canInvokeOnClientGamepadUpdate;
    }
}