fork/slippi-nix

git clone https://git.julia.blue/fork/slippi-nix

Julia Ryanchore(updates)7950757

main
21.8 KiB594 linesraw
1{
2  inputs = {
3    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
4    git-hooks.url = "github:cachix/git-hooks.nix";
5    git-hooks.inputs.nixpkgs.follows = "nixpkgs";
6    home-manager.url = "github:nix-community/home-manager";
7    home-manager.inputs.nixpkgs.follows = "nixpkgs";
8  };
9
10  nixConfig = {
11    extra-substituters = [
12      "https://slippi-nix.cachix.org"
13    ];
14
15    extra-trusted-public-keys = [
16      "slippi-nix.cachix.org-1:2qnPHiOxTRpzgLEtx6K4kXq/ySDg7zHEJ58J6xNDvBo="
17    ];
18  };
19
20  outputs = {
21    nixpkgs,
22    git-hooks,
23    home-manager,
24    self,
25    ...
26  }: let
27    defaults = {
28      netplay = {
29        version = "3.4.4";
30        hash = "sha256-L+8DvEsaSGzJBg1gN3K4ntzvfnXFMssgKqPU40iOSTs=";
31      };
32      netplay-beta = {
33        version = "4.0.0-mainline-beta.8";
34        hash = "sha256-f9jx1ZzUr6oxCvPS1RG115EX13ocTeoEAdrke7YnWu0=";
35      };
36      playback = {
37        version = "3.4.5";
38        hash = "sha256-iCBdlcBPSRT8m772sqI+gSfNmVNAug0SfkSwVUE6+fE=";
39      };
40      launcher = {
41        version = "2.11.7";
42        hash = "sha256-wlPAbXzUdmu0zQE6H1FfUc4bk3yBptauC+86mwWFrRg=";
43      };
44    };
45
46    inherit (self) outputs;
47    forSystems = nixpkgs.lib.genAttrs [
48      # "aarch64-linux"
49      # "aarch64-darwin"
50      # "x86_64-darwin"
51      "x86_64-linux"
52    ];
53    pkgsFor = system: (import nixpkgs {inherit system;});
54    genPkgs = func: (forSystems (system: func (pkgsFor system)));
55  in {
56    overlays = {
57      default = outputs.overlays.slippi;
58
59      slippi = final: prev: {
60        inherit (outputs.packages.${final.system}.slippi) slippi-netplay slippi-playback slippi-launcher;
61      };
62    };
63
64    packages = genPkgs (pkgs: {
65      default = outputs.packages.${pkgs.system}.slippi-launcher;
66      slippi-netplay-beta = pkgs.callPackage ({
67        stdenvNoCC,
68        appimageTools,
69        fetchzip,
70        makeWrapper,
71        lib,
72        version ? defaults.netplay-beta.version,
73        hash ? defaults.netplay-beta.hash,
74      }: let
75        pname = "Slippi_Netplay_Mainline-x86_64.AppImage";
76        zip = fetchzip {
77          inherit hash;
78          url = "https://github.com/project-slippi/dolphin/releases/download/v${version}/Mainline-Slippi-${version}-Linux.zip";
79          stripRoot = false;
80        };
81        src = "${zip}/Slippi_Netplay_Mainline-x86_64.AppImage";
82      in
83        stdenvNoCC.mkDerivation {
84          inherit pname version;
85          nativeBuildInputs = [
86            makeWrapper
87          ];
88          src = appimageTools.wrapType2 {
89            inherit pname version src;
90            extraPkgs = pkgs: with pkgs; [curl libsForQt5.qt5.qttools];
91          };
92
93          installPhase = ''
94            runHook preInstall
95            mkdir -p "$out/bin"
96            cp -r "$src/bin" "$out"
97            wrapProgram $out/bin/${pname} \
98              --set QT_QPA_PLATFORM xcb
99            runHook postInstall
100          '';
101        }) {};
102      slippi-netplay = pkgs.callPackage ({
103        stdenvNoCC,
104        appimageTools,
105        fetchzip,
106        version ? defaults.netplay.version,
107        hash ? defaults.netplay.hash,
108      }: let
109        pname = "Slippi_Online-x86_64.AppImage";
110        zip = fetchzip {
111          inherit hash;
112          url = "https://github.com/project-slippi/Ishiiruka/releases/download/v${version}/FM-Slippi-${version}-Linux.zip";
113          stripRoot = false;
114        };
115        src = "${zip}/Slippi_Online-x86_64.AppImage";
116      in
117        stdenvNoCC.mkDerivation {
118          inherit pname version;
119
120          src = appimageTools.wrapType2 {
121            inherit pname version src;
122            extraPkgs = pkgs: with pkgs; [curl zlib mpg123];
123
124            postInstall = ''
125              ls -la "$out"
126              wrapProgram $out/bin/${pname}-${version} \
127                --add-flags "\''${NIXOS_OZONE_WL:+\''${WAYLAND_DISPLAY:+--ozone-platform-hint=auto --enable-features=WaylandWindowDecorations}}"
128            '';
129          };
130
131          installPhase = ''
132            runHook preInstall
133
134            mkdir -p "$out/bin"
135            cp -r "$src/bin" "$out"
136
137            runHook postInstall
138          '';
139        }) {};
140      slippi-playback = pkgs.callPackage ({
141        stdenvNoCC,
142        appimageTools,
143        fetchzip,
144        version ? defaults.playback.version,
145        hash ? defaults.playback.hash,
146      }: let
147        pname = "Slippi_Playback-x86_64.AppImage";
148        zip = fetchzip {
149          inherit hash;
150          url = "https://github.com/project-slippi/Ishiiruka-Playback/releases/download/v${version}/playback-${version}-Linux.zip";
151          stripRoot = false;
152        };
153        src = "${zip}/Slippi_Playback-x86_64.AppImage";
154      in
155        stdenvNoCC.mkDerivation {
156          inherit pname version;
157
158          src = appimageTools.wrapType2 {
159            inherit pname version src;
160            extraPkgs = pkgs: with pkgs; [curl zlib mpg123];
161
162            postInstall = ''
163              ls -la "$out"
164              wrapProgram $out/bin/${pname}-${version} \
165                --add-flags "\''${NIXOS_OZONE_WL:+\''${WAYLAND_DISPLAY:+--ozone-platform-hint=auto --enable-features=WaylandWindowDecorations}}"
166            '';
167          };
168
169          installPhase = ''
170            runHook preInstall
171
172            mkdir -p "$out/bin"
173            cp -r "$src/bin" "$out"
174
175            runHook postInstall
176          '';
177        }) {};
178      slippi-launcher = pkgs.callPackage ({
179        stdenvNoCC,
180        appimageTools,
181        fetchurl,
182        copyDesktopItems,
183        version ? defaults.launcher.version,
184        hash ? defaults.launcher.hash,
185      }: let
186        pname = "slippi-launcher-appimage";
187
188        src = fetchurl {
189          inherit hash;
190          url = "https://github.com/project-slippi/slippi-launcher/releases/download/v${version}/Slippi-Launcher-${version}-x86_64.AppImage";
191        };
192
193        appImageContents = appimageTools.extractType2 {
194          inherit pname version src;
195        };
196      in
197        stdenvNoCC.mkDerivation {
198          inherit pname version;
199
200          src = appimageTools.wrapType2 {
201            inherit pname version src;
202            extraPkgs = pkgs: with pkgs; [curl zlib mpg123];
203
204            postInstall = ''
205              ls -la "$out"
206              wrapProgram $out/bin/${pname}-${version} \
207                --add-flags "\''${NIXOS_OZONE_WL:+\''${WAYLAND_DISPLAY:+--ozone-platform-hint=auto --enable-features=WaylandWindowDecorations}}"
208            '';
209          };
210
211          # TODO: see if we can convince upstream to let us specify command line
212          # arguments to denote where the netplay and playback binaries are?
213          # this might eliminate the need for the home manager module
214          installPhase = ''
215            runHook preInstall
216
217            mkdir -p "$out/bin"
218            mkdir -p "$out/share/applications"
219            cp -r "$src/bin" "$out"
220            cp -r "${appImageContents}/$(readlink "${appImageContents}/slippi-launcher.png")" "$out/share/applications/"
221            sed '/Icon/d' "${appImageContents}/slippi-launcher.desktop" > "$out/share/applications/slippi-launcher.desktop"
222            sed '/Exec/d' "${appImageContents}/slippi-launcher.desktop" > "$out/share/applications/slippi-launcher.desktop"
223            echo "Icon=$out/share/applications/slippi-launcher.png" >> "$out/share/applications/slippi-launcher.desktop"
224            echo "Exec=$out/bin/${pname} %U" >> "$out/share/applications/slippi-launcher.desktop"
225
226            runHook postInstall
227          '';
228
229          nativeBuildInputs = [copyDesktopItems];
230        }) {};
231    });
232
233    formatter = genPkgs (p: p.alejandra);
234
235    checks = genPkgs (pkgs: {
236      inherit (outputs.packages.${pkgs.system}) slippi-launcher slippi-netplay slippi-playback;
237      git-hooks = git-hooks.lib.${pkgs.system}.run {
238        src = ./.;
239        hooks = {
240          alejandra.enable = true;
241        };
242      };
243      home-manager-module-test = pkgs.testers.runNixOSTest {
244        # a simple integration test to ensure that the home manager module
245        # works, boots a host, implying a successful NixOS configuration, and
246        # creates the configuration file referencing the correct packages'
247        # versions
248        name = "home-manager-module-test";
249        nodes.machine = {
250          config,
251          pkgs,
252          ...
253        }:
254          with pkgs.lib; {
255            imports = [
256              home-manager.nixosModules.home-manager
257              (
258                # nixos/tests/common/auto.nix from nixpkgs
259                {config, ...}: let
260                  cfg = config.test-support.displayManager.auto;
261                in {
262                  options = {
263                    test-support.displayManager.auto = {
264                      enable = mkOption {
265                        default = false;
266                        description = ''
267                          Whether to enable the fake "auto" display manager, which
268                          automatically logs in the user specified in the
269                          {option}`user` option.  This is mostly useful for
270                          automated tests.
271                        '';
272                      };
273                      user = mkOption {
274                        default = "root";
275                        description = "The user account to login automatically.";
276                      };
277                    };
278                  };
279                  config = {
280                    services.xserver.displayManager.lightdm.enable = cfg.enable;
281                    services.displayManager.autoLogin = {
282                      enable = cfg.enable;
283                      user = cfg.user;
284                    };
285                    security.pam.services.lightdm-autologin.text = mkIf cfg.enable (mkForce ''
286                      auth     requisite pam_nologin.so
287                      auth     required  pam_succeed_if.so quiet
288                      auth     required  pam_permit.so
289                      account  include   lightdm
290                      password include   lightdm
291                      session  include   lightdm
292                    '');
293                  };
294                }
295              )
296              {
297                services.xserver.enable = true;
298                test-support.displayManager.auto.enable = true;
299                services.displayManager.defaultSession = mkDefault "none+icewm";
300                services.xserver.windowManager.icewm.enable = true;
301              }
302            ];
303            users.users.daniel = {
304              isNormalUser = true;
305              home = "/home/daniel";
306              createHome = true;
307              extraGroups = ["wheel" "users"];
308            };
309            test-support.displayManager.auto.user = "daniel";
310            home-manager.users.daniel = {
311              imports = with outputs.homeManagerModules; [
312                slippi-launcher
313              ];
314              slippi-launcher.enable = true;
315              home = {
316                username = "daniel";
317                homeDirectory = "/home/daniel";
318                stateVersion = "24.11";
319              };
320            };
321            environment.systemPackages = with pkgs; [jq];
322            system.stateVersion = "24.11";
323          };
324        testScript = {nodes, ...}: ''
325          def as_user(cmd: str):
326              """
327              Return a shell command for running a shell command as a specific user.
328              """
329              return f"sudo -u daniel -i -- bash -c \"{cmd}\""
330
331          with subtest("ensure slippi launcher settings file references correct versions"):
332              machine.wait_for_unit("default.target")
333              machine.succeed("grep ${defaults.netplay.version} '/home/daniel/.config/Slippi Launcher/Settings'")
334              machine.succeed("grep ${defaults.playback.version} '/home/daniel/.config/Slippi Launcher/Settings'")
335
336          with subtest("ensure netplay appimage version is correct"):
337              machine.wait_for_unit("default.target")
338              machine.wait_for_x()
339              machine.wait_for_file("/home/daniel/.Xauthority")
340              machine.succeed("xauth merge /home/daniel/.Xauthority")
341              machine.succeed(as_user("""
342              "''$(jq -r '.settings.netplayDolphinPath' '/home/daniel/.config/Slippi Launcher/Settings')/Slippi_Online-x86_64.AppImage" --version | grep ${defaults.netplay.version}
343              """))
344        '';
345      };
346    });
347
348    nixosModules = {
349      default = {
350        imports = with outputs.nixosModules; [
351          gamecube-controller-adapter
352        ];
353      };
354
355      gamecube-controller-adapter = {
356        lib,
357        config,
358        ...
359      }: let
360        inherit (lib) mkEnableOption mkOption types mkIf;
361        cfg = config.gamecube-controller-adapter;
362      in {
363        # defaults here are true since we assume if you're importing the module, you
364        # want it on ;)
365        options.gamecube-controller-adapter = {
366          enable = mkEnableOption "Enable the optimal gamecube controller adapter experience." // {default = true;};
367
368          overclocking-kernel-module.enable = mkEnableOption "Turn on gamecube controller adapter overclocking kernel module." // {default = true;};
369
370          udev-rules.enable = mkEnableOption "Turn on udev rules for your gamecube controller adapter." // {default = true;};
371          udev-rules.rules = mkOption {
372            default = ''
373              ATTRS{idVendor}=="057e", ATTRS{idProduct}=="0337", MODE="666", SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_device" TAG+="uaccess"
374            '';
375            type = types.lines;
376            description = "To be appended to services.udev.extraRules if gcc.rules.enable is set.";
377          };
378        };
379
380        config = {
381          gamecube-controller-adapter.udev-rules.enable = mkIf cfg.enable true;
382          gamecube-controller-adapter.overclocking-kernel-module.enable = mkIf cfg.enable true;
383
384          services.udev.extraRules = mkIf cfg.udev-rules.enable cfg.udev-rules.rules;
385
386          boot.extraModulePackages = mkIf cfg.overclocking-kernel-module.enable [
387            # https://github.com/NixOS/nixpkgs/blob/master/pkgs/os-specific/linux/gcadapter-oc-kmod/default.nix
388            config.boot.kernelPackages.gcadapter-oc-kmod
389          ];
390          boot.kernelModules = mkIf cfg.overclocking-kernel-module.enable [
391            "gcadapter_oc"
392          ];
393        };
394      };
395    };
396
397    homeManagerModules = {
398      default = {
399        imports = with outputs.homeManagerModules; [
400          slippi-launcher
401        ];
402      };
403
404      slippi-launcher = {
405        lib,
406        pkgs,
407        config,
408        ...
409      }: let
410        inherit (lib) mkEnableOption mkOption types mkIf;
411        cfg = config.slippi-launcher;
412        flakePackages = outputs.packages.${pkgs.system};
413        netplay-beta-package = version: hash:
414          flakePackages.slippi-netplay-beta.overrideAttrs {
415            inherit version hash;
416          };
417        netplay-package = version: hash:
418          flakePackages.slippi-netplay.overrideAttrs {
419            inherit version hash;
420          };
421        playback-package = version: hash:
422          flakePackages.slippi-playback.overrideAttrs {
423            inherit version hash;
424          };
425        launcher-package = version: hash:
426          flakePackages.slippi-launcher.overrideAttrs {
427            inherit version hash;
428          };
429      in {
430        # defaults here are true since we assume if you're importing the module, you
431        # want it on ;)
432        options.slippi-launcher = {
433          enable = mkEnableOption "Install Slippi Launcher" // {default = true;};
434
435          netplayVersion = mkOption {
436            default = defaults.netplay.version;
437            type = types.str;
438            description = "The version of Slippi Netplay to install.";
439          };
440          netplayHash = mkOption {
441            default = defaults.netplay.hash;
442            type = types.str;
443            description = "The hash of the Slippi Netplay AppImage to install.";
444          };
445
446          netplayBetaVersion = mkOption {
447            default = defaults.netplay-beta.version;
448            type = types.str;
449            description = "The version of Slippi Netplay (Mainline beta) to install.";
450          };
451          netplayBetaHash = mkOption {
452            default = defaults.netplay-beta.hash;
453            type = types.str;
454            description = "The hash of the Slippi Netplay (Mainline beta) AppImage to install.";
455          };
456
457          playbackVersion = mkOption {
458            default = defaults.playback.version;
459            type = types.str;
460            description = "The version of Slippi Playback to install.";
461          };
462          playbackHash = mkOption {
463            default = defaults.playback.hash;
464            type = types.str;
465            description = "The hash of the Slippi Playback AppImage to install.";
466          };
467
468          launcherVersion = mkOption {
469            default = defaults.launcher.version;
470            type = types.str;
471            description = "The version of Slippi Launcher to install.";
472          };
473          launcherHash = mkOption {
474            default = defaults.launcher.hash;
475            type = types.str;
476            description = "The hash of the Slippi Launcher AppImage to install.";
477          };
478
479          isoPath = mkOption {
480            default = "";
481            type = types.str;
482            description = "The path to an NTSC Melee ISO.";
483          };
484          useNetplayBeta = mkEnableOption "Use the mainline Dolphin instead of the stable version." // {default = false;};
485
486          launchMeleeOnPlay = mkEnableOption "Launch Melee in Dolphin when the Play button is pressed." // {default = true;};
487
488          enableJukebox = mkEnableOption "Enable in-game music via Slippi Jukebox. Incompatible with WASAPI." // {default = true;};
489
490          rootSlpPath = mkOption {
491            default = "${config.home.homeDirectory}/Slippi";
492            type = types.str;
493            description = "The folder where your SLP replays should be saved.";
494          };
495
496          useMonthlySubfolders = mkEnableOption "Save replays to monthly subfolders";
497
498          spectateSlpPath = mkOption {
499            default = "${cfg.rootSlpPath}/Spectate";
500            type = types.nullOr types.str;
501            description = "The folder where spectated games should be saved.";
502          };
503
504          extraSlpPaths = mkOption {
505            default = [];
506            type = types.listOf types.str;
507            description = "Choose any additional SLP directories that should show up in the replay browser.";
508          };
509        };
510        config = let
511          cfgNetplayPackage = netplay-package cfg.netplayVersion cfg.netplayHash;
512          cfgNetplayBetaPackage = netplay-beta-package cfg.netplayBetaVersion cfg.netplayBetaHash;
513          cfgPlaybackPackage = playback-package cfg.playbackVersion cfg.playbackHash;
514          cfgLauncherPackage = launcher-package cfg.launcherVersion cfg.launcherHash;
515        in {
516          home.packages = [(mkIf cfg.enable cfgLauncherPackage)];
517          home.file.".config/Slippi Launcher/netplay/Slippi_Online-x86_64.AppImage" = {
518            enable = cfg.enable;
519            source = "${cfgNetplayPackage}/bin/Slippi_Online-x86_64.AppImage";
520            recursive = false;
521          };
522          home.file.".config/Slippi Launcher/netplay/Sys" = {
523            enable = cfg.enable;
524            source = "${pkgs.fetchzip {
525              url = "https://github.com/project-slippi/Ishiiruka/releases/download/v${cfg.netplayVersion}/FM-Slippi-${cfg.netplayVersion}-Linux.zip";
526              hash = cfg.netplayHash;
527              stripRoot = false;
528            }}/Sys";
529            recursive = false;
530          };
531          home.file.".config/Slippi Launcher/netplay-beta/Slippi_Netplay_Mainline-x86_64.AppImage" = {
532            enable = cfg.useNetplayBeta;
533            source = "${cfgNetplayBetaPackage}/bin/Slippi_Netplay_Mainline-x86_64.AppImage";
534            recursive = false;
535          };
536          home.file.".config/Slippi Launcher/netplay-beta/Sys" = {
537            enable = cfg.useNetplayBeta;
538            source = "${pkgs.fetchzip {
539              url = "https://github.com/project-slippi/dolphin/releases/download/v${cfg.netplayBetaVersion}/Mainline-Slippi-${cfg.netplayBetaVersion}-Linux.zip";
540              hash = cfg.netplayBetaHash;
541              stripRoot = false;
542            }}/Sys";
543            recursive = false;
544          };
545          home.file.".config/Slippi Launcher/playback/Slippi_Playback-x86_64.AppImage" = {
546            enable = cfg.enable;
547            source = "${cfgPlaybackPackage}/bin/Slippi_Playback-x86_64.AppImage";
548            recursive = false;
549          };
550          home.file.".config/Slippi Launcher/playback/Sys" = {
551            enable = cfg.enable;
552            source = "${
553              pkgs.fetchzip {
554                url = "https://github.com/project-slippi/Ishiiruka-Playback/releases/download/v${cfg.playbackVersion}/playback-${cfg.playbackVersion}-Linux.zip";
555                hash = cfg.netplayHash;
556                stripRoot = false;
557              }
558            }/Sys";
559            recursive = false;
560          };
561          xdg.configFile."Slippi Launcher/Settings" = {
562            enable = cfg.enable;
563            source = let
564              jsonFormat = pkgs.formats.json {};
565            in
566              jsonFormat.generate "slippi-config" {
567                settings = {
568                  isoPath = cfg.isoPath;
569
570                  launchMeleeOnPlay = cfg.launchMeleeOnPlay;
571                  enableJukebox = cfg.enableJukebox;
572                  useNetplayBeta = cfg.useNetplayBeta;
573
574                  rootSlpPath = cfg.rootSlpPath;
575                  useMonthlySubfolders = cfg.useMonthlySubfolders;
576                  spectateSlpPath = cfg.spectateSlpPath;
577                  extraSlpPaths = cfg.extraSlpPaths;
578
579                  netplayDolphinPath = "${
580                    if cfg.useNetplayBeta
581                    then cfgNetplayBetaPackage
582                    else cfgNetplayPackage
583                  }/bin/";
584                  playbackDolphinPath = "${cfgPlaybackPackage}/bin/";
585
586                  autoUpdateLauncher = false;
587                };
588              };
589          };
590        };
591      };
592    };
593  };
594}