/*
==================
SCR_Init
==================
*/
void SCR_Init (void)
{

	Cvar_RegisterVariable (&scr_fov);
	Cvar_RegisterVariable (&scr_viewsize);
	Cvar_RegisterVariable (&scr_conspeed);
	Cvar_RegisterVariable (&scr_showram);
	Cvar_RegisterVariable (&scr_showturtle);
	Cvar_RegisterVariable (&scr_showpause);
	Cvar_RegisterVariable (&scr_centertime);
	Cvar_RegisterVariable (&scr_printspeed);
    Cvar_RegisterVariable (&scr_conheight);
	Cvar_RegisterVariable (&r_dithering);
    Cvar_RegisterVariable (&scr_coloredtext);
	Cvar_RegisterVariable (&crosshairalpha);
    Cvar_RegisterVariable (&crosshairsize);
	Cvar_RegisterVariable (&crosshaircolor);

//
// register our commands
//
	Cmd_AddCommand ("screenshot",SCR_ScreenShot_f);
	Cmd_AddCommand ("sizeup",SCR_SizeUp_f);
	Cmd_AddCommand ("sizedown",SCR_SizeDown_f);

	scr_ram = Draw_PicFromWad ("ram");
	scr_net = Draw_PicFromWad ("net");
	scr_turtle = Draw_PicFromWad ("turtle");

	scr_initialized = qtrue;
}
示例#2
0
/*
===========
IN_Init
===========
*/
void IN_Init (void)
{
	// mouse variables
	Cvar_RegisterVariable (&m_filter);

	// joystick variables
	Cvar_RegisterVariable (&in_joystick);
	Cvar_RegisterVariable (&joy_name);
	Cvar_RegisterVariable (&joy_advanced);
	Cvar_RegisterVariable (&joy_advaxisx);
	Cvar_RegisterVariable (&joy_advaxisy);
	Cvar_RegisterVariable (&joy_advaxisz);
	Cvar_RegisterVariable (&joy_advaxisr);
	Cvar_RegisterVariable (&joy_advaxisu);
	Cvar_RegisterVariable (&joy_advaxisv);
	Cvar_RegisterVariable (&joy_forwardthreshold);
	Cvar_RegisterVariable (&joy_sidethreshold);
	Cvar_RegisterVariable (&joy_pitchthreshold);
	Cvar_RegisterVariable (&joy_yawthreshold);
	Cvar_RegisterVariable (&joy_forwardsensitivity);
	Cvar_RegisterVariable (&joy_sidesensitivity);
	Cvar_RegisterVariable (&joy_pitchsensitivity);
	Cvar_RegisterVariable (&joy_yawsensitivity);
	Cvar_RegisterVariable (&joy_wwhack1);
	Cvar_RegisterVariable (&joy_wwhack2);

	Cmd_AddCommand ("force_centerview", Force_CenterView_f);
	Cmd_AddCommand ("joyadvancedupdate", Joy_AdvancedUpdate_f);

	uiWheelMessage = RegisterWindowMessage ( "MSWHEEL_ROLLMSG" );

	IN_StartupMouse ();
	IN_StartupJoystick ();
}
示例#3
0
文件: snd_dma.c 项目: ACIIL/Quake
/*
================
S_Init
================
*/
void S_Init (void)
{

//	Con_Printf("\nSound Initialization\n");

	if (COM_CheckParm("-nosound"))
		return;

	if (COM_CheckParm("-simsound"))
		fakedma = true;

	Cmd_AddCommand("play", S_Play);
	Cmd_AddCommand("playvol", S_PlayVol);
	Cmd_AddCommand("stopsound", S_StopAllSoundsC);
	Cmd_AddCommand("soundlist", S_SoundList);
	Cmd_AddCommand("soundinfo", S_SoundInfo_f);

	Cvar_RegisterVariable(&nosound);
	Cvar_RegisterVariable(&volume);
	Cvar_RegisterVariable(&precache);
	Cvar_RegisterVariable(&loadas8bit);
	Cvar_RegisterVariable(&bgmvolume);
	Cvar_RegisterVariable(&bgmbuffer);
	Cvar_RegisterVariable(&ambient_level);
	Cvar_RegisterVariable(&ambient_fade);
	Cvar_RegisterVariable(&snd_noextraupdate);
	Cvar_RegisterVariable(&snd_show);
	Cvar_RegisterVariable(&_snd_mixahead);

	if (host_parms.memsize < 0x800000)
	{
		Cvar_Set ("loadas8bit", "1");
		Con_Printf ("loading all sounds as 8bit\n");
	}



	snd_initialized = true;

	S_Startup ();

	SND_InitScaletable ();

	known_sfx = Hunk_AllocName (MAX_SFX*sizeof(sfx_t), "sfx_t");
	num_sfx = 0;

// create a piece of DMA memory

	if (fakedma)
	{
		shm = (void *) Hunk_AllocName(sizeof(*shm), "shm");
		shm->splitbuffer = 0;
		shm->samplebits = 16;
		shm->speed = 22050;
		shm->channels = 2;
		shm->samples = 32768;
		shm->samplepos = 0;
		shm->soundalive = true;
		shm->gamealive = true;
		shm->submission_chunk = 1;
		shm->buffer = Hunk_AllocName(1<<16, "shmbuf");
	}

//	Con_Printf ("Sound sampling rate: %i\n", shm->speed);

	// provides a tick sound until washed clean

//	if (shm->buffer)
//		shm->buffer[4] = shm->buffer[5] = 0x7f;	// force a pop for debugging

	ambient_sfx[AMBIENT_WATER] = S_PrecacheSound ("ambience/water1.wav");
	ambient_sfx[AMBIENT_SKY] = S_PrecacheSound ("ambience/wind2.wav");

	S_StopAllSounds (true);
}
示例#4
0
文件: gl_model.c 项目: welford/qurp
/*
===============
Mod_Init
===============
*/
void Mod_Init (void)
{
	Cvar_RegisterVariable (&gl_subdivide_size);
	memset (mod_novis, 0xff, sizeof(mod_novis));
}
示例#5
0
void NET_Init (void)
{
	int			i;
	int			controlSocket;
	qsocket_t	*s;

	if (COM_CheckParm("-playback"))
	{
		net_numdrivers = 1;
		net_drivers[0].Init = VCR_Init;
	}

	if (COM_CheckParm("-record"))
		recording = true;

	i = COM_CheckParm ("-port");
	if (!i)
		i = COM_CheckParm ("-udpport");
	if (!i)
		i = COM_CheckParm ("-ipxport");

	if (i)
	{
		if (i < com_argc-1)
			DEFAULTnet_hostport = Q_atoi (com_argv[i+1]);
		else
			Sys_Error ("NET_Init: you must specify a number after -port");
	}
	net_hostport = DEFAULTnet_hostport;

	if (COM_CheckParm("-listen") || cls.state == ca_dedicated)
		listening = true;
	net_numsockets = svs.maxclientslimit;
	if (cls.state != ca_dedicated)
		net_numsockets++;

	SetNetTime();

	for (i = 0; i < net_numsockets; i++)
	{
		s = (qsocket_t *)Hunk_AllocName(sizeof(qsocket_t), "qsocket");
		s->next = net_freeSockets;
		net_freeSockets = s;
		s->disconnected = true;
	}

	// allocate space for network message buffer
	SZ_Alloc (&net_message, NET_MAXMESSAGE);

	Cvar_RegisterVariable (&net_messagetimeout);
	Cvar_RegisterVariable (&hostname);
	Cvar_RegisterVariable (&config_com_port);
	Cvar_RegisterVariable (&config_com_irq);
	Cvar_RegisterVariable (&config_com_baud);
	Cvar_RegisterVariable (&config_com_modem);
	Cvar_RegisterVariable (&config_modem_dialtype);
	Cvar_RegisterVariable (&config_modem_clear);
	Cvar_RegisterVariable (&config_modem_init);
	Cvar_RegisterVariable (&config_modem_hangup);
#ifdef IDGODS
	Cvar_RegisterVariable (&idgods);
#endif

	if(!host_initialized)
	{
		Cmd_AddCommand ("slist", NET_Slist_f);
		Cmd_AddCommand ("listen", NET_Listen_f);
		Cmd_AddCommand ("maxplayers", MaxPlayers_f);
		Cmd_AddCommand ("port", NET_Port_f);
	}

	// initialize all the drivers
	for (net_driverlevel=0 ; net_driverlevel<net_numdrivers ; net_driverlevel++)
		{
		controlSocket = net_drivers[net_driverlevel].Init();
		if (controlSocket == -1)
			continue;
		net_drivers[net_driverlevel].initialized = true;
		net_drivers[net_driverlevel].controlSock = controlSocket;
		if (listening)
			net_drivers[net_driverlevel].Listen (true);
		}

	if (*my_ipx_address)
		Con_DPrintf("IPX address %s\n", my_ipx_address);
	if (*my_tcpip_address)
		Con_DPrintf("TCP/IP address %s\n", my_tcpip_address);
}
示例#6
0
文件: host.cpp 项目: TeamNyx/gdk
/*
=======================
Host_InitLocal
======================
*/
void Host_InitLocal (void)
{
	Host_InitCommands ();

	Cvar_RegisterVariable (&host_framerate);
	Cvar_RegisterVariable (&host_speeds);

	Cvar_RegisterVariable (&sys_ticrate);
	Cvar_RegisterVariable (&serverprofile);

	Cvar_RegisterVariable (&fraglimit);
	Cvar_RegisterVariable (&timelimit);
	Cvar_RegisterVariable (&teamplay);
	Cvar_RegisterVariable (&samelevel);
	Cvar_RegisterVariable (&noexit);
	Cvar_RegisterVariable (&skill);
	Cvar_RegisterVariable (&developer);
	Cvar_RegisterVariable (&deathmatch);
	Cvar_RegisterVariable (&coop);

	Cvar_RegisterVariable (&pausable);

	Cvar_RegisterVariable (&temp1);

	Host_FindMaxClients ();

	host_time = 1.0;		// so a think at time 0 won't get called
}
示例#7
0
void Palette_Init(void)
{
	R_RegisterModule("Palette", Palette_Load, Palette_Shutdown, Palette_NewMap, NULL, NULL);
	Cvar_RegisterVariable(&r_colormap_palette);
	Palette_Load();
}
示例#8
0
/*  Initialization function.
*/
void Editor_Initialize(void)
{
	Cvar_RegisterVariable(&cvEditorLightPreview,NULL);
}
示例#9
0
void IN_Init (void)
{
    Cvar_RegisterVariable (&in_anglescaling);
}
示例#10
0
/*
===============
SV_Init
===============
*/
void SV_Init (void)
{
    int		i;
    extern	cvar_t	sv_maxvelocity;
    extern	cvar_t	sv_gravity;
    extern	cvar_t	sv_nostep;
    extern	cvar_t	sv_friction;
    extern	cvar_t	sv_edgefriction;
    extern	cvar_t	sv_stopspeed;
    extern	cvar_t	sv_maxspeed;
    extern	cvar_t	sv_accelerate;
    extern	cvar_t	sv_idealpitchscale;
    extern	cvar_t	sv_aim;

    Cvar_RegisterVariable (&sv_maxvelocity);
    Cvar_RegisterVariable (&sv_gravity);
    Cvar_RegisterVariable (&sv_friction);
    Cvar_RegisterVariable (&sv_edgefriction);
    Cvar_RegisterVariable (&sv_stopspeed);
    Cvar_RegisterVariable (&sv_maxspeed);
    Cvar_RegisterVariable (&sv_accelerate);
    Cvar_RegisterVariable (&sv_idealpitchscale);
    Cvar_RegisterVariable (&sv_aim);
    Cvar_RegisterVariable (&sv_nostep);

    Cvar_RegisterVariable(&pq_fullpitch); // JPG 2.01

    for (i=0 ; i<MAX_MODELS ; i++)
        sprintf (localmodels[i], "*%i", i);
}
示例#11
0
文件: host.c 项目: bangstk/Quakespasm
/*
=======================
Host_InitLocal
======================
*/
void Host_InitLocal (void)
{
	Cmd_AddCommand ("version", Host_Version_f);

	Host_InitCommands ();

	Cvar_RegisterVariable (&host_framerate);
	Cvar_RegisterVariable (&host_speeds);
	Cvar_RegisterVariable (&host_maxfps); //johnfitz
	Cvar_RegisterVariable (&host_timescale); //johnfitz

	Cvar_RegisterVariable (&max_edicts); //johnfitz
	Cvar_SetCallback (&max_edicts, Max_Edicts_f);
	Cvar_RegisterVariable (&devstats); //johnfitz

	Cvar_RegisterVariable (&sys_ticrate);
	Cvar_RegisterVariable (&sys_throttle);
	Cvar_RegisterVariable (&serverprofile);

	Cvar_RegisterVariable (&fraglimit);
	Cvar_RegisterVariable (&timelimit);
	Cvar_RegisterVariable (&teamplay);
	Cvar_SetCallback (&fraglimit, Host_Callback_Notify);
	Cvar_SetCallback (&timelimit, Host_Callback_Notify);
	Cvar_SetCallback (&teamplay, Host_Callback_Notify);
	Cvar_RegisterVariable (&samelevel);
	Cvar_RegisterVariable (&noexit);
	Cvar_SetCallback (&noexit, Host_Callback_Notify);
	Cvar_RegisterVariable (&skill);
	Cvar_RegisterVariable (&developer);
	Cvar_RegisterVariable (&coop);
	Cvar_RegisterVariable (&deathmatch);

	Cvar_RegisterVariable (&pausable);

	Cvar_RegisterVariable (&temp1);

	Host_FindMaxClients ();
}
示例#12
0
bool retro_load_game(const struct retro_game_info *info)
{
   quakeparms_t parms;

   extract_directory(g_rom_dir, info->path, sizeof(g_rom_dir));

   snprintf(g_pak_path, sizeof(g_pak_path), "%s", info->path);

   MEMSIZE_MB = DEFAULT_MEMSIZE_MB;

   if (strstr(info->path, "hipnotic") || strstr(info->path, "rogue")
         || strstr(info->path, "HIPNOTIC")
         || strstr(info->path, "ROGUE"))
   {
#if defined(HW_RVL) || defined(_XBOX1)
      MEMSIZE_MB = 16;
#endif
      extract_directory(g_rom_dir, g_rom_dir, sizeof(g_rom_dir));
   }

   memset(&parms, 0, sizeof(parms));

   COM_InitArgv(0, NULL);

   parms.argc = com_argc;
   parms.argv = com_argv;
   parms.basedir = g_rom_dir;
   parms.memsize = MEMSIZE_MB * 1024 * 1024;

   heap = (unsigned char*)malloc(parms.memsize);

   parms.membase = heap;

#ifdef NQ_HACK
   fprintf(stderr, "Quake Libretro -- TyrQuake Version %s\n", stringify(TYR_VERSION));
#endif
#ifdef QW_HACK
   fprintf(stderr, "QuakeWorld Libretro -- TyrQuake Version %s\n", stringify(TYR_VERSION));
#endif

   Sys_Init();
   Host_Init(&parms);

   Cvar_Set("cl_bob", "0.02");
   Cvar_Set("crosshair", "0");
   Cvar_Set("viewsize", "100");
   Cvar_Set("showram", "0");
   Cvar_Set("dither_filter", "1");
   Cvar_RegisterVariable(&framerate);
   Cvar_Set("framerate", "60");

   enum retro_pixel_format fmt = RETRO_PIXEL_FORMAT_RGB565;
   if (!environ_cb(RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, &fmt))
   {
      fprintf(stderr, "RGB565 is not supported.\n");
      return false;
   }

   /* set keyboard callback */

   //struct retro_keyboard_callback cb = { keyboard_cb };
   //environ_cb(RETRO_ENVIRONMENT_SET_KEYBOARD_CALLBACK, &cb);

#ifdef NQ_HACK
   oldtime = Sys_DoubleTime() - 0.1;
#endif
#ifdef QW_HACK
   oldtime = Sys_DoubleTime();
#endif

   return true;
}
示例#13
0
void S_Init (void)
{
	Cvar_RegisterVariable(&precache);
	Con_Printf("SOUND: disabled at compile time\n");
}
示例#14
0
文件: sbar.c 项目: dommul/super8
/*
===============
Sbar_Init
===============
*/
void Sbar_Init (void)
{
    int		i;

    Cvar_RegisterVariableWithCallback(&sbar_scale, CheckSbarScale); //qb: added
    // mankrip - begin
    Cvar_RegisterVariable (&sbar_show_scores);
    Cvar_RegisterVariable (&sbar_show_ammolist);
    Cvar_RegisterVariable (&sbar_show_weaponlist);
    Cvar_RegisterVariable (&sbar_show_keys);
    Cvar_RegisterVariable (&sbar_show_runes);
    Cvar_RegisterVariable (&sbar_show_powerups);
    Cvar_RegisterVariable (&sbar_show_armor);
    Cvar_RegisterVariable (&sbar_show_health);
    Cvar_RegisterVariable (&sbar_show_ammo);
    Cvar_RegisterVariable (&sbar_show_bg);
    Cvar_RegisterVariable (&sbar);

    Cvar_RegisterVariable (&crosshair_color);
    Cvar_RegisterVariable (&crosshair_custom16); //qb: custom color
    Cvar_RegisterVariable (&crosshair_custom17); //qb: custom color

    Cvar_RegisterVariableWithCallback (&sbar, Sbar_SizeScreen);
    // mankrip - end

    for (i=0 ; i<10 ; i++)
    {
        sb_nums[0][i] = Draw_PicFromWad (va("num_%i",i));
        sb_nums[1][i] = Draw_PicFromWad (va("anum_%i",i));
    }

    sb_nums[0][10] = Draw_PicFromWad ("num_minus");
    sb_nums[1][10] = Draw_PicFromWad ("anum_minus");

    sb_colon = Draw_PicFromWad ("num_colon");
    sb_slash = Draw_PicFromWad ("num_slash");

    sb_weapons[0][0] = Draw_PicFromWad ("inv_shotgun");
    sb_weapons[0][1] = Draw_PicFromWad ("inv_sshotgun");
    sb_weapons[0][2] = Draw_PicFromWad ("inv_nailgun");
    sb_weapons[0][3] = Draw_PicFromWad ("inv_snailgun");
    sb_weapons[0][4] = Draw_PicFromWad ("inv_rlaunch");
    sb_weapons[0][5] = Draw_PicFromWad ("inv_srlaunch");
    sb_weapons[0][6] = Draw_PicFromWad ("inv_lightng");

    sb_weapons[1][0] = Draw_PicFromWad ("inv2_shotgun");
    sb_weapons[1][1] = Draw_PicFromWad ("inv2_sshotgun");
    sb_weapons[1][2] = Draw_PicFromWad ("inv2_nailgun");
    sb_weapons[1][3] = Draw_PicFromWad ("inv2_snailgun");
    sb_weapons[1][4] = Draw_PicFromWad ("inv2_rlaunch");
    sb_weapons[1][5] = Draw_PicFromWad ("inv2_srlaunch");
    sb_weapons[1][6] = Draw_PicFromWad ("inv2_lightng");

    for (i=0 ; i<5 ; i++)
    {
        sb_weapons[2+i][0] = Draw_PicFromWad (va("inva%i_shotgun",i+1));
        sb_weapons[2+i][1] = Draw_PicFromWad (va("inva%i_sshotgun",i+1));
        sb_weapons[2+i][2] = Draw_PicFromWad (va("inva%i_nailgun",i+1));
        sb_weapons[2+i][3] = Draw_PicFromWad (va("inva%i_snailgun",i+1));
        sb_weapons[2+i][4] = Draw_PicFromWad (va("inva%i_rlaunch",i+1));
        sb_weapons[2+i][5] = Draw_PicFromWad (va("inva%i_srlaunch",i+1));
        sb_weapons[2+i][6] = Draw_PicFromWad (va("inva%i_lightng",i+1));
    }

    sb_ammo[0] = Draw_PicFromWad ("sb_shells");
    sb_ammo[1] = Draw_PicFromWad ("sb_nails");
    sb_ammo[2] = Draw_PicFromWad ("sb_rocket");
    sb_ammo[3] = Draw_PicFromWad ("sb_cells");

    sb_armor[0] = Draw_PicFromWad ("sb_armor1");
    sb_armor[1] = Draw_PicFromWad ("sb_armor2");
    sb_armor[2] = Draw_PicFromWad ("sb_armor3");

    sb_items[0] = Draw_PicFromWad ("sb_key1");
    sb_items[1] = Draw_PicFromWad ("sb_key2");
    sb_items[2] = Draw_PicFromWad ("sb_invis");
    sb_items[3] = Draw_PicFromWad ("sb_invuln");
    sb_items[4] = Draw_PicFromWad ("sb_suit");
    sb_items[5] = Draw_PicFromWad ("sb_quad");

    sb_sigil[0] = Draw_PicFromWad ("sb_sigil1");
    sb_sigil[1] = Draw_PicFromWad ("sb_sigil2");
    sb_sigil[2] = Draw_PicFromWad ("sb_sigil3");
    sb_sigil[3] = Draw_PicFromWad ("sb_sigil4");

    sb_faces[4][0] = Draw_PicFromWad ("face1");
    sb_faces[4][1] = Draw_PicFromWad ("face_p1");
    sb_faces[3][0] = Draw_PicFromWad ("face2");
    sb_faces[3][1] = Draw_PicFromWad ("face_p2");
    sb_faces[2][0] = Draw_PicFromWad ("face3");
    sb_faces[2][1] = Draw_PicFromWad ("face_p3");
    sb_faces[1][0] = Draw_PicFromWad ("face4");
    sb_faces[1][1] = Draw_PicFromWad ("face_p4");
    sb_faces[0][0] = Draw_PicFromWad ("face5");
    sb_faces[0][1] = Draw_PicFromWad ("face_p5");

    sb_face_invis = Draw_PicFromWad ("face_invis");
    sb_face_invuln = Draw_PicFromWad ("face_invul2");
    sb_face_invis_invuln = Draw_PicFromWad ("face_inv2");
    sb_face_quad = Draw_PicFromWad ("face_quad");

    Cmd_AddCommand ("+showscores", Sbar_ShowScores);
    Cmd_AddCommand ("-showscores", Sbar_DontShowScores);

    sb_sbar = Draw_PicFromWad ("sbar");
    sb_ibar = Draw_PicFromWad ("ibar");
    sb_scorebar = Draw_PicFromWad ("scorebar");

//MED 01/04/97 added new hipnotic weapons
    if (hipnotic)
    {
        hsb_weapons[0][0] = Draw_PicFromWad ("inv_laser");
        hsb_weapons[0][1] = Draw_PicFromWad ("inv_mjolnir");
        hsb_weapons[0][2] = Draw_PicFromWad ("inv_gren_prox");
        hsb_weapons[0][3] = Draw_PicFromWad ("inv_prox_gren");
        hsb_weapons[0][4] = Draw_PicFromWad ("inv_prox");

        hsb_weapons[1][0] = Draw_PicFromWad ("inv2_laser");
        hsb_weapons[1][1] = Draw_PicFromWad ("inv2_mjolnir");
        hsb_weapons[1][2] = Draw_PicFromWad ("inv2_gren_prox");
        hsb_weapons[1][3] = Draw_PicFromWad ("inv2_prox_gren");
        hsb_weapons[1][4] = Draw_PicFromWad ("inv2_prox");

        for (i=0 ; i<5 ; i++)
        {
            hsb_weapons[2+i][0] = Draw_PicFromWad (va("inva%i_laser",i+1));
            hsb_weapons[2+i][1] = Draw_PicFromWad (va("inva%i_mjolnir",i+1));
            hsb_weapons[2+i][2] = Draw_PicFromWad (va("inva%i_gren_prox",i+1));
            hsb_weapons[2+i][3] = Draw_PicFromWad (va("inva%i_prox_gren",i+1));
            hsb_weapons[2+i][4] = Draw_PicFromWad (va("inva%i_prox",i+1));
        }

        hsb_items[0] = Draw_PicFromWad ("sb_wsuit");
        hsb_items[1] = Draw_PicFromWad ("sb_eshld");
    }

    if (rogue)
    {
        rsb_invbar[0] = Draw_PicFromWad ("r_invbar1");
        rsb_invbar[1] = Draw_PicFromWad ("r_invbar2");

        rsb_weapons[0] = Draw_PicFromWad ("r_lava");
        rsb_weapons[1] = Draw_PicFromWad ("r_superlava");
        rsb_weapons[2] = Draw_PicFromWad ("r_gren");
        rsb_weapons[3] = Draw_PicFromWad ("r_multirock");
        rsb_weapons[4] = Draw_PicFromWad ("r_plasma");

        rsb_items[0] = Draw_PicFromWad ("r_shield1");
        rsb_items[1] = Draw_PicFromWad ("r_agrav1");

// PGM 01/19/97 - team color border
        rsb_teambord = Draw_PicFromWad ("r_teambord");
// PGM 01/19/97 - team color border

        rsb_ammo[0] = Draw_PicFromWad ("r_ammolava");
        rsb_ammo[1] = Draw_PicFromWad ("r_ammomulti");
        rsb_ammo[2] = Draw_PicFromWad ("r_ammoplasma");
    }
    Draw_CachePic ("gfx/complete.lmp"); // mankrip
    Draw_CachePic ("gfx/inter.lmp"); // mankrip
}
示例#15
0
/*
==================
SCR_Init
==================
*/
void SCR_Init (void)
{
	//johnfitz -- new cvars
	Cvar_RegisterVariable (&scr_menuscale);
	Cvar_RegisterVariable (&scr_sbarscale);
	Cvar_SetCallback (&scr_sbaralpha, SCR_Callback_refdef);
	Cvar_RegisterVariable (&scr_sbaralpha);
	Cvar_SetCallback (&scr_conwidth, &SCR_Conwidth_f);
	Cvar_SetCallback (&scr_conscale, &SCR_Conwidth_f);
	Cvar_RegisterVariable (&scr_conwidth);
	Cvar_RegisterVariable (&scr_conscale);
	Cvar_RegisterVariable (&scr_crosshairscale);
	Cvar_RegisterVariable (&scr_showfps);
	Cvar_RegisterVariable (&scr_clock);
	//johnfitz
	Cvar_SetCallback (&scr_fov, SCR_Callback_refdef);
	Cvar_SetCallback (&scr_fov_adapt, SCR_Callback_refdef);
	Cvar_SetCallback (&scr_viewsize, SCR_Callback_refdef);
	Cvar_RegisterVariable (&scr_fov);
	Cvar_RegisterVariable (&scr_fov_adapt);
	Cvar_RegisterVariable (&scr_viewsize);
	Cvar_RegisterVariable (&scr_conspeed);
	Cvar_RegisterVariable (&scr_showram);
	Cvar_RegisterVariable (&scr_showturtle);
	Cvar_RegisterVariable (&scr_showpause);
	Cvar_RegisterVariable (&scr_centertime);
	Cvar_RegisterVariable (&scr_printspeed);
	Cvar_RegisterVariable (&gl_triplebuffer);

	Cmd_AddCommand ("screenshot",SCR_ScreenShot_f);
	Cmd_AddCommand ("sizeup",SCR_SizeUp_f);
	Cmd_AddCommand ("sizedown",SCR_SizeDown_f);

	SCR_LoadPics (); //johnfitz

	scr_initialized = true;
}
示例#16
0
/* <35d12> ../engine/host.c:297 */
void Host_InitLocal(void)
{
	Host_InitCommands();
	Cvar_RegisterVariable(&host_killtime);
	Cvar_RegisterVariable(&sys_ticrate);
	Cvar_RegisterVariable(&fps_max);
	Cvar_RegisterVariable(&fps_override);
	Cvar_RegisterVariable(&host_name);
	Cvar_RegisterVariable(&host_limitlocal);

	sys_timescale.value = 1.0f;

	Cvar_RegisterVariable(&host_framerate);
	Cvar_RegisterVariable(&host_speeds);
	Cvar_RegisterVariable(&host_profile);
	Cvar_RegisterVariable(&mp_logfile);
	Cvar_RegisterVariable(&mp_logecho);
	Cvar_RegisterVariable(&sv_log_onefile);
	Cvar_RegisterVariable(&sv_log_singleplayer);
	Cvar_RegisterVariable(&sv_logsecret);
	Cvar_RegisterVariable(&sv_stats);
	Cvar_RegisterVariable(&developer);
	Cvar_RegisterVariable(&deathmatch);
	Cvar_RegisterVariable(&coop);
	Cvar_RegisterVariable(&pausable);
	Cvar_RegisterVariable(&skill);

	SV_SetMaxclients();
}
示例#17
0
文件: view.c 项目: DrBeef/QuakeGVR
/*
=============
V_Init
=============
*/
void V_Init (void)
{
	Cmd_AddCommand ("v_cshift", V_cshift_f, "sets tint color of view");
	Cmd_AddCommand ("bf", V_BonusFlash_f, "briefly flashes a bright color tint on view (used when items are picked up); optionally takes R G B [A [alphafade]] arguments to specify how the flash looks");
	Cmd_AddCommand ("centerview", V_StartPitchDrift, "gradually recenter view (stop looking up/down)");

	Cvar_RegisterVariable (&v_centermove);
	Cvar_RegisterVariable (&v_centerspeed);

	Cvar_RegisterVariable (&v_iyaw_cycle);
	Cvar_RegisterVariable (&v_iroll_cycle);
	Cvar_RegisterVariable (&v_ipitch_cycle);
	Cvar_RegisterVariable (&v_iyaw_level);
	Cvar_RegisterVariable (&v_iroll_level);
	Cvar_RegisterVariable (&v_ipitch_level);

	Cvar_RegisterVariable (&v_idlescale);
	Cvar_RegisterVariable (&crosshair);

	Cvar_RegisterVariable (&cl_rollspeed);
	Cvar_RegisterVariable (&cl_rollangle);
	Cvar_RegisterVariable (&cl_bob);
	Cvar_RegisterVariable (&cl_bobcycle);
	Cvar_RegisterVariable (&cl_bobup);
	Cvar_RegisterVariable (&cl_bob2);
	Cvar_RegisterVariable (&cl_bob2cycle);
	Cvar_RegisterVariable (&cl_bob2smooth);
	Cvar_RegisterVariable (&cl_bobfall);
	Cvar_RegisterVariable (&cl_bobfallcycle);
	Cvar_RegisterVariable (&cl_bobfallminspeed);
	Cvar_RegisterVariable (&cl_bobmodel);
	Cvar_RegisterVariable (&cl_bobmodel_side);
	Cvar_RegisterVariable (&cl_bobmodel_up);
	Cvar_RegisterVariable (&cl_bobmodel_speed);

	Cvar_RegisterVariable (&cl_weaponrecoil);

	Cvar_RegisterVariable (&cl_leanmodel);
	Cvar_RegisterVariable (&cl_leanmodel_side_speed);
	Cvar_RegisterVariable (&cl_leanmodel_side_limit);
	Cvar_RegisterVariable (&cl_leanmodel_side_highpass1);
	Cvar_RegisterVariable (&cl_leanmodel_side_lowpass);
	Cvar_RegisterVariable (&cl_leanmodel_side_highpass);
	Cvar_RegisterVariable (&cl_leanmodel_up_speed);
	Cvar_RegisterVariable (&cl_leanmodel_up_limit);
	Cvar_RegisterVariable (&cl_leanmodel_up_highpass1);
	Cvar_RegisterVariable (&cl_leanmodel_up_lowpass);
	Cvar_RegisterVariable (&cl_leanmodel_up_highpass);

	Cvar_RegisterVariable (&cl_followmodel);
	Cvar_RegisterVariable (&cl_followmodel_side_speed);
	Cvar_RegisterVariable (&cl_followmodel_side_limit);
	Cvar_RegisterVariable (&cl_followmodel_side_highpass1);
	Cvar_RegisterVariable (&cl_followmodel_side_lowpass);
	Cvar_RegisterVariable (&cl_followmodel_side_highpass);
	Cvar_RegisterVariable (&cl_followmodel_up_speed);
	Cvar_RegisterVariable (&cl_followmodel_up_limit);
	Cvar_RegisterVariable (&cl_followmodel_up_highpass1);
	Cvar_RegisterVariable (&cl_followmodel_up_lowpass);
	Cvar_RegisterVariable (&cl_followmodel_up_highpass);

	Cvar_RegisterVariable (&cl_viewmodel_scale);

	Cvar_RegisterVariable (&v_kicktime);
	Cvar_RegisterVariable (&v_kickroll);
	Cvar_RegisterVariable (&v_kickpitch);

	Cvar_RegisterVariable (&cl_stairsmoothspeed);
	
	Cvar_RegisterVariable (&cl_smoothviewheight);

	Cvar_RegisterVariable (&chase_back);
	Cvar_RegisterVariable (&chase_up);
	Cvar_RegisterVariable (&chase_active);
	Cvar_RegisterVariable (&chase_overhead);
	Cvar_RegisterVariable (&chase_pitchangle);
	Cvar_RegisterVariable (&chase_stevie);

	Cvar_RegisterVariable (&v_deathtilt);
	Cvar_RegisterVariable (&v_deathtiltangle);
}
void SCR_Init (void)
{
	Cvar_RegisterVariable (&default_fov, CL_Default_fov_f);
	Cvar_RegisterVariable (&scr_fov, CL_Fov_f);

	Cvar_RegisterVariable (&scr_viewsize, NULL);
	Cvar_RegisterVariable (&scr_conspeed, NULL);
	Cvar_RegisterVariable (&scr_showram, NULL);
	Cvar_RegisterVariable (&scr_showturtle, NULL);
	Cvar_RegisterVariable (&scr_showpause, NULL);
	Cvar_RegisterVariable (&scr_centertime, NULL);
	Cvar_RegisterVariable (&scr_printspeed, NULL);

#ifdef GLQUAKE
	Cvar_RegisterVariable (&gl_triplebuffer, NULL);
#endif

	Cvar_RegisterVariable (&pq_drawfps, NULL); // JPG - draw frames per second
	Cvar_RegisterVariable (&show_speed, NULL); // Baker 3.67

// register our commands

	Cmd_AddCommand ("screenshot",SCR_ScreenShot_f);
	Cmd_AddCommand ("sizeup",SCR_SizeUp_f);
	Cmd_AddCommand ("sizedown",SCR_SizeDown_f);

	scr_ram = Draw_PicFromWad ("ram");
	scr_net = Draw_PicFromWad ("net");
	scr_turtle = Draw_PicFromWad ("turtle");

#ifdef SUPPORTS_AVI_CAPTURE
	Movie_Init ();
#endif

	scr_initialized = true;
}
示例#19
0
/*
================
S_Init
================
*/
void S_Init (void)
{
	int i;

	if (snd_initialized)
	{
		Con_Printf("Sound is already initialized\n");
		return;
	}

	Cvar_RegisterVariable(&nosound);
	Cvar_RegisterVariable(&sfxvolume);
	Cvar_RegisterVariable(&precache);
	Cvar_RegisterVariable(&loadas8bit);
	Cvar_RegisterVariable(&bgmvolume);
	Cvar_RegisterVariable(&ambient_level);
	Cvar_RegisterVariable(&ambient_fade);
	Cvar_RegisterVariable(&snd_noextraupdate);
	Cvar_RegisterVariable(&snd_show);
	Cvar_RegisterVariable(&_snd_mixahead);
	Cvar_RegisterVariable(&sndspeed);
	Cvar_RegisterVariable(&snd_mixspeed);
	Cvar_RegisterVariable(&snd_filterquality);
	
	if (safemode || COM_CheckParm("-nosound"))
		return;

	Con_Printf("\nSound Initialization\n");

	Cmd_AddCommand("play", S_Play);
	Cmd_AddCommand("playvol", S_PlayVol);
	Cmd_AddCommand("stopsound", S_StopAllSoundsC);
	Cmd_AddCommand("soundlist", S_SoundList);
	Cmd_AddCommand("soundinfo", S_SoundInfo_f);

	i = COM_CheckParm("-sndspeed");
	if (i && i < com_argc-1)
	{
		Cvar_SetQuick (&sndspeed, com_argv[i+1]);
	}
	
	i = COM_CheckParm("-mixspeed");
	if (i && i < com_argc-1)
	{
		Cvar_SetQuick (&snd_mixspeed, com_argv[i+1]);
	}

	if (host_parms->memsize < 0x800000)
	{
		Cvar_SetQuick (&loadas8bit, "1");
		Con_Printf ("loading all sounds as 8bit\n");
	}

	Cvar_SetCallback(&sfxvolume, SND_Callback_sfxvolume);
	Cvar_SetCallback(&snd_filterquality, &SND_Callback_snd_filterquality);

	SND_InitScaletable ();

	known_sfx = (sfx_t *) Hunk_AllocName (MAX_SFX*sizeof(sfx_t), "sfx_t");
	num_sfx = 0;

	snd_initialized = true;

	S_Startup ();
	if (sound_started == 0)
		return;

// provides a tick sound until washed clean
//	if (shm->buffer)
//		shm->buffer[4] = shm->buffer[5] = 0x7f;	// force a pop for debugging

	ambient_sfx[AMBIENT_WATER] = S_PrecacheSound ("ambience/water1.wav");
	ambient_sfx[AMBIENT_SKY] = S_PrecacheSound ("ambience/wind2.wav");

	S_CodecInit ();

	S_StopAllSounds (true);
}
示例#20
0
void CL_InitCam(void)
{
	Cvar_RegisterVariable (&cl_hightrack);
//	Cvar_RegisterVariable (&cl_camera_maxpitch);
//	Cvar_RegisterVariable (&cl_camera_maxyaw);
}
示例#21
0
/*
=================
CL_Init
=================
*/
void
CL_Init(void)
{
    SZ_Alloc(&cls.message, 1024);

    CL_InitInput();
    CL_InitTEnts();

//
// register our commands
//
    Cvar_RegisterVariable(&cl_name);
    Cvar_RegisterVariable(&cl_color);
    Cvar_RegisterVariable(&cl_upspeed);
    Cvar_RegisterVariable(&cl_forwardspeed);
    Cvar_RegisterVariable(&cl_backspeed);
    Cvar_RegisterVariable(&cl_sidespeed);
    Cvar_RegisterVariable(&cl_movespeedkey);
    Cvar_RegisterVariable(&cl_yawspeed);
    Cvar_RegisterVariable(&cl_pitchspeed);
    Cvar_RegisterVariable(&cl_anglespeedkey);
    Cvar_RegisterVariable(&cl_shownet);
    Cvar_RegisterVariable(&cl_nolerp);
    Cvar_RegisterVariable(&lookspring);
    Cvar_RegisterVariable(&lookstrafe);
    Cvar_RegisterVariable(&sensitivity);

    Cvar_RegisterVariable(&m_pitch);
    Cvar_RegisterVariable(&m_yaw);
    Cvar_RegisterVariable(&m_forward);
    Cvar_RegisterVariable(&m_side);

//      Cvar_RegisterVariable (&cl_autofire);

    Cmd_AddCommand("entities", CL_PrintEntities_f);
    Cmd_AddCommand("disconnect", CL_Disconnect_f);
    Cmd_AddCommand("record", CL_Record_f);
    Cmd_AddCommand("stop", CL_Stop_f);
    Cmd_AddCommand("playdemo", CL_PlayDemo_f);
    Cmd_SetCompletion("playdemo", CL_Demo_Arg_f);
    Cmd_AddCommand("timedemo", CL_TimeDemo_f);
    Cmd_SetCompletion("timedemo", CL_Demo_Arg_f);

    Cmd_AddCommand("mcache", Mod_Print);
}
示例#22
0
/*
==============
CL_InitPrediction
==============
*/
void CL_InitPrediction (void)
{
	Cvar_RegisterVariable (&cl_pushlatency);
	Cvar_RegisterVariable (&cl_nopred);
}
示例#23
0
文件: host.c 项目: odnarb/manquake
/*
=======================
Host_InitLocal
======================
*/
void Host_InitLocal (void)
{
	Host_InitCommands ();

	Cvar_RegisterVariable (&host_framerate);
	Cvar_RegisterVariable (&sys_ticrate);
	Cvar_RegisterVariable (&serverprofile);
	Cvar_RegisterVariable (&fraglimit);
	Cvar_RegisterVariable (&timelimit);
	Cvar_RegisterVariable (&teamplay);
	Cvar_RegisterVariable (&samelevel);
	Cvar_RegisterVariable (&noexit);
	Cvar_RegisterVariable (&skill);
	Cvar_RegisterVariable (&developer);
	Cvar_RegisterVariable (&deathmatch);
	Cvar_RegisterVariable (&coop);
	Cvar_RegisterVariable (&pausable);
	Cvar_RegisterVariable (&temp1);
	Cvar_RegisterVariable (&proquake);				// JPG - added this so QuakeC can find it
	Cvar_RegisterVariable (&pq_spam_rate);			// JPG - spam protection
	Cvar_RegisterVariable (&pq_spam_grace);			// JPG - spam protection
	Cvar_RegisterVariable (&pq_tempmute);			// JPG 3.20 - temporary muting
	Cvar_RegisterVariable (&pq_showedict);			// JPG 3.11 - feature request from Slot Zero
	Cvar_RegisterVariable (&pq_dequake);			// JPG 1.05 - translate dedicated console output to plain text
	Cvar_RegisterVariable (&pq_maxfps);				// JPG 1.05
	Cvar_RegisterVariable (&pq_logbinds);			// JPG 3.20 - log player binds
	Cvar_RegisterVariable (&pq_mute_spam_client);	// Slot Zero 3.50-2  Mute spamming client.
	Cvar_RegisterVariable (&pq_ipmask);				// Slot Zero 3.50-2  IP masking.
	Cvar_RegisterVariable (&mod_protocol);			// Slot Zero 3.50-2  RQ Support.

	Host_FindMaxClients ();
	Host_InitDeQuake();	// JPG 1.05 - initialize dequake array
}
示例#24
0
文件: cvar.c 项目: odnarb/manquake
/*
=============
Cvar_Init

These aren't actually used for anything but I left them
intact because some mods might use them.
=============
*/
void Cvar_Init (void)
{
	// from view.c
	Cvar_RegisterVariable (&lcd_x);
	Cvar_RegisterVariable (&lcd_yaw);
	Cvar_RegisterVariable (&v_centermove);
	Cvar_RegisterVariable (&v_centerspeed);
	Cvar_RegisterVariable (&v_iyaw_cycle);
	Cvar_RegisterVariable (&v_iroll_cycle);
	Cvar_RegisterVariable (&v_ipitch_cycle);
	Cvar_RegisterVariable (&v_iyaw_level);
	Cvar_RegisterVariable (&v_iroll_level);
	Cvar_RegisterVariable (&v_ipitch_level);
	Cvar_RegisterVariable (&v_idlescale);
	Cvar_RegisterVariable (&crosshair);
	Cvar_RegisterVariable (&cl_crossx);
	Cvar_RegisterVariable (&cl_crossy);
	Cvar_RegisterVariable (&gl_cshiftpercent);
	Cvar_RegisterVariable (&scr_ofsx);
	Cvar_RegisterVariable (&scr_ofsy);
	Cvar_RegisterVariable (&scr_ofsz);
	Cvar_RegisterVariable (&cl_rollspeed);
	Cvar_RegisterVariable (&cl_rollangle);
	Cvar_RegisterVariable (&cl_bob);
	Cvar_RegisterVariable (&cl_bobcycle);
	Cvar_RegisterVariable (&cl_bobup);
	Cvar_RegisterVariable (&v_kicktime);
	Cvar_RegisterVariable (&v_kickroll);
	Cvar_RegisterVariable (&v_kickpitch);
	Cvar_RegisterVariable (&v_gamma);
	Cvar_RegisterVariable (&pq_waterblend);
	Cvar_RegisterVariable (&pq_quadblend);
	Cvar_RegisterVariable (&pq_pentblend);
	Cvar_RegisterVariable (&pq_ringblend);
	Cvar_RegisterVariable (&pq_suitblend);
	Cvar_RegisterVariable (&r_polyblend);

	// from console.c
	Cvar_RegisterVariable (&con_notifytime);
	Cvar_RegisterVariable (&pq_confilter);
	Cvar_RegisterVariable (&pq_timestamp);
	Cvar_RegisterVariable (&pq_removecr);

	// for chat messages
	Cvar_RegisterVariable (&cl_name);
}
示例#25
0
文件: net_main.c 项目: MP2E/tyrquake
/*
 * ====================
 * NET_Init
 * ====================
 */
void
NET_Init(void)
{
    int i, num_inited;
    int controlSocket;
    qsocket_t *s;

    i = COM_CheckParm("-port");
    if (!i)
	i = COM_CheckParm("-udpport");

    if (i) {
	if (i < com_argc - 1)
	    DEFAULTnet_hostport = Q_atoi(com_argv[i + 1]);
	else
	    Sys_Error("%s: you must specify a number after -port", __func__);
    }
    net_hostport = DEFAULTnet_hostport;

    if (COM_CheckParm("-listen") || cls.state == ca_dedicated)
	listening = true;
    net_numsockets = svs.maxclientslimit;
    if (cls.state != ca_dedicated)
	net_numsockets++;

    SetNetTime();

    for (i = 0; i < net_numsockets; i++) {
	s = (qsocket_t *)Hunk_AllocName(sizeof(qsocket_t), "qsocket");
	s->next = net_freeSockets;
	net_freeSockets = s;
	s->disconnected = true;
    }

    /* allocate space for network message buffer */
    SZ_Alloc(&net_message, NET_MAXMESSAGE);

    Cvar_RegisterVariable(&net_messagetimeout);
    Cvar_RegisterVariable(&hostname);

    Cmd_AddCommand("slist", NET_Slist_f);
    Cmd_AddCommand("listen", NET_Listen_f);
    Cmd_AddCommand("maxplayers", MaxPlayers_f);
    Cmd_AddCommand("port", NET_Port_f);

    /* initialize all the drivers */
    num_inited = 0;
    for (i = 0; i < net_numdrivers; i++) {
	net_driver = &net_drivers[i];
	controlSocket = net_driver->Init();
	if (controlSocket == -1)
	    continue;
	num_inited++;
	net_driver->initialized = true;
	net_driver->controlSock = controlSocket;
	if (listening)
	    net_driver->Listen(true);
    }

    if (num_inited == 0 && cls.state == ca_dedicated)
	Sys_Error("Network not available!");

    if (*my_tcpip_address)
	Con_DPrintf("TCP/IP address %s\n", my_tcpip_address);
}
示例#26
0
static void Host_InitLocal (void)
{
	Cmd_AddCommand("saveconfig", Host_SaveConfig_f, "save settings to config.cfg (or a specified filename) immediately (also automatic when quitting)");
	Cmd_AddCommand("loadconfig", Host_LoadConfig_f, "reset everything and reload configs");

	Cvar_RegisterVariable (&cl_maxphysicsframesperserverframe);
	Cvar_RegisterVariable (&host_framerate);
	Cvar_RegisterVariable (&host_speeds);
	Cvar_RegisterVariable (&host_maxwait);
	Cvar_RegisterVariable (&cl_minfps);
	Cvar_RegisterVariable (&cl_minfps_fade);
	Cvar_RegisterVariable (&cl_minfps_qualitymax);
	Cvar_RegisterVariable (&cl_minfps_qualitymin);
	Cvar_RegisterVariable (&cl_minfps_qualitystepmax);
	Cvar_RegisterVariable (&cl_minfps_qualityhysteresis);
	Cvar_RegisterVariable (&cl_minfps_qualitymultiply);
	Cvar_RegisterVariable (&cl_minfps_force);
	Cvar_RegisterVariable (&cl_maxfps);
	Cvar_RegisterVariable (&cl_maxfps_alwayssleep);
	Cvar_RegisterVariable (&cl_maxidlefps);

	Cvar_RegisterVariable (&sys_first_run);

	Cvar_RegisterVariable (&developer);
	Cvar_RegisterVariable (&developer_extra);
	Cvar_RegisterVariable (&developer_insane);
	Cvar_RegisterVariable (&developer_loadfile);
	Cvar_RegisterVariable (&developer_loading);
	Cvar_RegisterVariable (&developer_entityparsing);

	Cvar_RegisterVariable (&timestamps);
	Cvar_RegisterVariable (&timeformat);

	Cvar_RegisterVariable (&sv_writepicture_quality);
	Cvar_RegisterVariable (&r_texture_jpeg_fastpicmip);
}
示例#27
0
/*
===================
VID_Init
===================
*/
void VID_Init (unsigned char *palette)
{
	int		width, height, i, temp;
	SDL_Rect	**enumlist;
	const char	*read_vars[] = {
				"vid_config_fscr",
				"vid_config_swx",
				"vid_config_swy" };
#define num_readvars	( sizeof(read_vars)/sizeof(read_vars[0]) )

	temp = scr_disabled_for_loading;
	scr_disabled_for_loading = true;

	Cvar_RegisterVariable (&vid_config_fscr);
	Cvar_RegisterVariable (&vid_config_swy);
	Cvar_RegisterVariable (&vid_config_swx);
	Cvar_RegisterVariable (&vid_config_gly);
	Cvar_RegisterVariable (&vid_config_glx);
	Cvar_RegisterVariable (&vid_mode);
	Cvar_RegisterVariable (&_enable_mouse);
	Cvar_RegisterVariable (&vid_showload);

	Cmd_AddCommand ("vid_showinfo", VID_ShowInfo_f);
	Cmd_AddCommand ("vid_listmodes", VID_ListModes_f);
	Cmd_AddCommand ("vid_nummodes", VID_NumModes_f);
	Cmd_AddCommand ("vid_restart", VID_Restart_f);

	// init sdl
	// the first check is actually unnecessary
	if ( (SDL_WasInit(SDL_INIT_VIDEO)) == 0 )
	{
		if (SDL_Init(SDL_INIT_VIDEO) < 0)
			Sys_Error("VID: Couldn't load SDL: %s", SDL_GetError());
	}

	// this will contain the "best bpp" for the current display
	// make sure to re-retrieve it if you ever re-init sdl_video
	vid_info = SDL_GetVideoInfo();

	// retrieve the list of fullscreen modes
	enumlist = SDL_ListModes(NULL, SDL_SWSURFACE|SDL_HWPALETTE|SDL_FULLSCREEN);
	// prepare the modelists, find the actual modenum for vid_default
	VID_PrepareModes(enumlist);

	// set vid_mode to our safe default first
	Cvar_SetValue ("vid_mode", vid_default);

	// perform an early read of config.cfg
	CFG_ReadCvars (read_vars, num_readvars);

	// windowed mode is default
	// see if the user wants fullscreen
	if (COM_CheckParm("-fullscreen") || COM_CheckParm("-f"))
	{
		Cvar_SetValue("vid_config_fscr", 1);
	}
	else if (COM_CheckParm("-window") || COM_CheckParm("-w"))
	{
		Cvar_SetValue("vid_config_fscr", 0);
	}

	if (vid_config_fscr.integer && !num_fmodes) // FIXME: see below, as well
		Sys_Error ("No fullscreen modes available at this color depth");

	width = vid_config_swx.integer;
	height = vid_config_swy.integer;

	// user is always right ...
	i = COM_CheckParm("-width");
	if (i && i < com_argc-1)
	{	// FIXME: this part doesn't know about a disaster case
		// like we aren't reported any fullscreen modes.
		width = atoi(com_argv[i+1]);

		i = COM_CheckParm("-height");
		if (i && i < com_argc-1)
			height = atoi(com_argv[i+1]);
		else	// proceed with 4/3 ratio
			height = 3 * width / 4;
	}

	// user requested a mode either from the config or from the
	// command line
	// scan existing modes to see if this is already available
	// if not, add this as the last "valid" video mode and set
	// vid_mode to it only if it doesn't go beyond vid_maxwidth
	i = 0;
	while (i < *nummodes)
	{
		if (modelist[i].width == width && modelist[i].height == height)
			break;
		i++;
	}
	if (i < *nummodes)
	{
		Cvar_SetValue ("vid_mode", i);
	}
	else if ( (width <= vid_maxwidth && width >= MIN_WIDTH &&
		   height <= vid_maxheight && height >= MIN_HEIGHT) ||
		  COM_CheckParm("-force") )
	{
		modelist[*nummodes].width = width;
		modelist[*nummodes].height = height;
		modelist[*nummodes].halfscreen = 0;
		modelist[*nummodes].fullscreen = 1;
		modelist[*nummodes].bpp = 8;
		q_snprintf (modelist[*nummodes].modedesc, MAX_DESC, "%d x %d (user mode)", width, height);
		Cvar_SetValue ("vid_mode", *nummodes);
		(*nummodes)++;
	}
	else
	{
		Con_SafePrintf ("ignoring invalid -width and/or -height arguments\n");
	}

	vid.maxwarpwidth = WARP_WIDTH;
	vid.maxwarpheight = WARP_HEIGHT;
	vid.colormap = host_colormap;
	vid.fullbright = 256 - LittleLong (*((int *)vid.colormap + 2048));

	i = VID_SetMode(vid_mode.integer, palette);
	if ( !i )
	{
		if (vid_mode.integer == vid_default)
			Sys_Error ("Couldn't set video mode: %s", SDL_GetError());

		// just one more try before dying
		Con_SafePrintf ("Couldn't set video mode %d\n"
				"Trying the default mode\n", vid_mode.integer);
		//Cvar_SetValue("vid_config_fscr", 0);
		Cvar_SetValue ("vid_mode", vid_default);
		i = VID_SetMode(vid_default, palette);
		if ( !i )
			Sys_Error ("Couldn't set video mode: %s", SDL_GetError());
	}

	// lock the early-read cvars until Host_Init is finished
	for (i = 0; i < (int)num_readvars; i++)
		Cvar_LockVar (read_vars[i]);

	scr_disabled_for_loading = temp;
	vid_initialized = true;

	vid_menudrawfn = VID_MenuDraw;
	vid_menukeyfn = VID_MenuKey;
}
示例#28
0
/*
===============
PR_Init
===============
*/
void PR_Init (void)
{
	Cmd_AddCommand ("edict", ED_PrintEdict_f);
	Cmd_AddCommand ("edicts", ED_PrintEdicts);
	Cmd_AddCommand ("edictcount", ED_Count);
	Cmd_AddCommand ("profile", PR_Profile_f);
	Cvar_RegisterVariable (&nomonsters);
	Cvar_RegisterVariable (&gamecfg);
	Cvar_RegisterVariable (&scratch1);
	Cvar_RegisterVariable (&scratch2);
	Cvar_RegisterVariable (&scratch3);
	Cvar_RegisterVariable (&scratch4);
	Cvar_RegisterVariable (&savedgamecfg);
	Cvar_RegisterVariable (&saved1);
	Cvar_RegisterVariable (&saved2);
	Cvar_RegisterVariable (&saved3);
	Cvar_RegisterVariable (&saved4);
}
示例#29
0
/* <d49ce> ../engine/net_ws.c:2315 */
void NET_Init(void)
{
#ifdef HOOK_ENGINE
	Cmd_AddCommand("maxplayers", (xcommand_t)GetOriginalFuncAddrOrDefault("MaxPlayers_f", (void *)MaxPlayers_f));
#else
	Cmd_AddCommand("maxplayers", MaxPlayers_f);
#endif // HOOK_ENGINE

	Cvar_RegisterVariable(&net_address);
	Cvar_RegisterVariable(&ipname);
	Cvar_RegisterVariable(&iphostport);
	Cvar_RegisterVariable(&hostport);
	Cvar_RegisterVariable(&defport);
	Cvar_RegisterVariable(&ip_clientport);
	Cvar_RegisterVariable(&clientport);
	Cvar_RegisterVariable(&clockwindow);
	Cvar_RegisterVariable(&multicastport);
#ifdef _WIN32
	Cvar_RegisterVariable(&ipx_hostport);
	Cvar_RegisterVariable(&ipx_clientport);
#endif // _WIN32
	Cvar_RegisterVariable(&fakelag);
	Cvar_RegisterVariable(&fakeloss);
	Cvar_RegisterVariable(&net_graph);
	Cvar_RegisterVariable(&net_graphwidth);
	Cvar_RegisterVariable(&net_scale);
	Cvar_RegisterVariable(&net_graphpos);

	if (COM_CheckParm("-netthread"))
		use_thread = 1;

	if (COM_CheckParm("-netsleep"))
		net_sleepforever = 0;

#ifdef _WIN32
	if (COM_CheckParm("-noipx"))
		noipx = TRUE;
#endif // _WIN32

	if (COM_CheckParm("-noip"))
		noip = TRUE;

	int port = COM_CheckParm("-port");
	if (port)
		Cvar_SetValue("hostport", atof(com_argv[port + 1]));
	
	int clockwindow_ = COM_CheckParm("-clockwindow");
	if (clockwindow_)
		Cvar_SetValue("clockwindow", atof(com_argv[clockwindow_ + 1]));
	
	net_message.data = (byte *)&net_message_buffer;
	net_message.maxsize = sizeof(net_message_buffer);
	net_message.flags = 0;
	net_message.buffername = "net_message";

	in_message.data = (byte *)&in_message_buf;
	in_message.maxsize = sizeof(in_message_buf);
	in_message.flags = 0;
	in_message.buffername = "in_message";

	for (int i = 0; i < 3; i++)
	{
		g_pLagData[i].pPrev = &g_pLagData[i];
		g_pLagData[i].pNext = &g_pLagData[i];
	}

	NET_AllocateQueues();
	Con_DPrintf("Base networking initialized.\n");
}
示例#30
0
/*
================
VID_Init
================
*/
void    VID_Init (unsigned char *palette)
{
	Cvar_RegisterVariable (&vid_mode);
	Cvar_RegisterVariable (&vid_wait);
	Cvar_RegisterVariable (&vid_nopageflip);
	Cvar_RegisterVariable (&_vid_wait_override);
	Cvar_RegisterVariable (&_vid_default_mode);
	Cvar_RegisterVariable (&_vid_default_mode_win);
	Cvar_RegisterVariable (&vid_config_x);
	Cvar_RegisterVariable (&vid_config_y);
	Cvar_RegisterVariable (&vid_stretch_by_2);
	Cvar_RegisterVariable (&_windowed_mouse);
	Cvar_RegisterVariable (&vid_fullscreen_mode);
	Cvar_RegisterVariable (&vid_windowed_mode);
	Cvar_RegisterVariable (&block_switch);

	Cmd_AddCommand ("vid_testmode", VID_TestMode_f);
	Cmd_AddCommand ("vid_nummodes", VID_NumModes_f);
	Cmd_AddCommand ("vid_describecurrentmode", VID_DescribeCurrentMode_f);
	Cmd_AddCommand ("vid_describemode", VID_DescribeMode_f);
	Cmd_AddCommand ("vid_describemodes", VID_DescribeModes_f);

// set up the mode list; note that later inits link in their modes ahead of
// earlier ones, so the standard VGA modes are always first in the list. This
// is important because mode 0 must always be VGA mode 0x13
	if (!COM_CheckParm ("-stdvid"))
		VID_InitExtra ();
	VGA_Init ();

	vid_testingmode = 0;

	vid_modenum = vid_mode.value;

	VID_SetMode (vid_modenum, palette);

	vid_realmode = vid_modenum;
	
	vid_menudrawfn = VID_MenuDraw;
	vid_menukeyfn = VID_MenuKey;
}