neser 0.1.1

NESER - NES Emulator in Rust - is a NES emulator written in Rust. It aims to be a high-quality, hardware-accurate emulator that is also easy to use and extend. It supports a wide range of NES games and features, including various mappers, audio processing, and input handling. NESER is designed to be modular and extensible, allowing developers to easily add new features or support for additional hardware. It can be run using one of two frontends: a native desktop application using SDL2, or a web application using WebAssembly. The desktop application provides a high-performance, feature-rich experience with support for various input devices and display options, while the web application allows users to play NES games directly in their browsers without needing to install any software in a BYOR manner (Bring Your Own Roms).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

import { shouldSuppressJoypadInput } from "./input_routing.js";

export function mapMouseXToPaddlePosition(x, windowWidth) {
    const minPosition = 0x62;
    const maxPosition = 0xF2;
    const range = maxPosition - minPosition;

    if (windowWidth <= 1) {
        return minPosition;
    }

    const maxX = windowWidth - 1;
    const clampedX = Math.min(Math.max(x, 0), maxX);
    const normalized = (clampedX / maxX) * 2 - 1;
    const curved = Math.sign(normalized) * Math.pow(Math.abs(normalized), 1.5);
    const scaled = (curved + 1) * 0.5 * range + minPosition;

    return Math.min(maxPosition, Math.max(minPosition, Math.round(scaled)));
}

export function mapMouseXToZapperPosition(x, windowWidth) {
    if (windowWidth <= 1) {
        return 0;
    }

    const maxX = windowWidth - 1;
    const clampedX = Math.min(Math.max(x, 0), maxX);
    const normalized = clampedX / maxX;
    const scaled = normalized * 255;

    return Math.min(255, Math.max(0, Math.round(scaled)));
}

export function mapMouseYToZapperPosition(y, windowHeight) {
    if (windowHeight <= 1) {
        return 0;
    }

    const maxY = windowHeight - 1;
    const clampedY = Math.min(Math.max(y, 0), maxY);
    const normalized = clampedY / maxY;
    const scaled = normalized * 239;

    return Math.min(239, Math.max(0, Math.round(scaled)));
}

export function mapMouseAxisToSnesMousePosition(axis, windowExtent) {
    if (windowExtent <= 1) {
        return 0;
    }

    const maxAxis = windowExtent - 1;
    const clamped = Math.min(Math.max(axis, 0), maxAxis);
    const normalized = clamped / maxAxis;
    const scaled = normalized * 255;

    return Math.min(255, Math.max(0, Math.round(scaled)));
}

export function applyMouseMotion(nes, x, y, windowWidth, windowHeight) {
    const isZapper = isZapperActive(nes);
    const isSnesMouse =
        nes.is_snes_mouse_active?.(1) ||
        nes.is_snes_mouse_active?.(2);
    
    if (isZapper) {
        const positionX = mapMouseXToZapperPosition(x, windowWidth);
        const positionY = mapMouseYToZapperPosition(y, windowHeight);
        nes.set_mouse_x_position(positionX);
        nes.set_mouse_y_position(positionY);
    } else if (isSnesMouse) {
        const positionX = mapMouseAxisToSnesMousePosition(x, windowWidth);
        const positionY = mapMouseAxisToSnesMousePosition(y, windowHeight);
        nes.set_mouse_x_position(positionX);
        nes.set_mouse_y_position(positionY);
    } else {
        // Arkanoid paddle only uses X position
        const positionX = mapMouseXToPaddlePosition(x, windowWidth);
        nes.set_mouse_x_position(positionX);
    }
}

export function applyMouseButton(nes, button, pressed) {
    if (button === 0) {
        nes.set_mouse_left_button(pressed);
    } else if (button === 2) {
        nes.set_mouse_right_button(pressed);
    }
}

export function applyJoypadButtonIfAllowed(nes, controller, button, pressed) {
    // Check if there's a mouse-emulated controller on this port
    if (shouldSuppressJoypadInput(nes, controller)) {
        return; // Suppress joypad input on the port with mouse-emulated controller
    }

    nes.set_button(controller, button, pressed);
}

export function isZapperActive(nes) {
    // Check if Zapper is active on either port
    return nes.is_zapper_active(1) || nes.is_zapper_active(2);
}