commit e0c78f4208d5fbdcc9f45beb41f6b938f7c5a2c8 · pyrox.dev/nixpkgs

pkgs/games/xpilot/bloodspilot-client.nix

···

       21
       21
        
           sha256 = "1qwl95av5an2zl01m7saj6fyy49xpixga7gbn4lwbpgpqs1rbwxj";

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
       +
         patches = [ ./bloodspilot-sdl-window-fix.patch ];

     

       25
       25
       +
       

     

       24
       26
        
         buildInputs = [

     

       25
       27
        
           libX11

     

       26
       28
        
           SDL

+95

pkgs/games/xpilot/bloodspilot-sdl-window-fix.patch

···

       1
       1
       +
       --- a/src/client/sdl/scrap.c	2012-09-02 11:25:23.000000000 +0200

     

       2
       2
       +
       +++ b/src/client/sdl/scrap.c	2025-03-23 12:01:51.968751308 +0100

     

       3
       3
       +
       @@ -71,13 +71,13 @@

     

       4
       4
       +
        #if defined(X11_SCRAP)

     

       5
       5
       +
        /* * */

     

       6
       6
       +
        static Display *SDL_Display;

     

       7
       7
       +
       -static Window SDL_Window;

     

       8
       8
       +
       +static Window BloodsPilot_SDL_Window;

     

       9
       9
       +
        static void (*Lock_Display) (void);

     

       10
       10
       +
        static void (*Unlock_Display) (void);

     

       11
       11
       +
        

     

       12
       12
       +
        #elif defined(WIN_SCRAP)

     

       13
       13
       +
        /* * */

     

       14
       14
       +
       -static HWND SDL_Window;

     

       15
       15
       +
       +static HWND BloodsPilot_SDL_Window;

     

       16
       16
       +
        

     

       17
       17
       +
        #elif defined(QNX_SCRAP)

     

       18
       18
       +
        /* * */

     

       19
       19
       +
       @@ -274,7 +274,7 @@

     

       20
       20
       +
        /* * */

     

       21
       21
       +
        		if (info.subsystem == SDL_SYSWM_X11) {

     

       22
       22
       +
        			SDL_Display = info.info.x11.display;

     

       23
       23
       +
       -			SDL_Window = info.info.x11.window;

     

       24
       24
       +
       +			BloodsPilot_SDL_Window = info.info.x11.window;

     

       25
       25
       +
        			Lock_Display = info.info.x11.lock_func;

     

       26
       26
       +
        			Unlock_Display = info.info.x11.unlock_func;

     

       27
       27
       +
        

     

       28
       28
       +
       @@ -290,7 +290,7 @@

     

       29
       29
       +
        

     

       30
       30
       +
        #elif defined(WIN_SCRAP)

     

       31
       31
       +
        /* * */

     

       32
       32
       +
       -		SDL_Window = info.window;

     

       33
       33
       +
       +		BloodsPilot_SDL_Window = info.window;

     

       34
       34
       +
        		retval = 0;

     

       35
       35
       +
        

     

       36
       36
       +
        #elif defined(QNX_SCRAP)

     

       37
       37
       +
       @@ -310,12 +310,12 @@

     

       38
       38
       +
        #if defined(X11_SCRAP)

     

       39
       39
       +
        /* * */

     

       40
       40
       +
        	Lock_Display();

     

       41
       41
       +
       -	retval = (XGetSelectionOwner(SDL_Display, XA_PRIMARY) != SDL_Window);

     

       42
       42
       +
       +	retval = (XGetSelectionOwner(SDL_Display, XA_PRIMARY) != BloodsPilot_SDL_Window);

     

       43
       43
       +
        	Unlock_Display();

     

       44
       44
       +
        

     

       45
       45
       +
        #elif defined(WIN_SCRAP)

     

       46
       46
       +
        /* * */

     

       47
       47
       +
       -	retval = (GetClipboardOwner() != SDL_Window);

     

       48
       48
       +
       +	retval = (GetClipboardOwner() != BloodsPilot_SDL_Window);

     

       49
       49
       +
        

     

       50
       50
       +
        #elif defined(QNX_SCRAP)

     

       51
       51
       +
        /* * */

     

       52
       52
       +
       @@ -346,14 +346,14 @@

     

       53
       53
       +
        				(unsigned char *) dst, dstlen);

     

       54
       54
       +
        		free(dst);

     

       55
       55
       +
        		if (lost_scrap())

     

       56
       56
       +
       -			XSetSelectionOwner(SDL_Display, XA_PRIMARY, SDL_Window,

     

       57
       57
       +
       +			XSetSelectionOwner(SDL_Display, XA_PRIMARY, BloodsPilot_SDL_Window,

     

       58
       58
       +
        					   CurrentTime);

     

       59
       59
       +
        		Unlock_Display();

     

       60
       60
       +
        	}

     

       61
       61
       +
        

     

       62
       62
       +
        #elif defined(WIN_SCRAP)

     

       63
       63
       +
        /* * */

     

       64
       64
       +
       -	if (OpenClipboard(SDL_Window)) {

     

       65
       65
       +
       +	if (OpenClipboard(BloodsPilot_SDL_Window)) {

     

       66
       66
       +
        		HANDLE hMem;

     

       67
       67
       +
        

     

       68
       68
       +
        		hMem = GlobalAlloc((GMEM_MOVEABLE | GMEM_DDESHARE), dstlen);

     

       69
       69
       +
       @@ -441,7 +441,7 @@

     

       70
       70
       +
        		Lock_Display();

     

       71
       71
       +
        		owner = XGetSelectionOwner(SDL_Display, XA_PRIMARY);

     

       72
       72
       +
        		Unlock_Display();

     

       73
       73
       +
       -		if ((owner == None) || (owner == SDL_Window)) {

     

       74
       74
       +
       +		if ((owner == None) || (owner == BloodsPilot_SDL_Window)) {

     

       75
       75
       +
        			owner = DefaultRootWindow(SDL_Display);

     

       76
       76
       +
        			selection1 = XA_CUT_BUFFER0;

     

       77
       77
       +
        		}

     

       78
       78
       +
       @@ -449,7 +449,7 @@

     

       79
       79
       +
        			int selection_response = 0;

     

       80
       80
       +
        			SDL_Event event;

     

       81
       81
       +
        

     

       82
       82
       +
       -			owner = SDL_Window;

     

       83
       83
       +
       +			owner = BloodsPilot_SDL_Window;

     

       84
       84
       +
        			Lock_Display();

     

       85
       85
       +
        			selection1 = XInternAtom(SDL_Display, "SDL_SELECTION", False);

     

       86
       86
       +
        			XConvertSelection(SDL_Display, XA_PRIMARY, format,

     

       87
       87
       +
       @@ -485,7 +485,7 @@

     

       88
       88
       +
        

     

       89
       89
       +
        #elif defined(WIN_SCRAP)

     

       90
       90
       +
        /* * */

     

       91
       91
       +
       -	if (IsClipboardFormatAvailable(format) && OpenClipboard(SDL_Window)) {

     

       92
       92
       +
       +	if (IsClipboardFormatAvailable(format) && OpenClipboard(BloodsPilot_SDL_Window)) {

     

       93
       93
       +
        		HANDLE hMem;

     

       94
       94
       +
        		char *src;

     

       95
       95
       +

+40

pkgs/games/xpilot/bloodspilot-server-strcpy-fix.patch

···

       1
       1
       +
       Fortify catches a possible strcpy overcopy, throw more space at it

     

       2
       2
       +
       

     

       3
       3
       +
       --- a/src/server/contact.c	2010-05-24 14:51:41.000000000 +0200

     

       4
       4
       +
       +++ b/src/server/contact.c	2025-03-23 12:15:36.426805646 +0100

     

       5
       5
       +
       @@ -58,11 +58,11 @@

     

       6
       6
       +
        

     

       7
       7
       +
        struct queued_player {

     

       8
       8
       +
        	struct queued_player *next;

     

       9
       9
       +
       -	char real_name[MAX_CHARS];

     

       10
       10
       +
       -	char nick_name[MAX_CHARS];

     

       11
       11
       +
       -	char disp_name[MAX_CHARS];

     

       12
       12
       +
       -	char host_name[MAX_CHARS];

     

       13
       13
       +
       -	char host_addr[24];

     

       14
       14
       +
       +	char real_name[MAX_CHARS + 32];

     

       15
       15
       +
       +	char nick_name[MAX_CHARS + 32];

     

       16
       16
       +
       +	char disp_name[MAX_CHARS + 32];

     

       17
       17
       +
       +	char host_name[MAX_CHARS + 32];

     

       18
       18
       +
       +	char host_addr[1056];

     

       19
       19
       +
        	int32_t port;

     

       20
       20
       +
        	team_t *team;

     

       21
       21
       +
        	uint32_t version;

     

       22
       22
       +
       @@ -271,12 +271,12 @@

     

       23
       23
       +
        	uint32_t my_magic;

     

       24
       24
       +
        	uint16_t port;

     

       25
       25
       +
        	char ch;

     

       26
       26
       +
       -	char real_name[MAX_CHARS];

     

       27
       27
       +
       -	char disp_name[MAX_CHARS];

     

       28
       28
       +
       -	char nick_name[MAX_CHARS];

     

       29
       29
       +
       -	char host_name[MAX_CHARS];

     

       30
       30
       +
       -	char host_addr[24];

     

       31
       31
       +
       -	char str[MSG_LEN];

     

       32
       32
       +
       +	char real_name[MAX_CHARS + 32 ];

     

       33
       33
       +
       +	char disp_name[MAX_CHARS + 32 ];

     

       34
       34
       +
       +	char nick_name[MAX_CHARS + 32 ];

     

       35
       35
       +
       +	char host_name[MAX_CHARS + 32 ];

     

       36
       36
       +
       +	char host_addr[1056];

     

       37
       37
       +
       +	char str[MSG_LEN + 32];

     

       38
       38
       +
        

     

       39
       39
       +
        	/*

     

       40
       40
       +
        	 * Someone connected to us, now try and decipher the message :)

pkgs/games/xpilot/bloodspilot-server.nix

···

       20
       20
        
       

     

       21
       21
        
         patches = [

     

       22
       22
        
           ./server-gcc5.patch

     

       23
       23
       +
           ./bloodspilot-server-strcpy-fix.patch

     

       23
       24
        
         ];

     

       24
       25
        
       

     

       25
       26
        
         meta = with lib; {

+6 -1

pkgs/games/xpilot/default.nix

···

       4
       4
        
         fetchurl,

     

       5
       5
        
         libX11,

     

       6
       6
        
         libSM,

     

       7
       7
       +
         libXext,

     

       7
       8
        
         SDL,

     

       8
       9
        
         libGLU,

     

       9
       10
        
         libGL,

     
···

       23
       24
        
         buildInputs = [

     

       24
       25
        
           libX11

     

       25
       26
        
           libSM

     

       27
       27
       +
           libXext

     

       26
       28
        
           SDL

     

       27
       29
        
           SDL_ttf

     

       28
       30
        
           SDL_image

     
···

       33
       35
        
           libXxf86misc

     

       34
       36
        
         ];

     

       35
       37
        
       

     

       36
       36
       -
         patches = [ ./xpilot-ng-gcc-14-fix.patch ];

     

       38
       38
       +
         patches = [

     

       39
       39
       +
           ./xpilot-ng-gcc-14-fix.patch

     

       40
       40
       +
           ./xpilot-ng-sdl-window-fix.patch

     

       41
       41
       +
         ];

     

       37
       42
        
       

     

       38
       43
        
         meta = with lib; {

     

       39
       44
        
           description = "Multiplayer X11 space combat game";

+96

pkgs/games/xpilot/xpilot-ng-sdl-window-fix.patch

···

       1
       1
       +
       XPilot-NG uses SDL_Window (now an SDL type name) as a variable name

     

       2
       2
       +
       

     

       3
       3
       +
       --- a/src/client/sdl/scrap.c	2025-03-23 11:48:45.045699445 +0100

     

       4
       4
       +
       +++ b.src/client/sdl/scrap.c	2025-03-23 11:48:48.773699690 +0100

     

       5
       5
       +
       @@ -57,13 +57,13 @@

     

       6
       6
       +
        #if defined(X11_SCRAP)

     

       7
       7
       +
        /* * */

     

       8
       8
       +
        static Display *SDL_Display;

     

       9
       9
       +
       -static Window SDL_Window;

     

       10
       10
       +
       +static Window XPilot_SDL_Window;

     

       11
       11
       +
        static void (*Lock_Display)(void);

     

       12
       12
       +
        static void (*Unlock_Display)(void);

     

       13
       13
       +
        

     

       14
       14
       +
        #elif defined(WIN_SCRAP)

     

       15
       15
       +
        /* * */

     

       16
       16
       +
       -static HWND SDL_Window;

     

       17
       17
       +
       +static HWND XPilot_SDL_Window;

     

       18
       18
       +
        

     

       19
       19
       +
        #elif defined(QNX_SCRAP)

     

       20
       20
       +
        /* * */

     

       21
       21
       +
       @@ -285,7 +285,7 @@

     

       22
       22
       +
              if ( info.subsystem == SDL_SYSWM_X11 )

     

       23
       23
       +
                {

     

       24
       24
       +
                  SDL_Display = info.info.x11.display;

     

       25
       25
       +
       -          SDL_Window = info.info.x11.window;

     

       26
       26
       +
       +          XPilot_SDL_Window = info.info.x11.window;

     

       27
       27
       +
                  Lock_Display = info.info.x11.lock_func;

     

       28
       28
       +
                  Unlock_Display = info.info.x11.unlock_func;

     

       29
       29
       +
        

     

       30
       30
       +
       @@ -302,7 +302,7 @@

     

       31
       31
       +
        

     

       32
       32
       +
        #elif defined(WIN_SCRAP)

     

       33
       33
       +
        /* * */

     

       34
       34
       +
       -      SDL_Window = info.window;

     

       35
       35
       +
       +      XPilot_SDL_Window = info.window;

     

       36
       36
       +
              retval = 0;

     

       37
       37
       +
        

     

       38
       38
       +
        #elif defined(QNX_SCRAP)

     

       39
       39
       +
       @@ -323,12 +323,12 @@

     

       40
       40
       +
        #if defined(X11_SCRAP)

     

       41
       41
       +
        /* * */

     

       42
       42
       +
          Lock_Display();

     

       43
       43
       +
       -  retval = ( XGetSelectionOwner(SDL_Display, XA_PRIMARY) != SDL_Window );

     

       44
       44
       +
       +  retval = ( XGetSelectionOwner(SDL_Display, XA_PRIMARY) != XPilot_SDL_Window );

     

       45
       45
       +
          Unlock_Display();

     

       46
       46
       +
        

     

       47
       47
       +
        #elif defined(WIN_SCRAP)

     

       48
       48
       +
        /* * */

     

       49
       49
       +
       -  retval = ( GetClipboardOwner() != SDL_Window );

     

       50
       50
       +
       +  retval = ( GetClipboardOwner() != XPilot_SDL_Window );

     

       51
       51
       +
        

     

       52
       52
       +
        #elif defined(QNX_SCRAP)

     

       53
       53
       +
        /* * */

     

       54
       54
       +
       @@ -360,13 +360,13 @@

     

       55
       55
       +
                XA_CUT_BUFFER0, format, 8, PropModeReplace, (unsigned char *)dst, dstlen);

     

       56
       56
       +
              free(dst);

     

       57
       57
       +
              if ( lost_scrap() )

     

       58
       58
       +
       -        XSetSelectionOwner(SDL_Display, XA_PRIMARY, SDL_Window, CurrentTime);

     

       59
       59
       +
       +        XSetSelectionOwner(SDL_Display, XA_PRIMARY, XPilot_SDL_Window, CurrentTime);

     

       60
       60
       +
              Unlock_Display();

     

       61
       61
       +
            }

     

       62
       62
       +
        

     

       63
       63
       +
        #elif defined(WIN_SCRAP)

     

       64
       64
       +
        /* * */

     

       65
       65
       +
       -  if ( OpenClipboard(SDL_Window) )

     

       66
       66
       +
       +  if ( OpenClipboard(XPilot_SDL_Window) )

     

       67
       67
       +
            {

     

       68
       68
       +
              HANDLE hMem;

     

       69
       69
       +
        

     

       70
       70
       +
       @@ -461,7 +461,7 @@

     

       71
       71
       +
            Lock_Display();

     

       72
       72
       +
            owner = XGetSelectionOwner(SDL_Display, XA_PRIMARY);

     

       73
       73
       +
            Unlock_Display();

     

       74
       74
       +
       -    if ( (owner == None) || (owner == SDL_Window) )

     

       75
       75
       +
       +    if ( (owner == None) || (owner == XPilot_SDL_Window) )

     

       76
       76
       +
              {

     

       77
       77
       +
                owner = DefaultRootWindow(SDL_Display);

     

       78
       78
       +
                selection1 = XA_CUT_BUFFER0;

     

       79
       79
       +
       @@ -471,7 +471,7 @@

     

       80
       80
       +
                int selection_response = 0;

     

       81
       81
       +
                SDL_Event event;

     

       82
       82
       +
        

     

       83
       83
       +
       -        owner = SDL_Window;

     

       84
       84
       +
       +        owner = XPilot_SDL_Window;

     

       85
       85
       +
                Lock_Display();

     

       86
       86
       +
                selection1 = XInternAtom(SDL_Display, "SDL_SELECTION", False);

     

       87
       87
       +
                XConvertSelection(SDL_Display, XA_PRIMARY, format,

     

       88
       88
       +
       @@ -511,7 +511,7 @@

     

       89
       89
       +
        

     

       90
       90
       +
        #elif defined(WIN_SCRAP)

     

       91
       91
       +
        /* * */

     

       92
       92
       +
       -  if ( IsClipboardFormatAvailable(format) && OpenClipboard(SDL_Window) )

     

       93
       93
       +
       +  if ( IsClipboardFormatAvailable(format) && OpenClipboard(XPilot_SDL_Window) )

     

       94
       94
       +
            {

     

       95
       95
       +
              HANDLE hMem;

     

       96
       96
       +
              char *src;