tools/quake3/q3map2/path_init.c

   1 /* -------------------------------------------------------------------------------
   2
   3 Copyright (C) 1999-2007 id Software, Inc. and contributors.
   4 For a list of contributors, see the accompanying CONTRIBUTORS file.
   5
   6 This file is part of GtkRadiant.
   7
   8 GtkRadiant is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 GtkRadiant is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GtkRadiant; if not, write to the Free Software
  20 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  21
  22 ----------------------------------------------------------------------------------
  23
  24 This code has been altered significantly from its original form, to support
  25 several games based on the Quake III Arena engine, in the form of "Q3Map2."
  26
  27 ------------------------------------------------------------------------------- */
  28
  29
  30
  31 /* marker */
  32 #define PATH_INIT_C
  33
  34
  35
  36 /* dependencies */
  37 #include "q3map2.h"
  38
  39
  40
  41 /* path support */
  42 #define MAX_BASE_PATHS  10
  43 #define MAX_GAME_PATHS  10
  44
  45 char                                    *homePath;
  46 char                                    installPath[ MAX_OS_PATH ];
  47
  48 int                                             numBasePaths;
  49 char                                    *basePaths[ MAX_BASE_PATHS ];
  50 int                                             numGamePaths;
  51 char                                    *gamePaths[ MAX_GAME_PATHS ];
  52
  53
  54
  55 /*
  56 some of this code is based off the original q3map port from loki
  57 and finds various paths. moved here from bsp.c for clarity.
  58 */
  59
  60 /*
  61 PathLokiGetHomeDir()
  62 gets the user's home dir (for ~/.q3a)
  63 */
  64
  65 char *LokiGetHomeDir( void )
  66 {
  67         #ifndef Q_UNIX
  68                 return NULL;
  69         #else
  70                 char                    *home;
  71                 uid_t                   id;
  72                 struct passwd   *pwd;
  73
  74
  75                 /* get the home environment variable */
  76                 home = getenv( "HOME" );
  77                 if( home == NULL )
  78                 {
  79                         /* do some more digging */
  80                         id = getuid();
  81                         setpwent();
  82                         while( (pwd = getpwent()) != NULL )
  83                         {
  84                                 if( pwd->pw_uid == id )
  85                                 {
  86                                         home = pwd->pw_dir;
  87                                         break;
  88                                 }
  89                         }
  90                         endpwent();
  91                 }
  92
  93                 /* return it */
  94                 return home;
  95         #endif
  96 }
  97
  98
  99
 100 /*
 101 PathLokiInitPaths()
 102 initializes some paths on linux/os x
 103 */
 104
 105 void LokiInitPaths( char *argv0 )
 106 {
 107         #ifndef Q_UNIX
 108                 /* this is kinda crap, but hey */
 109                 strcpy( installPath, "../" );
 110         #else
 111                 char            temp[ MAX_OS_PATH ];
 112                 char            *home;
 113                 char            *path;
 114                 char            *last;
 115                 qboolean        found;
 116
 117
 118                 /* get home dir */
 119                 home = LokiGetHomeDir();
 120                 if( home == NULL )
 121                         home = ".";
 122
 123                 /* do some path divining */
 124                 strcpy( temp, argv0 );
 125                 if( strrchr( temp, '/' ) )
 126                         argv0 = strrchr( argv0, '/' ) + 1;
 127                 else
 128                 {
 129                         /* get path environment variable */
 130                         path = getenv( "PATH" );
 131
 132                         /* minor setup */
 133                         last[ 0 ] = path[ 0 ];
 134                         last[ 1 ] = '\0';
 135                         found = qfalse;
 136
 137                         /* go through each : segment of path */
 138                         while( last[ 0 ] != '\0' && found == qfalse )
 139                         {
 140                                 /* null out temp */
 141                                 temp[ 0 ] = '\0';
 142
 143                                 /* find next chunk */
 144                                 last = strchr( path, ':' );
 145                                 if( last == NULL )
 146                                         last = path + strlen( path );
 147
 148                                 /* found home dir candidate */
 149                                 if( *path == '~' )
 150                                 {
 151                                         strcpy( temp, home );
 152                                         path++;
 153                                 }
 154
 155                                 /* concatenate */
 156                                 if( last > (path + 1) )
 157                                 {
 158                                         strncat( temp, path, (last - path) );
 159                                         strcat( temp, "/" );
 160                                 }
 161                                 strcat( temp, "./" );
 162                                 strcat( temp, argv0 );
 163
 164                                 /* verify the path */
 165                                 if( access( temp, X_OK ) == 0 )
 166                                         found++;
 167                                 path = last + 1;
 168                         }
 169                 }
 170
 171                 /* flake */
 172                 if( realpath( temp, installPath ) )
 173                 {
 174                         /* q3map is in "tools/" */
 175                         *(strrchr( installPath, '/' )) = '\0';
 176                         *(strrchr( installPath, '/' ) + 1) = '\0';
 177                 }
 178
 179                 /* set home path */
 180                 homePath = home;
 181         #endif
 182 }
 183
 184
 185
 186 /*
 187 CleanPath() - ydnar
 188 cleans a dos path \ -> /
 189 */
 190
 191 void CleanPath( char *path )
 192 {
 193         while( *path )
 194         {
 195                 if( *path == '\\' )
 196                         *path = '/';
 197                 path++;
 198         }
 199 }
 200
 201
 202
 203 /*
 204 GetGame() - ydnar
 205 gets the game_t based on a -game argument
 206 returns NULL if no match found
 207 */
 208
 209 game_t *GetGame( char *arg )
 210 {
 211         int     i;
 212
 213
 214         /* dummy check */
 215         if( arg == NULL || arg[ 0 ] == '\0' )
 216                 return NULL;
 217
 218         /* joke */
 219         if( !Q_stricmp( arg, "quake1" ) ||
 220                 !Q_stricmp( arg, "quake2" ) ||
 221                 !Q_stricmp( arg, "unreal" ) ||
 222                 !Q_stricmp( arg, "ut2k3" ) ||
 223                 !Q_stricmp( arg, "dn3d" ) ||
 224                 !Q_stricmp( arg, "dnf" ) ||
 225                 !Q_stricmp( arg, "hl" ) )
 226         {
 227                 Sys_Printf( "April fools, silly rabbit!\n" );
 228                 exit( 0 );
 229         }
 230
 231         /* test it */
 232         i = 0;
 233         while( games[ i ].arg != NULL )
 234         {
 235                 if( Q_stricmp( arg, games[ i ].arg ) == 0 )
 236                         return &games[ i ];
 237                 i++;
 238         }
 239
 240         /* no matching game */
 241         return NULL;
 242 }
 243
 244
 245
 246 /*
 247 AddBasePath() - ydnar
 248 adds a base path to the list
 249 */
 250
 251 void AddBasePath( char *path )
 252 {
 253         /* dummy check */
 254         if( path == NULL || path[ 0 ] == '\0' || numBasePaths >= MAX_BASE_PATHS )
 255                 return;
 256
 257         /* add it to the list */
 258         basePaths[ numBasePaths ] = safe_malloc( strlen( path ) + 1 );
 259         strcpy( basePaths[ numBasePaths ], path );
 260         CleanPath( basePaths[ numBasePaths ] );
 261         numBasePaths++;
 262 }
 263
 264
 265
 266 /*
 267 AddHomeBasePath() - ydnar
 268 adds a base path to the beginning of the list, prefixed by ~/
 269 */
 270
 271 void AddHomeBasePath( char *path )
 272 {
 273         #ifdef Q_UNIX
 274                 int             i;
 275                 char    temp[ MAX_OS_PATH ];
 276
 277
 278                 /* dummy check */
 279                 if( path == NULL || path[ 0 ] == '\0' )
 280                         return;
 281
 282                 /* make a hole */
 283                 for( i = 0; i < (MAX_BASE_PATHS - 1); i++ )
 284                         basePaths[ i + 1 ] = basePaths[ i ];
 285
 286                 /* concatenate home dir and path */
 287                 sprintf( temp, "%s/%s", homePath, path );
 288
 289                 /* add it to the list */
 290                 basePaths[ 0 ] = safe_malloc( strlen( temp ) + 1 );
 291                 strcpy( basePaths[ 0 ], temp );
 292                 CleanPath( basePaths[ 0 ] );
 293                 numBasePaths++;
 294         #endif
 295 }
 296
 297
 298
 299 /*
 300 AddGamePath() - ydnar
 301 adds a game path to the list
 302 */
 303
 304 void AddGamePath( char *path )
 305 {
 306         int     i;
 307
 308         /* dummy check */
 309         if( path == NULL || path[ 0 ] == '\0' || numGamePaths >= MAX_GAME_PATHS )
 310                 return;
 311
 312         /* add it to the list */
 313         gamePaths[ numGamePaths ] = safe_malloc( strlen( path ) + 1 );
 314         strcpy( gamePaths[ numGamePaths ], path );
 315         CleanPath( gamePaths[ numGamePaths ] );
 316         numGamePaths++;
 317
 318         /* don't add it if it's already there */
 319         for (i = 0; i < numGamePaths - 1; i++)
 320         {
 321                 if (strcmp(gamePaths[i], gamePaths[numGamePaths - 1]) == 0)
 322                 {
 323                         free(gamePaths[numGamePaths - 1]);
 324                         gamePaths[numGamePaths - 1] = NULL;
 325                         numGamePaths--;
 326                         break;
 327                 }
 328         }
 329
 330 }
 331
 332
 333
 334
 335 /*
 336 InitPaths() - ydnar
 337 cleaned up some of the path initialization code from bsp.c
 338 will remove any arguments it uses
 339 */
 340
 341 void InitPaths( int *argc, char **argv )
 342 {
 343         int             i, j, k, len, len2;
 344         char    temp[ MAX_OS_PATH ];
 345
 346
 347         /* note it */
 348         Sys_FPrintf( SYS_VRB, "--- InitPaths ---\n" );
 349
 350         /* get the install path for backup */
 351         LokiInitPaths( argv[ 0 ] );
 352
 353         /* set game to default (q3a) */
 354         game = &games[ 0 ];
 355         numBasePaths = 0;
 356         numGamePaths = 0;
 357
 358         /* parse through the arguments and extract those relevant to paths */
 359         for( i = 0; i < *argc; i++ )
 360         {
 361                 /* check for null */
 362                 if( argv[ i ] == NULL )
 363                         continue;
 364
 365                 /* -game */
 366                 if( strcmp( argv[ i ], "-game" ) == 0 )
 367                 {
 368                         if( ++i >= *argc )
 369                                 Error( "Out of arguments: No game specified after %s", argv[ i - 1 ] );
 370                         argv[ i - 1 ] = NULL;
 371                         game = GetGame( argv[ i ] );
 372                         if( game == NULL )
 373                                 game = &games[ 0 ];
 374                         argv[ i ] = NULL;
 375                 }
 376
 377                 /* -fs_basepath */
 378                 else if( strcmp( argv[ i ], "-fs_basepath" ) == 0 )
 379                 {
 380                         if( ++i >= *argc )
 381                                 Error( "Out of arguments: No path specified after %s.", argv[ i - 1 ] );
 382                         argv[ i - 1 ] = NULL;
 383                         AddBasePath( argv[ i ] );
 384                         argv[ i ] = NULL;
 385                 }
 386
 387                 /* -fs_game */
 388                 else if( strcmp( argv[ i ], "-fs_game" ) == 0 )
 389                 {
 390                         if( ++i >= *argc )
 391                                 Error( "Out of arguments: No path specified after %s.", argv[ i - 1 ] );
 392                         argv[ i - 1 ] = NULL;
 393                         AddGamePath( argv[ i ] );
 394                         argv[ i ] = NULL;
 395                 }
 396         }
 397
 398         /* remove processed arguments */
 399         for( i = 0, j = 0, k = 0; i < *argc && j < *argc; i++, j++ )
 400         {
 401                 for( ; j < *argc && argv[ j ] == NULL; j++ );
 402                 argv[ i ] = argv[ j ];
 403                 if( argv[ i ] != NULL )
 404                         k++;
 405         }
 406         *argc = k;
 407
 408         /* add standard game path */
 409         AddGamePath( game->gamePath );
 410
 411         /* if there is no base path set, figure it out */
 412         if( numBasePaths == 0 )
 413         {
 414                 /* this is another crappy replacement for SetQdirFromPath() */
 415                 len2 = strlen( game->magic );
 416                 for( i = 0; i < *argc && numBasePaths == 0; i++ )
 417                 {
 418                         /* extract the arg */
 419                         strcpy( temp, argv[ i ] );
 420                         CleanPath( temp );
 421                         len = strlen( temp );
 422                         Sys_FPrintf( SYS_VRB, "Searching for \"%s\" in \"%s\" (%d)...\n", game->magic, temp, i );
 423
 424                         /* this is slow, but only done once */
 425                         for( j = 0; j < (len - len2); j++ )
 426                         {
 427                                 /* check for the game's magic word */
 428                                 if( Q_strncasecmp( &temp[ j ], game->magic, len2 ) == 0 )
 429                                 {
 430                                         /* now find the next slash and nuke everything after it */
 431                                         while( temp[ ++j ] != '/' && temp[ j ] != '\0' );
 432                                         temp[ j ] = '\0';
 433
 434                                         /* add this as a base path */
 435                                         AddBasePath( temp );
 436                                         break;
 437                                 }
 438                         }
 439                 }
 440
 441                 /* add install path */
 442                 if( numBasePaths == 0 )
 443                         AddBasePath( installPath );
 444
 445                 /* check again */
 446                 if( numBasePaths == 0 )
 447                         Error( "Failed to find a valid base path." );
 448         }
 449
 450         /* this only affects unix */
 451         AddHomeBasePath( game->homeBasePath );
 452
 453         /* initialize vfs paths */
 454         if( numBasePaths > MAX_BASE_PATHS )
 455                 numBasePaths = MAX_BASE_PATHS;
 456         if( numGamePaths > MAX_GAME_PATHS )
 457                 numGamePaths = MAX_GAME_PATHS;
 458
 459         /* walk the list of game paths */
 460         for( j = 0; j < numGamePaths; j++ )
 461         {
 462                 /* walk the list of base paths */
 463                 for( i = 0; i < numBasePaths; i++ )
 464                 {
 465                         /* create a full path and initialize it */
 466                         sprintf( temp, "%s/%s/", basePaths[ i ], gamePaths[ j ] );
 467                         vfsInitDirectory( temp );
 468                 }
 469         }
 470
 471         /* done */
 472         Sys_Printf( "\n" );
 473 }
 474
 475
 476
 477