void I_GetMemory(quakeparms_t *parms) { FILE *f; char buffer[256]; char *procparse; int freemem, buffermem, totalmem; int rc, suggestion; parms->memsize = 8*1024*1024; f = fopen("/proc/meminfo", "r"); if (f) { fgets(buffer, sizeof buffer, f); procparse = "%s %d %d %d %d %d"; rc = fscanf(f, procparse, buffer, &totalmem, buffer, &freemem, buffer, &buffermem); suggestion = (9*buffermem)/10 + freemem; if (suggestion > totalmem) I_Printf("[%s] did not properly parse /proc/meminfo\n", procparse); if (suggestion > parms->memsize && suggestion < totalmem) parms->memsize = suggestion; fclose(f); } else I_Printf("Did you know /proc breaks up painful gas bubbles?\n"); parms->membase = malloc (parms->memsize); }
// DHM - Nerve void I_ShutdownNetwork( void ) { if ( globalNetworking && gameLocal != NULL ) { int curPlayer = DoomLib::GetPlayer(); for (int player = 0; player < gameLocal->Interface.GetNumPlayers(); ++player) { DoomLib::SetPlayer( player ); if ( IsValidSocket( ::g->insocket ) ) { I_Printf( "[-] Shut down insocket for player %d\n", DoomLib::GetPlayer() ); shutdown( ::g->insocket, SHUT_RDWR ); socketclose( ::g->insocket ); } if ( IsValidSocket( ::g->sendsocket ) ) { I_Printf( "[-] Shut down sendsocket for player %d\n", DoomLib::GetPlayer() ); shutdown( ::g->sendsocket, SHUT_RDWR ); socketclose( ::g->sendsocket ); } } DoomLib::SetPlayer(curPlayer); globalNetworking = false; } }
// // I_SetAffinityMask // // Due to ongoing problems with the SDL_mixer library and/or the SDL audio // core, it is necessary to support the restriction of Eternity to a single // core or CPU. Apparent thread contention issues cause the library to // malfunction if multiple threads of the process run simultaneously. // // I wish SDL would fix their bullshit already. // void I_SetAffinityMask(void) { #ifdef HAVE_SCHED_SETAFFINITY int p = M_CheckParm("-affinity"); if(p && p < myargc - 1) process_affinity_mask = datoi(myargv[p + 1]); else process_affinity_mask = 0; // Set the process affinity mask so that all threads // run on the same processor. This is a workaround for a bug in // SDL_mixer that causes occasional crashes. if(process_affinity_mask) { int i; cpu_set_t set; CPU_ZERO(&set); for(i = 0; i < 16; ++i) CPU_SET((process_affinity_mask>>i)&1, &set); if(sched_setaffinity(getpid(), sizeof(set), &set) == -1) I_Printf("I_SetAffinityMask: failed to set process affinity mask.\n"); else I_Printf("I_SetAffinityMask: applied affinity mask.\n"); } #endif }
// // R_InitData // Locates all the lumps // that will be used by all views // Must be called after W_Init. // void R_InitData (void) { R_InitTextures (); I_Printf ("\nInitTextures"); R_InitFlats (); I_Printf ("\nInitFlats"); R_InitSpriteLumps (); I_Printf ("\nInitSprites"); R_InitColormaps (); I_Printf ("\nInitColormaps"); }
void G_PrintActions(alist_t *al) { int i; while(al) { I_Printf("%s", al->cmd); for(i = 0; al->param[i]; i++) { I_Printf(" %s", al->param[i]); } al = al->next; if(al) I_Printf(" ; "); } }
void D_DoomMain(void) { I_Printf("I_Init\n"); I_Init(); I_Printf("Z_Init\n"); Z_Init(); I_Printf("W_Init\n"); W_Init(); I_Printf("R_Init\n"); R_Init(); I_Printf("P_Init\n"); P_Init(); I_Printf("ST_Init\n"); ST_Init(); I_Printf("S_Init\n"); S_Init(); gameaction = ga_nothing; gamestate = GS_NONE; gametic = 0; startskill = sk_medium; gameskill = sk_medium; startmap = 1; ticdup = 1; offsetms = 0; playeringame[0] = true; D_DebugParams(); D_SplashScreen(); D_DoomLoop(); }
void G_ShowAliases(action_t *action) { if(!action) return; if(action->children[0]) G_ShowAliases(action->children[0]); if((action->proc == G_RunAlias) && action->data) { I_Printf(" %s = ", action->name); G_PrintActions((alist_t *)action->data); I_Printf("\n"); } if(action->children[1]) G_ShowAliases(action->children[1]); }
static CMD(Unbind) { if(!param[0]) { I_Printf(" unbind <key>\n"); return; } Unbind(param[0]); }
void CON_Printf(rcolor clr, const char *s, ...) { static char msg[MAX_MESSAGE_SIZE]; va_list va; va_start(va, s); vsprintf(msg, s, va); va_end(va); I_Printf(msg); console_buffer[console_head]->color = clr; }
void G_ShowBinding(char *key) { alist_t **alist; alist = G_FindKeyByName(key); if(!alist) { CON_Warnf("Unknown key:%s\n", key); return; } if(!*alist) { CON_Warnf("%s is not bound\n", key); return; } I_Printf("%s = ", key); G_PrintActions(*alist); I_Printf("\n"); }
static CMD(Alias) { alist_t *al; if(!param[0]) { I_Printf("Current Aliases:\n"); G_ShowAliases(Actions); return; } al = ParseActions(param[1]); if(!al) G_UnregisterAction(param[0]); else G_AddCommand(param[0], G_RunAlias, (int64)al); }
static void Unbind(char *action) { alist_t **alist; alist = G_FindKeyByName(action); if(!alist) { I_Printf("Unknown Key:%s\n", action); return; } if(*alist) { DerefActionList(*alist); *alist=NULL; } }
void WI_drawOnLnode ( int n, patch_t* c[] ) { int i; int left; int top; int right; int bottom; qboolean fits = false; i = 0; do { left = lnodes[::g->wbs->epsd][n].x - SHORT(c[i]->leftoffset); top = lnodes[::g->wbs->epsd][n].y - SHORT(c[i]->topoffset); right = left + SHORT(c[i]->width); bottom = top + SHORT(c[i]->height); if (left >= 0 && right < SCREENWIDTH && top >= 0 && bottom < SCREENHEIGHT) { fits = true; } else { i++; } } while (!fits && i!=2); if (fits && i<2) { V_DrawPatch(lnodes[::g->wbs->epsd][n].x, lnodes[::g->wbs->epsd][n].y, FB, c[i]); } else { // DEBUG I_Printf("Could not place patch on level %d", n+1); } }
// // R_InitSpriteLumps // Finds the width and hoffset of all ::g->sprites in the wad, // so the sprite does not need to be cached completely // just for having the header info ready during rendering. // void R_InitSpriteLumps (void) { int i; patch_t *patch; ::g->firstspritelump = W_GetNumForName ("S_START") + 1; ::g->lastspritelump = W_GetNumForName ("S_END") - 1; ::g->numspritelumps = ::g->lastspritelump - ::g->firstspritelump + 1; ::g->spritewidth = (fixed_t*)DoomLib::Z_Malloc (::g->numspritelumps*4, PU_STATIC, 0); ::g->spriteoffset = (fixed_t*)DoomLib::Z_Malloc (::g->numspritelumps*4, PU_STATIC, 0); ::g->spritetopoffset = (fixed_t*)DoomLib::Z_Malloc (::g->numspritelumps*4, PU_STATIC, 0); for (i=0 ; i< ::g->numspritelumps ; i++) { if (!(i&63)) I_Printf ("."); patch = (patch_t*)W_CacheLumpNum (::g->firstspritelump+i, PU_CACHE_SHARED); ::g->spritewidth[i] = SHORT(patch->width)<<FRACBITS; ::g->spriteoffset[i] = SHORT(patch->leftoffset)<<FRACBITS; ::g->spritetopoffset[i] = SHORT(patch->topoffset)<<FRACBITS; } }
// // R_InitTextures // Initializes the texture list // with the s_textures from the world map. // void R_InitTextures (void) { maptexture_t* mtexture; texture_t* texture; mappatch_t* mpatch; texpatch_t* patch; int i; int j; int* maptex; int* maptex2; int* maptex1; char name[9]; char* names; char* name_p; int totalwidth; int nummappatches; int offset; int maxoff; int maxoff2; int numtextures1; int numtextures2; int* directory; int temp1; int temp2; int temp3; // Load the patch names from pnames.lmp. name[8] = 0; names = (char*)W_CacheLumpName ("PNAMES", PU_CACHE_SHARED); nummappatches = LONG ( *((int *)names) ); name_p = names+4; std::vector<int> patchlookup(nummappatches); for (i=0 ; i<nummappatches ; i++) { strncpy (name,name_p+i*8, 8); patchlookup[i] = W_CheckNumForName (name); } Z_Free(names); if (::g->s_numtextures == 0) { // Load the map texture definitions from textures.lmp. // The data is contained in one or two lumps, // TEXTURE1 for shareware, plus TEXTURE2 for commercial. maptex = maptex1 = (int*)W_CacheLumpName ("TEXTURE1", PU_CACHE_SHARED); // ALAN: LOADTIME numtextures1 = LONG(*maptex); maxoff = W_LumpLength (W_GetNumForName ("TEXTURE1")); directory = maptex+1; if (W_CheckNumForName ("TEXTURE2") != -1) { maptex2 = (int*)W_CacheLumpName ("TEXTURE2", PU_CACHE_SHARED); // ALAN: LOADTIME numtextures2 = LONG(*maptex2); maxoff2 = W_LumpLength (W_GetNumForName ("TEXTURE2")); } else { maptex2 = NULL; numtextures2 = 0; maxoff2 = 0; } ::g->s_numtextures = numtextures1 + numtextures2; ::g->s_textures = (texture_t**)DoomLib::Z_Malloc (::g->s_numtextures*sizeof(texture_t*), PU_STATIC_SHARED, 0); ::g->s_texturecolumnlump = (short**)DoomLib::Z_Malloc (::g->s_numtextures*sizeof(short*), PU_STATIC_SHARED, 0); ::g->s_texturecolumnofs = (unsigned short**)DoomLib::Z_Malloc (::g->s_numtextures*sizeof(unsigned short*), PU_STATIC_SHARED, 0); ::g->s_texturewidthmask = (int*)DoomLib::Z_Malloc (::g->s_numtextures*4, PU_STATIC_SHARED, 0); ::g->s_textureheight = (fixed_t*)DoomLib::Z_Malloc (::g->s_numtextures*4, PU_STATIC_SHARED, 0); ::g->s_texturecomposite = (byte**)DoomLib::Z_Malloc (::g->s_numtextures*sizeof(byte*), PU_STATIC_SHARED, 0); ::g->s_texturecompositesize = (int*)DoomLib::Z_Malloc (::g->s_numtextures*4, PU_STATIC_SHARED, 0); totalwidth = 0; // Really complex printing shit... temp1 = W_GetNumForName ("S_START"); // P_??????? temp2 = W_GetNumForName ("S_END") - 1; temp3 = ((temp2-temp1+63)/64) + ((::g->s_numtextures+63)/64); I_Printf("["); for (i = 0; i < temp3; i++) I_Printf(" "); I_Printf(" ]"); for (i = 0; i < temp3; i++) I_Printf("\x8"); I_Printf("\x8\x8\x8\x8\x8\x8\x8\x8\x8\x8"); for (i=0 ; i < ::g->s_numtextures ; i++, directory++) { if (!(i&63)) I_Printf ("."); if (i == numtextures1) { // Start looking in second texture file. maptex = maptex2; maxoff = maxoff2; directory = maptex+1; } offset = LONG(*directory); if (offset > maxoff) I_Error ("R_InitTextures: bad texture directory"); mtexture = (maptexture_t *) ( (byte *)maptex + offset); texture = ::g->s_textures[i] = (texture_t*)DoomLib::Z_Malloc (sizeof(texture_t) + sizeof(texpatch_t)*(SHORT(mtexture->patchcount)-1), PU_STATIC_SHARED, 0); texture->width = SHORT(mtexture->width); texture->height = SHORT(mtexture->height); texture->patchcount = SHORT(mtexture->patchcount); memcpy (texture->name, mtexture->name, sizeof(texture->name)); mpatch = &mtexture->patches[0]; patch = &texture->patches[0]; for (j=0 ; j<texture->patchcount ; j++, mpatch++, patch++) { patch->originx = SHORT(mpatch->originx); patch->originy = SHORT(mpatch->originy); patch->patch = patchlookup[SHORT(mpatch->patch)]; if (patch->patch == -1) { I_Error ("R_InitTextures: Missing patch in texture %s", texture->name); } } ::g->s_texturecolumnlump[i] = (short*)DoomLib::Z_Malloc (texture->width*2, PU_STATIC_SHARED,0); ::g->s_texturecolumnofs[i] = (unsigned short*)DoomLib::Z_Malloc (texture->width*2, PU_STATIC_SHARED,0); j = 1; while (j*2 <= texture->width) j<<=1; ::g->s_texturewidthmask[i] = j-1; ::g->s_textureheight[i] = texture->height<<FRACBITS; totalwidth += texture->width; } Z_Free(maptex1); if (maptex2) Z_Free(maptex2); // Precalculate whatever possible. for (i=0 ; i < ::g->s_numtextures ; i++) R_GenerateLookup (i); } // ALAN: These animations are done globally -- can it be shared? // Create translation table for global animation. ::g->texturetranslation = (int*)DoomLib::Z_Malloc ((::g->s_numtextures+1)*4, PU_STATIC, 0); for (i=0 ; i < ::g->s_numtextures ; i++) ::g->texturetranslation[i] = i; }
// // R_GenerateLookup // void R_GenerateLookup (int texnum) { texture_t* texture; texpatch_t* patch; patch_t* realpatch; int x; int x1; int x2; int i; short* collump; unsigned short* colofs; texture = ::g->s_textures[texnum]; // Composited texture not created yet. ::g->s_texturecomposite[texnum] = 0; ::g->s_texturecompositesize[texnum] = 0; collump = ::g->s_texturecolumnlump[texnum]; colofs = ::g->s_texturecolumnofs[texnum]; // Now count the number of columns // that are covered by more than one patch. // Fill in the lump / offset, so columns // with only a single patch are all done. std::vector<byte> patchcount(texture->width, 0); patch = texture->patches; for (i=0 , patch = texture->patches; i<texture->patchcount; i++, patch++) { realpatch = (patch_t*)W_CacheLumpNum (patch->patch, PU_CACHE_SHARED); x1 = patch->originx; x2 = x1 + SHORT(realpatch->width); if (x1 < 0) x = 0; else x = x1; if (x2 > texture->width) x2 = texture->width; for ( ; x<x2 ; x++) { patchcount[x]++; collump[x] = patch->patch; colofs[x] = LONG(realpatch->columnofs[x-x1])+3; } } for (x=0 ; x<texture->width ; x++) { if (!patchcount[x]) { I_Printf ("R_GenerateLookup: column without a patch (%s)\n", texture->name); return; } // I_Error ("R_GenerateLookup: column without a patch"); if (patchcount[x] > 1) { // Use the cached block. collump[x] = -1; colofs[x] = ::g->s_texturecompositesize[texnum]; if (::g->s_texturecompositesize[texnum] > 0x10000-texture->height) { I_Error ("R_GenerateLookup: texture %i is >64k", texnum); } ::g->s_texturecompositesize[texnum] += texture->height; } } }
static void D_DebugParams(void) { int keys = 0; scanKeys(); keys = keysHeld(); if(!(keys & (KEY_Y | KEY_B))) return; I_Printf("Debug startup enabled\n\n"); while(!(keys & KEY_START)) { scanKeys(); keys = keysDown(); if(keys & KEY_UP) { keys &= ~KEY_UP; startmap++; if(startmap > 33) startmap = 33; I_Printf("startmap: %i\n", startmap); } if(keys & KEY_DOWN) { keys &= ~KEY_DOWN; startmap--; if(startmap < 1) startmap = 1; I_Printf("startmap: %i\n", startmap); } if(keys & KEY_A) { nomonsters ^= 1; I_Printf("nomonsters "); if(nomonsters) I_Printf("on\n"); else I_Printf("off\n"); } if(keys & KEY_B) { lockmonsters ^= 1; I_Printf("lockmonsters "); if(lockmonsters) I_Printf("on\n"); else I_Printf("off\n"); } if(keys & KEY_X) { devparm ^= 1; I_Printf("development mode "); if(devparm) I_Printf("on\n"); else I_Printf("off\n"); } if(keys & KEY_Y) { nosound ^= 1; I_Printf("sound "); if(nosound) I_Printf("disabled\n"); else I_Printf("enabled\n"); } swiWaitForVBlank(); } I_Printf("Exiting...\n"); }
void W_AddFile ( const char *filename) { wadinfo_t header; lumpinfo_t* lump_p; int i; idFile * handle; int length; int startlump; std::vector<filelump_t> fileinfo( 1 ); // open the file and add to directory if ( (handle = fileSystem->OpenFileRead(filename)) == 0) { I_Printf (" couldn't open %s\n",filename); return; } I_Printf (" adding %s\n",filename); startlump = numlumps; if ( idStr::Icmp( filename+strlen(filename)-3 , "wad" ) ) { // single lump file fileinfo[0].filepos = 0; fileinfo[0].size = 0; ExtractFileBase (filename, fileinfo[0].name); numlumps++; } else { // WAD file handle->Read( &header, sizeof( header ) ); if ( idStr::Cmpn( header.identification,"IWAD",4 ) ) { // Homebrew levels? if ( idStr::Cmpn( header.identification, "PWAD", 4 ) ) { I_Error ("Wad file %s doesn't have IWAD " "or PWAD id\n", filename); } // ???modifiedgame = true; } header.numlumps = LONG(header.numlumps); header.infotableofs = LONG(header.infotableofs); length = header.numlumps*sizeof(filelump_t); fileinfo.resize(header.numlumps); handle->Seek( header.infotableofs, FS_SEEK_SET ); handle->Read( &fileinfo[0], length ); numlumps += header.numlumps; } // Fill in lumpinfo if (lumpinfo == NULL) { lumpinfo = (lumpinfo_t*)malloc( numlumps*sizeof(lumpinfo_t) ); } else { lumpinfo = (lumpinfo_t*)realloc( lumpinfo, numlumps*sizeof(lumpinfo_t) ); } if (!lumpinfo) I_Error ("Couldn't realloc lumpinfo"); lump_p = &lumpinfo[startlump]; ::g->wadFileHandles[ ::g->numWadFiles++ ] = handle; filelump_t * filelumpPointer = &fileinfo[0]; for (i=startlump ; i<numlumps ; i++,lump_p++, filelumpPointer++) { lump_p->handle = handle; lump_p->position = LONG(filelumpPointer->filepos); lump_p->size = LONG(filelumpPointer->size); strncpy (lump_p->name, filelumpPointer->name, 8); } }
// // I_InitNetwork // void I_InitNetwork (void) { //qboolean trueval = true; int i; int p; //int a = 0; // struct hostent* hostentry; // host information entry memset (&::g->doomcom, 0, sizeof(::g->doomcom) ); // set up for network i = M_CheckParm ("-dup"); if (i && i< ::g->myargc-1) { ::g->doomcom.ticdup = ::g->myargv[i+1][0]-'0'; if (::g->doomcom.ticdup < 1) ::g->doomcom.ticdup = 1; if (::g->doomcom.ticdup > 9) ::g->doomcom.ticdup = 9; } else ::g->doomcom.ticdup = 1; if (M_CheckParm ("-extratic")) ::g->doomcom.extratics = 1; else ::g->doomcom.extratics = 0; p = M_CheckParm ("-port"); if (p && p < ::g->myargc-1) { DOOMPORT = atoi (::g->myargv[p+1]); I_Printf ("using alternate port %i\n",DOOMPORT); } // parse network game options, // -net <::g->consoleplayer> <host> <host> ... i = M_CheckParm ("-net"); if (!i || !I_TrySetupNetwork()) { // single player game ::g->netgame = false; ::g->doomcom.id = DOOMCOM_ID; ::g->doomcom.numplayers = ::g->doomcom.numnodes = 1; ::g->doomcom.deathmatch = false; ::g->doomcom.consoleplayer = 0; return; } netsend = PacketSend; netget = PacketGet; ::g->netgame = true; { ++i; // skip the '-net' ::g->doomcom.numnodes = 0; ::g->doomcom.consoleplayer = atoi( ::g->myargv[i] ); // skip the console number ++i; ::g->doomcom.numnodes = 0; for (; i < ::g->myargc; ++i) { ::g->sendaddress[::g->doomcom.numnodes].sin_family = AF_INET; ::g->sendaddress[::g->doomcom.numnodes].sin_port = htons(DOOMPORT); // Pull out the port number. const std::string ipAddressWithPort( ::g->myargv[i] ); const std::size_t colonPosition = ipAddressWithPort.find_last_of(':'); std::string ipOnly; if( colonPosition != std::string::npos && colonPosition + 1 < ipAddressWithPort.size() ) { const std::string portOnly( ipAddressWithPort.substr( colonPosition + 1 ) ); ::g->sendaddress[::g->doomcom.numnodes].sin_port = htons( atoi( portOnly.c_str() ) ); ipOnly = ipAddressWithPort.substr( 0, colonPosition ); } else { // Assume the address doesn't include a port. ipOnly = ipAddressWithPort; } in_addr_t ipAddress = inet_addr( ipOnly.c_str() ); if ( ipAddress == INADDR_NONE ) { I_Error( "Invalid IP Address: %s\n", ipOnly.c_str() ); session->QuitMatch(); common->AddDialog( GDM_OPPONENT_CONNECTION_LOST, DIALOG_ACCEPT, NULL, NULL, false ); } ::g->sendaddress[::g->doomcom.numnodes].sin_addr.s_addr = ipAddress; ::g->doomcom.numnodes++; } ::g->doomcom.id = DOOMCOM_ID; ::g->doomcom.numplayers = ::g->doomcom.numnodes; } if ( globalNetworking ) { // Setup sockets ::g->insocket = UDPsocket (); BindToLocalPort (::g->insocket,htons(DOOMPORT)); // PS3 call to enable non-blocking mode int nonblocking = 1; // Non-zero is nonblocking mode. setsockopt( ::g->insocket, SOL_SOCKET, SO_NBIO, &nonblocking, sizeof(nonblocking)); ::g->sendsocket = UDPsocket (); I_Printf( "[+] Setting up sockets for player %d\n", DoomLib::GetPlayer() ); } }