void CDAudio_Update(void)
{
#if defined(__FreeBSD__)
struct ioc_read_subchannel subchnl;
struct cd_sub_channel_info data;
#endif
#if defined(__linux__)
struct cdrom_subchnl subchnl;
#endif
static time_t lastchk;
if (cdfile == -1 || !enabled)
return;
if (cd_volume && cd_volume->value != cdvolume)
{
if (cdvolume)
{
Cvar_SetValue ("cd_volume", 0.0);
cdvolume = cd_volume->value;
CDAudio_Pause ();
}
else
{
Cvar_SetValue ("cd_volume", 1.0);
cdvolume = cd_volume->value;
CDAudio_Resume ();
}
}
if (playing && lastchk < time(NULL)) {
lastchk = time(NULL) + 2; //two seconds between chks
#if defined(__FreeBSD__)
subchnl.address_format = CD_MSF_FORMAT;
subchnl.data_format = CD_CURRENT_POSITION;
subchnl.data_len = sizeof(data);
subchnl.track = playTrack;
subchnl.data = &data;
if (ioctl(cdfile, CDIOCREADSUBCHANNEL, &subchnl) == -1 ) {
Com_DPrintf("ioctl cdiocreadsubchannel failed\n");
playing = false;
return;
}
if (subchnl.data->header.audio_status != CD_AS_PLAY_IN_PROGRESS &&
subchnl.data->header.audio_status != CD_AS_PLAY_PAUSED) {
playing = false;
if (playLooping)
CDAudio_Play(playTrack, true);
}
#endif
#if defined(__linux__)
subchnl.cdsc_format = CDROM_MSF;
if (ioctl(cdfile, CDROMSUBCHNL, &subchnl) == -1 ) {
Com_DPrintf("ioctl cdromsubchnl failed\n");
playing = false;
return;
}
if (subchnl.cdsc_audiostatus != CDROM_AUDIO_PLAY &&
subchnl.cdsc_audiostatus != CDROM_AUDIO_PAUSED) {
playing = false;
if (playLooping)
CDAudio_Play(playTrack, true);
}
#endif
}
}
static int CDAudio_GetAudioDiskInfo(void)
{
#if defined(__FreeBSD__)
struct ioc_toc_header tochdr;
#endif
#ifdef __linux__
struct cdrom_tochdr tochdr;
#endif
cdValid = false;
#if defined(__FreeBSD__)
if ( ioctl(cdfile, CDIOREADTOCHEADER, &tochdr) == -1 )
{
Com_DPrintf("ioctl cdioreadtocheader failed\n");
#endif
#ifdef __linux__
if ( ioctl(cdfile, CDROMREADTOCHDR, &tochdr) == -1 )
{
Com_DPrintf("ioctl cdromreadtochdr failed\n");
#endif
return -1;
}
#if defined(__FreeBSD__)
if (tochdr.starting_track < 1)
#endif
#ifdef __linux__
if (tochdr.cdth_trk0 < 1)
#endif
{
Com_DPrintf("CDAudio: no music tracks\n");
return -1;
}
cdValid = true;
#if defined(__FreeBSD__)
maxTrack = tochdr.ending_track;
#endif
#ifdef __linux__
maxTrack = tochdr.cdth_trk1;
#endif
return 0;
}
void CDAudio_Play(int track, qboolean looping)
{
#if defined(__FreeBSD__)
struct ioc_read_toc_entry entry;
struct cd_toc_entry toc_buffer;
struct ioc_play_track ti;
#endif
#if defined(__linux__)
struct cdrom_tocentry entry;
struct cdrom_ti ti;
#endif
if (cdfile == -1 || !enabled)
return;
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
return;
}
track = remap[track];
if (track < 1 || track > maxTrack)
{
Com_DPrintf("CDAudio: Bad track number %u.\n", track);
return;
}
#if defined(__FreeBSD__)
#define CDROM_DATA_TRACK 4
bzero((char *)&toc_buffer, sizeof(toc_buffer));
entry.data_len = sizeof(toc_buffer);
entry.data = &toc_buffer;
// don't try to play a non-audio track
entry.starting_track = track;
entry.address_format = CD_MSF_FORMAT;
if ( ioctl(cdfile, CDIOREADTOCENTRYS, &entry) == -1 )
{
Com_DPrintf("ioctl cdromreadtocentry failed\n");
return;
}
if (toc_buffer.control == CDROM_DATA_TRACK)
#endif
#if defined(__linux__)
// don't try to play a non-audio track
entry.cdte_track = track;
entry.cdte_format = CDROM_LBA;
if ( ioctl(cdfile, CDROMREADTOCENTRY, &entry) == -1 )
{
Com_DPrintf("ioctl cdromreadtocentry failed\n");
return;
}
if (entry.cdte_ctrl == CDROM_DATA_TRACK)
#endif
{
Com_Printf("CDAudio: track %i is not audio\n", track);
return;
}
if (playing)
{
if (playTrack == track)
return;
CDAudio_Stop();
}
#if defined(__FreeBSD__)
ti.start_track = track;
ti.end_track = track;
ti.start_index = 1;
ti.end_index = 99;
#endif
#if defined(__linux__)
ti.cdti_trk0 = track;
ti.cdti_trk1 = track;
ti.cdti_ind0 = 0;
ti.cdti_ind1 = 0;
#endif
#if defined(__FreeBSD__)
if ( ioctl(cdfile, CDIOCPLAYTRACKS, &ti) == -1 )
#endif
#if defined(__linux__)
if ( ioctl(cdfile, CDROMPLAYTRKIND, &ti) == -1 )
#endif
{
Com_DPrintf("ioctl cdromplaytrkind failed\n");
return;
}
#if defined(__FreeBSD__)
if ( ioctl(cdfile, CDIOCRESUME) == -1 )
#endif
#if defined(__linux__)
if ( ioctl(cdfile, CDROMRESUME) == -1 )
#endif
Com_DPrintf("ioctl cdromresume failed\n");
playLooping = looping;
playTrack = track;
playing = true;
if (cd_volume->value == 0.0)
CDAudio_Pause ();
}
void CDAudio_RandomPlay(void)
{
int track, i = 0, free_tracks = 0, remap_track;
float f;
byte* track_bools;
#if defined(__FreeBSD__)
struct ioc_read_toc_entry entry;
struct cd_toc_entry toc_buffer;
struct ioc_play_track ti;
#endif
#if defined(__linux__)
struct cdrom_tocentry entry;
struct cdrom_ti ti;
#endif
if (cdfile == -1 || !enabled)
return;
track_bools = (byte*)malloc(maxTrack * sizeof(byte));
if (track_bools == 0)
return;
//create array of available audio tracknumbers
for (; i < maxTrack; i++)
{
#if defined(__FreeBSD__)
#define CDROM_DATA_TRACK 4
bzero((char *)&toc_buffer, sizeof(toc_buffer));
entry.data_len = sizeof(toc_buffer);
entry.data = &toc_buffer;
entry.starting_track = remap[i];
entry.address_format = CD_LBA_FORMAT;
if ( ioctl(cdfile, CDIOREADTOCENTRYS, &entry) == -1 )
{
track_bools[i] = 0;
}
else
track_bools[i] = (entry.data->control != CDROM_DATA_TRACK);
#endif
#if defined(__linux__)
entry.cdte_track = remap[i];
entry.cdte_format = CDROM_LBA;
if ( ioctl(cdfile, CDROMREADTOCENTRY, &entry) == -1 )
{
track_bools[i] = 0;
}
else
track_bools[i] = (entry.cdte_ctrl != CDROM_DATA_TRACK);
#endif
free_tracks += track_bools[i];
}
if (!free_tracks)
{
Com_DPrintf("CDAudio_RandomPlay: Unable to find and play a random audio track, insert an audio cd please");
goto free_end;
}
//choose random audio track
do
{
do
{
f = ((float)rand()) / ((float)RAND_MAX + 1.0);
track = (int)(maxTrack * f);
}
while(!track_bools[track]);
remap_track = remap[track];
if (playing)
{
if (playTrack == remap_track)
{
goto free_end;
}
CDAudio_Stop();
}
#if defined(__FreeBSD__)
#define CDROMPLAYTRKIND 0x5304
ti.start_track = remap_track;
ti.end_track = remap_track;
ti.start_index = 0;
ti.end_index = 0;
#endif
#if defined(__linux__)
ti.cdti_trk0 = remap_track;
ti.cdti_trk1 = remap_track;
ti.cdti_ind0 = 0;
ti.cdti_ind1 = 0;
#endif
if ( ioctl(cdfile, CDROMPLAYTRKIND, &ti) == -1 )
{
track_bools[track] = 0;
free_tracks--;
}
else
{
playLooping = true;
playTrack = remap_track;
playing = true;
break;
}
}
while (free_tracks > 0);
free_end:
free((void*)track_bools);
}
static void CD_f (void)
{
const char *command;
int ret, n;
if (Cmd_Argc() < 2)
{
Con_Printf("commands:");
Con_Printf("on, off, reset, remap, \n");
Con_Printf("play, stop, loop, pause, resume\n");
Con_Printf("eject, info\n");
return;
}
command = Cmd_Argv (1);
if (q_strcasecmp(command, "on") == 0)
{
enabled = true;
return;
}
if (q_strcasecmp(command, "off") == 0)
{
if (playing)
CDAudio_Stop();
enabled = false;
return;
}
if (q_strcasecmp(command, "reset") == 0)
{
enabled = true;
if (playing)
CDAudio_Stop();
for (n = 0; n < 100; n++)
remap[n] = n;
CDAudio_GetAudioDiskInfo();
return;
}
if (q_strcasecmp(command, "remap") == 0)
{
ret = Cmd_Argc () - 2;
if (ret <= 0)
{
for (n = 1; n < 100; n++)
if (remap[n] != n)
Con_Printf (" %u -> %u\n", n, remap[n]);
return;
}
for (n = 1; n <= ret; n++)
remap[n] = atoi(Cmd_Argv (n + 1));
return;
}
if (!cdValid)
{
CDAudio_GetAudioDiskInfo ();
if (!cdValid)
{
Con_Printf("No CD in player.\n");
return;
}
}
if (q_strcasecmp(command, "play") == 0)
{
CDAudio_Play((byte)atoi(Cmd_Argv (2)), false);
return;
}
if (q_strcasecmp(command, "loop") == 0)
{
CDAudio_Play((byte)atoi(Cmd_Argv (2)), true);
return;
}
if (q_strcasecmp(command, "stop") == 0)
{
CDAudio_Stop();
return;
}
if (q_strcasecmp(command, "pause") == 0)
{
CDAudio_Pause();
return;
}
if (q_strcasecmp(command, "resume") == 0)
{
CDAudio_Resume();
return;
}
if (q_strcasecmp(command, "eject") == 0)
{
if (playing)
CDAudio_Stop();
CDAudio_Eject();
cdValid = false;
return;
}
if (q_strcasecmp(command, "info") == 0)
{
int current_min, current_sec, current_frame;
int length_min, length_sec, length_frame;
Con_Printf ("%u tracks\n", cd_handle->numtracks);
if (playing)
Con_Printf ("Currently %s track %u\n", playLooping ? "looping" : "playing", playTrack);
else if (wasPlaying)
Con_Printf ("Paused %s track %u\n", playLooping ? "looping" : "playing", playTrack);
if (playing || wasPlaying)
{
SDL_CDStatus(cd_handle);
FRAMES_TO_MSF(cd_handle->cur_frame, ¤t_min, ¤t_sec, ¤t_frame);
FRAMES_TO_MSF(cd_handle->track[playTrack-1].length, &length_min, &length_sec, &length_frame);
Con_Printf ("Current position: %d:%02d.%02d (of %d:%02d.%02d)\n",
current_min, current_sec, current_frame * 60 / CD_FPS,
length_min, length_sec, length_frame * 60 / CD_FPS);
}
Con_Printf ("Volume is %f\n", bgmvolume.value);
return;
}
}
void CDAudio_Play(byte track, qboolean looping)
{
int len_m, len_s, len_f;
if (!cd_handle || !enabled)
return;
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
return;
}
track = remap[track];
if (track < 1 || track > cd_handle->numtracks)
{
Con_Printf ("%s: Bad track number %d.\n", __thisfunc__, track);
return;
}
if (cd_handle->track[track-1].type == SDL_DATA_TRACK)
{
Con_Printf ("%s: track %d is not audio\n", __thisfunc__, track);
return;
}
if (playing)
{
if (playTrack == track)
return;
CDAudio_Stop ();
}
if (SDL_CDPlay(cd_handle, cd_handle->track[track-1].offset, cd_handle->track[track-1].length) < 0)
{
// ok, check for status now
int cd_status = SDL_CDStatus(cd_handle);
if (cd_status > 0)
Con_Printf ("%s: Unable to play %d: %s\n", __thisfunc__, track, SDL_GetError ());
return;
}
playLooping = looping;
playTrack = track;
playing = true;
FRAMES_TO_MSF(cd_handle->track[track-1].length, &len_m, &len_s, &len_f);
endOfTrack = realtime + ((double)len_m * 60.0) + (double)len_s + (double)len_f / (double)CD_FPS;
/*
* Add the pregap for the next track. This means that disc-at-once CDs
* won't loop smoothly, but they wouldn't anyway so it doesn't really
* matter. SDL doesn't give us pregap information anyway, so you'll
* just have to live with it.
*/
endOfTrack += 2.0;
pausetime = -1.0;
if (!hw_vol_works && bgmvolume.value == 0.0)
CDAudio_Pause ();
}
void CDAudio_Play(byte track, qboolean looping)
{
int i, lf;
trackinfo_t* tnod;
int trackHdl;
int newTrackDataLength;
byte* newTrackData;
if (!enabled)
return;
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
return;
}
track = remap[track];
if (track < 1 || track > maxTrack)
{
Con_DPrintf("CDAudio: Bad track number %u.\n", track);
return;
}
i = track;
if(cd_nofirst.value)
i--;
if (playing)
{
if (playTrack == track)
return;
CDAudio_Stop();
}
lf = -1;
tnod = CDAudio_GetTrack(trackList, i - 1, &lf);
if(tnod == NULL)
{
Con_Printf("CDAudio: Can't locate track %i\n", track);
return;
}
newTrackDataLength = Sys_FileOpenRead(tnod->track, &trackHdl);
if(newTrackDataLength <= 0)
{
Con_Printf("CDAudio: Can't open track %i\n", track);
return;
};
if(trackData == NULL)
{
trackData = Sys_Malloc(newTrackDataLength, "CDAudio_Play");
trackDataSize = newTrackDataLength;
} else if(trackDataSize < newTrackDataLength)
{
newTrackData = realloc(trackData, newTrackDataLength);
if(newTrackData == NULL)
{
free(trackData);
trackData = Sys_Malloc(newTrackDataLength, "CDAudio_Play");
} else
{
trackData = newTrackData;
};
trackDataSize = newTrackDataLength;
};
trackDataLength = newTrackDataLength;
Sys_FileRead(trackHdl, trackData, trackDataLength);
Sys_FileClose(trackHdl);
if(PlayOgg(trackData, trackDataLength, 0, looping ? OGG_INFINITE_TIME : OGG_ONE_TIME))
{
Con_Printf("CDAudio: Can't play track %i\n", track);
return;
};
playLooping = looping;
playTrack = track;
playing = true;
//Con_Printf("Now playing: %s\n", tnod->track);
if (cdvolume == 0.0)
CDAudio_Pause ();
}
void CDAudio_Play(byte track, qboolean looping)
{
DWORD dwReturn;
MCI_PLAY_PARMS mciPlayParms;
MCI_STATUS_PARMS mciStatusParms;
if (!enabled)
{
return;
}
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
{
return;
}
}
track = remap[track];
if (track < 1 || track > maxTrack)
{
Con_DPrintf("CDAudio: Bad track number %u.\n", track);
return;
}
// don't try to play a non-audio track
mciStatusParms.dwItem = MCI_CDA_STATUS_TYPE_TRACK;
mciStatusParms.dwTrack = track;
dwReturn = mciSendCommand(wDeviceID, MCI_STATUS, MCI_STATUS_ITEM | MCI_TRACK | MCI_WAIT, (DWORD)(LPVOID) &mciStatusParms);
if (dwReturn)
{
Con_DPrintf("MCI_STATUS failed (%i)\n", dwReturn);
return;
}
if (mciStatusParms.dwReturn != MCI_CDA_TRACK_AUDIO)
{
Con_Printf("CDAudio: track %i is not audio\n", track);
return;
}
// get the length of the track to be played
mciStatusParms.dwItem = MCI_STATUS_LENGTH;
mciStatusParms.dwTrack = track;
dwReturn = mciSendCommand(wDeviceID, MCI_STATUS, MCI_STATUS_ITEM | MCI_TRACK | MCI_WAIT, (DWORD)(LPVOID) &mciStatusParms);
if (dwReturn)
{
Con_DPrintf("MCI_STATUS failed (%i)\n", dwReturn);
return;
}
if (playing)
{
if (playTrack == track)
{
return;
}
CDAudio_Stop();
}
mciPlayParms.dwFrom = MCI_MAKE_TMSF(track, 0, 0, 0);
mciPlayParms.dwTo = (mciStatusParms.dwReturn << 8) | track;
mciPlayParms.dwCallback = (DWORD)mainwindow;
dwReturn = mciSendCommand(wDeviceID, MCI_PLAY, MCI_NOTIFY | MCI_FROM | MCI_TO, (DWORD)(LPVOID) &mciPlayParms);
if (dwReturn)
{
Con_DPrintf("CDAudio: MCI_PLAY failed (%i)\n", dwReturn);
return;
}
playLooping = looping;
playTrack = track;
playing = true;
if (cdvolume == 0.0)
{
CDAudio_Pause();
}
}
static void CD_f (void)
{
const char *command;
#ifdef MAXTRACKS
int ret;
int n;
#endif
command = Cmd_Argv (1);
if (strcasecmp(command, "remap") != 0)
Host_StartVideo();
if (strcasecmp(command, "on") == 0)
{
enabled = true;
return;
}
if (strcasecmp(command, "off") == 0)
{
CDAudio_Stop();
enabled = false;
return;
}
if (strcasecmp(command, "reset") == 0)
{
enabled = true;
CDAudio_Stop();
#ifdef MAXTRACKS
for (n = 0; n < MAXTRACKS; n++)
*remap[n] = 0; // empty string, that is, unremapped
#endif
CDAudio_GetAudioDiskInfo();
return;
}
if (strcasecmp(command, "rescan") == 0)
{
CDAudio_Shutdown();
CDAudio_Startup();
return;
}
if (strcasecmp(command, "remap") == 0)
{
#ifdef MAXTRACKS
ret = Cmd_Argc() - 2;
if (ret <= 0)
{
for (n = 1; n < MAXTRACKS; n++)
if (*remap[n])
Con_Printf(" %u -> %s\n", n, remap[n]);
return;
}
for (n = 1; n <= ret; n++)
strlcpy(remap[n], Cmd_Argv (n+1), sizeof(*remap));
#endif
return;
}
if (strcasecmp(command, "close") == 0)
{
CDAudio_CloseDoor();
return;
}
if (strcasecmp(command, "play") == 0)
{
if (music_playlist_index.integer >= 0)
return;
CDAudio_Play_byName(Cmd_Argv (2), false, true, (Cmd_Argc() > 3) ? atof( Cmd_Argv(3) ) : 0);
return;
}
if (strcasecmp(command, "loop") == 0)
{
if (music_playlist_index.integer >= 0)
return;
CDAudio_Play_byName(Cmd_Argv (2), true, true, (Cmd_Argc() > 3) ? atof( Cmd_Argv(3) ) : 0);
return;
}
if (strcasecmp(command, "stop") == 0)
{
if (music_playlist_index.integer >= 0)
return;
CDAudio_Stop();
return;
}
if (strcasecmp(command, "pause") == 0)
{
if (music_playlist_index.integer >= 0)
return;
CDAudio_Pause();
return;
}
if (strcasecmp(command, "resume") == 0)
{
if (music_playlist_index.integer >= 0)
return;
CDAudio_Resume();
return;
}
if (strcasecmp(command, "eject") == 0)
{
if (faketrack == -1)
CDAudio_Stop();
CDAudio_Eject();
cdValid = false;
return;
}
if (strcasecmp(command, "info") == 0)
{
CDAudio_GetAudioDiskInfo ();
if (cdValid)
Con_Printf("%u tracks on CD.\n", maxTrack);
else
Con_Print ("No CD in player.\n");
if (cdPlaying)
Con_Printf("Currently %s track %u\n", cdPlayLooping ? "looping" : "playing", cdPlayTrack);
else if (wasPlaying)
Con_Printf("Paused %s track %u\n", cdPlayLooping ? "looping" : "playing", cdPlayTrack);
if (cdvolume >= 0)
Con_Printf("Volume is %f\n", cdvolume);
else
Con_Printf("Can't get CD volume\n");
return;
}
Con_Printf("CD commands:\n");
Con_Printf("cd on - enables CD audio system\n");
Con_Printf("cd off - stops and disables CD audio system\n");
Con_Printf("cd reset - resets CD audio system (clears track remapping and re-reads disc information)\n");
Con_Printf("cd rescan - rescans disks in drives (to use another disc)\n");
Con_Printf("cd remap <remap1> [remap2] [remap3] [...] - chooses (possibly emulated) CD tracks to play when a map asks for a particular track, this has many uses\n");
Con_Printf("cd close - closes CD tray\n");
Con_Printf("cd eject - stops playing music and opens CD tray to allow you to change disc\n");
Con_Printf("cd play <tracknumber> <startposition> - plays selected track in remapping table\n");
Con_Printf("cd loop <tracknumber> <startposition> - plays and repeats selected track in remapping table\n");
Con_Printf("cd stop - stops playing current CD track\n");
Con_Printf("cd pause - pauses CD playback\n");
Con_Printf("cd resume - unpauses CD playback\n");
Con_Printf("cd info - prints basic disc information (number of tracks, currently playing track, volume level)\n");
}
void CL_ParseServerMessage (void)
{
int cmd;
int i;
//
// if recording demos, copy the message out
//
if (cl_shownet.value == 1)
Con_Printf ("%i ",net_message.cursize);
else if (cl_shownet.value == 2)
Con_Printf ("------------------\n");
cl.onground = false; // unless the server says otherwise
//
// parse the message
//
MSG_BeginReading ();
while (1)
{
if (msg_badread)
Host_Error ("CL_ParseServerMessage: Bad server message");
cmd = MSG_ReadByte ();
if (cmd == -1)
{
SHOWNET("END OF MESSAGE");
return; // end of message
}
// if the high bit of the command byte is set, it is a fast update
if (cmd & 128)
{
SHOWNET("fast update");
CL_ParseUpdate (cmd&127);
continue;
}
SHOWNET(svc_strings[cmd]);
// other commands
switch (cmd)
{
default:
Host_Error ("CL_ParseServerMessage: Illegible server message\n");
break;
case svc_nop:
// Con_Printf ("svc_nop\n");
break;
case svc_time:
cl.mtime[1] = cl.mtime[0];
cl.mtime[0] = MSG_ReadFloat ();
break;
case svc_clientdata:
i = MSG_ReadShort ();
CL_ParseClientdata (i);
break;
case svc_version:
i = MSG_ReadLong ();
if (i != PROTOCOL_VERSION)
Host_Error ("CL_ParseServerMessage: Server is protocol %i instead of %i\n", i, PROTOCOL_VERSION);
break;
case svc_disconnect:
Host_EndGame ("Server disconnected\n");
case svc_print:
Con_Printf ("%s", MSG_ReadString ());
break;
case svc_centerprint:
SCR_CenterPrint (MSG_ReadString ());
break;
case svc_stufftext:
Cbuf_AddText (MSG_ReadString ());
break;
case svc_damage:
V_ParseDamage ();
break;
case svc_serverinfo:
CL_ParseServerInfo ();
vid.recalc_refdef = true; // leave intermission full screen
break;
case svc_setangle:
for (i=0 ; i<3 ; i++)
cl.viewangles[i] = MSG_ReadAngle ();
break;
case svc_setview:
cl.viewentity = MSG_ReadShort ();
break;
case svc_lightstyle:
i = MSG_ReadByte ();
if (i >= MAX_LIGHTSTYLES)
Sys_Error ("svc_lightstyle > MAX_LIGHTSTYLES");
Q_strcpy (cl_lightstyle[i].map, MSG_ReadString());
cl_lightstyle[i].length = Q_strlen(cl_lightstyle[i].map);
break;
case svc_sound:
CL_ParseStartSoundPacket();
break;
case svc_stopsound:
i = MSG_ReadShort();
S_StopSound(i>>3, i&7);
break;
case svc_updatename:
Sbar_Changed ();
i = MSG_ReadByte ();
if (i >= cl.maxclients)
Host_Error ("CL_ParseServerMessage: svc_updatename > MAX_SCOREBOARD");
strcpy (cl.scores[i].name, MSG_ReadString ());
break;
case svc_updatefrags:
Sbar_Changed ();
i = MSG_ReadByte ();
if (i >= cl.maxclients)
Host_Error ("CL_ParseServerMessage: svc_updatefrags > MAX_SCOREBOARD");
cl.scores[i].frags = MSG_ReadShort ();
break;
case svc_updatecolors:
Sbar_Changed ();
i = MSG_ReadByte ();
if (i >= cl.maxclients)
Host_Error ("CL_ParseServerMessage: svc_updatecolors > MAX_SCOREBOARD");
cl.scores[i].colors = MSG_ReadByte ();
CL_NewTranslation (i);
break;
case svc_particle:
R_ParseParticleEffect ();
break;
case svc_spawnbaseline:
i = MSG_ReadShort ();
// must use CL_EntityNum() to force cl.num_entities up
CL_ParseBaseline (CL_EntityNum(i));
break;
case svc_spawnstatic:
CL_ParseStatic ();
break;
case svc_temp_entity:
CL_ParseTEnt ();
break;
case svc_setpause:
{
cl.paused = MSG_ReadByte ();
if (cl.paused)
{
CDAudio_Pause ();
#ifdef _WIN32
VID_HandlePause (true);
#endif
}
else
{
CDAudio_Resume ();
#ifdef _WIN32
VID_HandlePause (false);
#endif
}
}
break;
case svc_signonnum:
i = MSG_ReadByte ();
if (i <= cls.signon)
Host_Error ("Received signon %i when at %i", i, cls.signon);
cls.signon = i;
CL_SignonReply ();
break;
case svc_killedmonster:
cl.stats[STAT_MONSTERS]++;
break;
case svc_foundsecret:
cl.stats[STAT_SECRETS]++;
break;
case svc_updatestat:
i = MSG_ReadByte ();
if (i < 0 || i >= MAX_CL_STATS)
Sys_Error ("svc_updatestat: %i is invalid", i);
cl.stats[i] = MSG_ReadLong ();;
break;
case svc_spawnstaticsound:
CL_ParseStaticSound ();
break;
case svc_cdtrack:
cl.cdtrack = MSG_ReadByte ();
cl.looptrack = MSG_ReadByte ();
if ( (cls.demoplayback || cls.demorecording) && (cls.forcetrack != -1) )
CDAudio_Play ((byte)cls.forcetrack, true);
else
CDAudio_Play ((byte)cl.cdtrack, true);
break;
case svc_intermission:
cl.intermission = 1;
cl.completed_time = (int) cl.time;
vid.recalc_refdef = true; // go to full screen
break;
case svc_finale:
cl.intermission = 2;
cl.completed_time = (int) cl.time;
vid.recalc_refdef = true; // go to full screen
SCR_CenterPrint (MSG_ReadString ());
break;
case svc_cutscene:
cl.intermission = 3;
cl.completed_time = (int) cl.time;
vid.recalc_refdef = true; // go to full screen
SCR_CenterPrint (MSG_ReadString ());
break;
case svc_sellscreen:
Cmd_ExecuteString2 ("help", src_command);
break;
}
}
}
static void CD_f()
{
char *command;
int cdstate;
if(Cmd_Argc() < 2) return;
command = Cmd_Argv(1);
if(!Q_strcasecmp(command,"on"))
{
enabled = true;
}
if(!Q_strcasecmp(command,"off"))
{
if(!cd_id) return;
cdstate = SDL_CDStatus(cd_id);
if((cdstate == CD_PLAYING) || (cdstate == CD_PAUSED))
CDAudio_Stop();
enabled = false;
return;
}
if(!Q_strcasecmp(command,"play"))
{
CDAudio_Play((byte)atoi(Cmd_Argv(2)),false);
return;
}
if(!Q_strcasecmp(command,"loop"))
{
CDAudio_Play((byte)atoi(Cmd_Argv(2)),true);
return;
}
if(!Q_strcasecmp(command,"stop"))
{
CDAudio_Stop();
return;
}
if(!Q_strcasecmp(command,"pause"))
{
CDAudio_Pause();
return;
}
if(!Q_strcasecmp(command,"resume"))
{
CDAudio_Resume();
return;
}
if(!Q_strcasecmp(command,"eject"))
{
CDAudio_Eject();
return;
}
if(!Q_strcasecmp(command,"info"))
{
if(!cd_id) return;
cdstate = SDL_CDStatus(cd_id);
Com_Printf("%d tracks\n",cd_id->numtracks);
if(cdstate == CD_PLAYING)
Com_Printf("Currently %s track %d\n",
playLooping ? "looping" : "playing",
cd_id->cur_track+1);
else
if(cdstate == CD_PAUSED)
Com_Printf("Paused %s track %d\n",
playLooping ? "looping" : "playing",
cd_id->cur_track+1);
return;
}
}
void CDAudio_Play_byName (const char *trackname, qboolean looping, qboolean tryreal, float startposition)
{
unsigned int track;
sfx_t* sfx;
char filename[MAX_QPATH];
Host_StartVideo();
if (!enabled)
return;
if(tryreal && strspn(trackname, "0123456789") == strlen(trackname))
{
track = (unsigned char) atoi(trackname);
#ifdef MAXTRACKS
if(track > 0 && track < MAXTRACKS)
if(*remap[track])
{
if(strspn(remap[track], "0123456789") == strlen(remap[track]))
{
trackname = remap[track];
}
else
{
// ignore remappings to fake tracks if we're going to play a real track
switch(cdaudio.integer)
{
case 0: // we never access CD
case 1: // we have a replacement
trackname = remap[track];
break;
case 2: // we only use fake track replacement if CD track is invalid
CDAudio_GetAudioDiskInfo();
if(!cdValid || track > maxTrack)
trackname = remap[track];
break;
case 3: // we always play from CD - ignore this remapping then
case 4: // we randomize anyway
break;
}
}
}
#endif
}
if(tryreal && strspn(trackname, "0123456789") == strlen(trackname))
{
track = (unsigned char) atoi(trackname);
if (track < 1)
{
Con_DPrintf("CDAudio: Bad track number %u.\n", track);
return;
}
}
else
track = 0;
// div0: I assume this code was intentionally there. Maybe turn it into a cvar?
if (cdPlaying && cdPlayTrack == track && faketrack == -1)
return;
CDAudio_Stop ();
if(track >= 1)
{
if(cdaudio.integer == 3) // only play real CD tracks at all
{
if(CDAudio_Play_real(track, looping, true))
goto success;
return;
}
if(cdaudio.integer == 2) // prefer real CD track over fake
{
if(CDAudio_Play_real(track, looping, false))
goto success;
}
}
if(cdaudio.integer == 4) // only play real CD tracks, EVEN instead of fake tracks!
{
if(CDAudio_Play_real(track, looping, false))
goto success;
if(cdValid && maxTrack > 0)
{
track = 1 + (rand() % maxTrack);
if(CDAudio_Play_real(track, looping, true))
goto success;
}
else
{
Con_DPrint ("No CD in player.\n");
}
return;
}
// Try playing a fake track (sound file) first
if(track >= 1)
{
dpsnprintf(filename, sizeof(filename), "sound/cdtracks/track%03u.wav", track);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/cdtracks/track%03u.ogg", track);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "music/track%03u.ogg", track);// added by motorsep
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "music/cdtracks/track%03u.ogg", track);// added by motorsep
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/cdtracks/track%02u.wav", track);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/cdtracks/track%02u.ogg", track);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "music/track%02u.ogg", track);// added by motorsep
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "music/cdtracks/track%02u.ogg", track);// added by motorsep
}
else
{
dpsnprintf(filename, sizeof(filename), "%s", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "%s.wav", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "%s.ogg", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/%s", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/%s.wav", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/%s.ogg", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/cdtracks/%s", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/cdtracks/%s.wav", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/cdtracks/%s.ogg", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "music/%s.ogg", trackname); // added by motorsep
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "music/cdtracks/%s.ogg", trackname); // added by motorsep
}
if (FS_FileExists(filename) && (sfx = S_PrecacheSound (filename, false, false)))
{
faketrack = S_StartSound_StartPosition_Flags (-1, 0, sfx, vec3_origin, cdvolume, 0, startposition, (looping ? CHANNELFLAG_FORCELOOP : 0) | CHANNELFLAG_FULLVOLUME | CHANNELFLAG_LOCALSOUND);
if (faketrack != -1)
{
if(track >= 1)
{
if(cdaudio.integer != 0) // we don't need these messages if only fake tracks can be played anyway
Con_DPrintf ("Fake CD track %u playing...\n", track);
}
else
Con_DPrintf ("BGM track %s playing...\n", trackname);
}
}
// If we can't play a fake CD track, try the real one
if (faketrack == -1)
{
if(cdaudio.integer == 0 || track < 1)
{
Con_Print("Could not load BGM track.\n");
return;
}
else
{
if(!CDAudio_Play_real(track, looping, true))
return;
}
}
success:
cdPlayLooping = looping;
cdPlayTrack = track;
cdPlaying = true;
if (cdvolume == 0.0 || bgmvolume.value == 0)
CDAudio_Pause ();
}
void CDAudio_Play(byte track, qboolean looping)
{
struct ioc_read_toc_entry entry;
struct cd_toc_entry toc_buffer;
struct ioc_play_track ti;
if (cdfile == -1 || !enabled)
return;
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
return;
}
track = remap[track];
if (track < 1 || track > maxTrack)
{
Con_DPrintf("CDAudio: Bad track number %u.\n", track);
return;
}
// don't try to play a non-audio track
# define CDROM_DATA_TRACK 4
memset((char *)&toc_buffer, 0, sizeof(toc_buffer));
entry.data_len = sizeof(toc_buffer);
entry.data = &toc_buffer;
entry.starting_track = track;
entry.address_format = CD_MSF_FORMAT;
if ( ioctl(cdfile, CDIOREADTOCENTRYS, &entry) == -1 )
{
IOCTL_FAILURE(CDIOREADTOCENTRYS);
return;
}
if (toc_buffer.control & CDROM_DATA_TRACK)
{
Con_Printf("CDAudio: track %i is not audio\n", track);
return;
}
if (playing)
{
if (playTrack == track)
return;
CDAudio_Stop();
}
ti.start_track = track;
ti.end_track = track;
ti.start_index = 1;
ti.end_index = 99;
if ( ioctl(cdfile, CDIOCPLAYTRACKS, &ti) == -1 )
{
IOCTL_FAILURE(CDIOCPLAYTRACKS);
return;
}
if ( ioctl(cdfile, CDIOCRESUME) == -1 )
IOCTL_FAILURE(CDIOCRESUME);
playLooping = looping;
playTrack = track;
playing = true;
if (!hw_vol_works && bgmvolume.value == 0.0)
CDAudio_Pause ();
}
/*
=====================
CL_ParseServerMessage
=====================
*/
void CL_ParseServerMessage (void)
{
int cmd;
int i, j, k;
int EntityCount = 0;
int EntitySize = 0;
int before;
static double lasttime;
static qboolean packet_loss = false;
entity_t *ent;
short RemovePlace, OrigPlace, NewPlace, AddedIndex;
int sc1, sc2;
byte test;
float compangles[2][3];
vec3_t deltaangles;
//
// if recording demos, copy the message out
//
if (net_message.cursize > LastServerMessageSize)
{
LastServerMessageSize = net_message.cursize;
}
if (cl_shownet.integer == 1)
{
Con_Printf ("Time: %2.2f Pck: %i ", realtime - lasttime, net_message.cursize);
lasttime = realtime;
}
else if (cl_shownet.integer == 2)
Con_Printf ("------------------\n");
cl.onground = false; // unless the server says otherwise
//
// parse the message
//
MSG_BeginReading ();
while (1)
{
if (msg_badread)
Host_Error ("%s: Bad server message", __thisfunc__);
cmd = MSG_ReadByte ();
if (cmd == -1)
{
if (cl_shownet.integer == 1)
Con_Printf ("Ent: %i (%i bytes)",EntityCount,EntitySize);
SHOWNET("END OF MESSAGE");
return; // end of message
}
// if the high bit of the command byte is set, it is a fast update
if (cmd & 128)
{
before = msg_readcount;
SHOWNET("fast update");
if (packet_loss)
CL_ParseUpdate2 (cmd&127);
else
CL_ParseUpdate (cmd&127);
EntityCount++;
EntitySize += msg_readcount - before + 1;
continue;
}
if (cmd < NUM_SVC_STRINGS) // else, it'll hit the illegible message below
{
SHOWNET(svc_strings[cmd]);
}
// other commands
switch (cmd)
{
default:
// CL_DumpPacket ();
Host_Error ("%s: Illegible server message %d", __thisfunc__, cmd);
break;
case svc_nop:
// Con_Printf ("svc_nop\n");
break;
case svc_time:
cl.mtime[1] = cl.mtime[0];
cl.mtime[0] = MSG_ReadFloat ();
break;
case svc_clientdata:
i = MSG_ReadShort ();
CL_ParseClientdata (i);
break;
case svc_version:
cl_protocol = MSG_ReadLong ();
switch (cl_protocol)
{
case PROTOCOL_RAVEN_111:
case PROTOCOL_RAVEN_112:
case PROTOCOL_UQE_113:
Con_Printf ("Server using protocol %i\n", cl_protocol);
break;
default:
Host_Error ("%s: Server is protocol %i instead of %i or %i",
__thisfunc__, cl_protocol,
PROTOCOL_RAVEN_112, PROTOCOL_UQE_113);
}
break;
case svc_disconnect:
Host_EndGame ("Server disconnected\n");
break;
case svc_print:
if (intro_playing)
MSG_ReadString ();
else
Con_Printf ("%s", MSG_ReadString ());
break;
case svc_centerprint:
SCR_CenterPrint (MSG_ReadString ());
break;
case svc_stufftext:
stufftext_frame = host_framecount; // allow full frame update
// on stuff messages. Pa3PyX
Cbuf_AddText (MSG_ReadString ());
break;
case svc_damage:
V_ParseDamage ();
break;
case svc_serverinfo:
CL_ParseServerInfo ();
vid.recalc_refdef = true; // leave intermission full screen
break;
case svc_setangle:
for (i = 0; i < 3; i++)
cl.viewangles[i] = MSG_ReadAngle ();
break;
case svc_setangle_interpolate:
compangles[0][0] = MSG_ReadAngle();
compangles[0][1] = MSG_ReadAngle();
compangles[0][2] = MSG_ReadAngle();
for (i = 0; i < 3; i++)
{
compangles[1][i] = cl.viewangles[i];
for (j = 0; j < 2; j++)
{//standardize both old and new angles to +-180
if (compangles[j][i] >= 360)
compangles[j][i] -= 360*((int)(compangles[j][i]/360));
else if (compangles[j][i] <= 360)
compangles[j][i] += 360*(1+(int)(-compangles[j][i]/360));
if (compangles[j][i] > 180)
compangles[j][i] = -360 + compangles[j][i];
else if (compangles[j][i] < -180)
compangles[j][i] = 360 + compangles[j][i];
}
//get delta
deltaangles[i] = compangles[0][i] - compangles[1][i];
//cap delta to <=180,>=-180
if (deltaangles[i] > 180)
deltaangles[i] += -360;
else if (deltaangles[i] < -180)
deltaangles[i] += 360;
//add the delta
cl.viewangles[i]+=(deltaangles[i]/8);//8 step interpolation
//cap newangles to +-180
if (cl.viewangles[i] >= 360)
cl.viewangles[i] -= 360*((int)(cl.viewangles[i]/360));
else if (cl.viewangles[i] <= 360)
cl.viewangles[i] += 360*(1+(int)(-cl.viewangles[i]/360));
if (cl.viewangles[i] > 180)
cl.viewangles[i] += -360;
else if (cl.viewangles[i] < -180)
cl.viewangles[i] += 360;
}
break;
case svc_setview:
cl.viewentity = MSG_ReadShort ();
break;
case svc_lightstyle:
i = MSG_ReadByte ();
if (i >= MAX_LIGHTSTYLES)
Sys_Error ("svc_lightstyle > MAX_LIGHTSTYLES");
q_strlcpy (cl_lightstyle[i].map, MSG_ReadString(), MAX_STYLESTRING);
cl_lightstyle[i].length = strlen(cl_lightstyle[i].map);
break;
case svc_sound:
CL_ParseStartSoundPacket();
break;
case svc_sound_update_pos:
{//FIXME: put a field on the entity that lists the channels
//it should update when it moves- if a certain flag
//is on the ent, this update_channels field could
//be set automatically by each sound and stopSound
//called for this ent?
vec3_t pos;
int channel, ent_num;
channel = MSG_ReadShort ();
ent_num = channel >> 3;
channel &= 7;
if (ent_num > MAX_EDICTS)
Host_Error ("svc_sound_update_pos: ent = %i", ent_num);
for (i = 0; i < 3; i++)
pos[i] = MSG_ReadCoord ();
S_UpdateSoundPos (ent_num, channel, pos);
}
break;
case svc_stopsound:
i = MSG_ReadShort();
S_StopSound(i>>3, i&7);
break;
case svc_updatename:
Sbar_Changed();
i = MSG_ReadByte ();
if (i >= cl.maxclients)
Host_Error ("%s: svc_updatename > MAX_CLIENTS", __thisfunc__);
q_strlcpy (cl.scores[i].name, MSG_ReadString(), MAX_SCOREBOARDNAME);
break;
case svc_updateclass:
Sbar_Changed();
i = MSG_ReadByte ();
if (i >= cl.maxclients)
Host_Error ("%s: svc_updateclass > MAX_CLIENTS", __thisfunc__);
cl.scores[i].playerclass = (float)MSG_ReadByte();
CL_NewTranslation(i); // update the color
break;
case svc_updatefrags:
Sbar_Changed();
i = MSG_ReadByte ();
if (i >= cl.maxclients)
Host_Error ("%s: svc_updatefrags > MAX_CLIENTS", __thisfunc__);
cl.scores[i].frags = MSG_ReadShort ();
break;
case svc_update_kingofhill:
sv_kingofhill = MSG_ReadShort() - 1;
break;
case svc_updatecolors:
Sbar_Changed();
i = MSG_ReadByte ();
if (i >= cl.maxclients)
Host_Error ("%s: svc_updatecolors > MAX_CLIENTS", __thisfunc__);
cl.scores[i].colors = MSG_ReadByte ();
CL_NewTranslation (i);
break;
case svc_particle:
R_ParseParticleEffect ();
break;
case svc_particle2:
R_ParseParticleEffect2 ();
break;
case svc_particle3:
R_ParseParticleEffect3 ();
break;
case svc_particle4:
R_ParseParticleEffect4 ();
break;
case svc_spawnbaseline:
i = MSG_ReadShort ();
// must use CL_EntityNum() to force cl.num_entities up
CL_ParseBaseline (CL_EntityNum(i));
break;
case svc_spawnstatic:
CL_ParseStatic ();
break;
case svc_raineffect:
CL_ParseRainEffect();
break;
case svc_temp_entity:
CL_ParseTEnt ();
break;
case svc_setpause:
cl.paused = MSG_ReadByte ();
if (cl.paused)
{
CDAudio_Pause ();
VID_HandlePause (true);
}
else
{
CDAudio_Resume ();
VID_HandlePause (false);
}
break;
case svc_signonnum:
i = MSG_ReadByte ();
if (i <= cls.signon)
Host_Error ("Received signon %i when at %i", i, cls.signon);
cls.signon = i;
CL_SignonReply ();
break;
case svc_killedmonster:
cl.stats[STAT_MONSTERS]++;
break;
case svc_foundsecret:
cl.stats[STAT_SECRETS]++;
break;
case svc_updatestat:
i = MSG_ReadByte ();
if (i < 0 || i >= MAX_CL_STATS)
Sys_Error ("svc_updatestat: %i is invalid", i);
cl.stats[i] = MSG_ReadLong ();
break;
case svc_spawnstaticsound:
CL_ParseStaticSound ();
break;
case svc_cdtrack:
cl.cdtrack = MSG_ReadByte ();
cl.looptrack = MSG_ReadByte ();
if (q_strcasecmp(bgmtype.string,"cd") == 0)
{
if ( (cls.demoplayback || cls.demorecording) && (cls.forcetrack != -1) )
CDAudio_Play ((byte)cls.forcetrack, true);
else
CDAudio_Play ((byte)cl.cdtrack, true);
}
else
CDAudio_Stop();
break;
case svc_midi_name:
q_strlcpy (cl.midi_name, MSG_ReadString(), sizeof(cl.midi_name));
if (q_strcasecmp(bgmtype.string,"midi") == 0)
MIDI_Play(cl.midi_name);
else
MIDI_Stop();
break;
case svc_toggle_statbar:
break;
case svc_intermission:
cl.intermission = MSG_ReadByte();
if (oem.integer && cl.intermission == 1)
cl.intermission = 9;
// skip intermissions while recording demos in single
// player games, but stop recording at ending scenes.
// skip intermissions when playing demos.
if (cls.demorecording)
{
// 5: finale for the demo version
// 6, 7, 8: eidolon end-1 to end-3
// 9: finale for the bundle version
// 10: praevus ending
if (sv.active && svs.maxclients == 1 &&
(cl.intermission < 5 || cl.intermission > 10))
{
cl.intermission = 0;
demohack = true;
Cbuf_AddText("+attack\n"); // HACK !..
break;
}
CL_Stop_f ();
}
else if (cls.demoplayback)
{
cl.intermission = 0;
break;
}
cl.completed_time = cl.time;
vid.recalc_refdef = true; // go to full screen
break;
/* case svc_finale:
cl.intermission = 2;
cl.completed_time = cl.time;
vid.recalc_refdef = true; // go to full screen
SCR_CenterPrint (MSG_ReadString ());
break;
case svc_cutscene:
cl.intermission = 3;
cl.completed_time = cl.time;
vid.recalc_refdef = true; // go to full screen
SCR_CenterPrint (MSG_ReadString ());
break;
case svc_sellscreen:
Cmd_ExecuteString ("help", src_command);
break;
*/
case svc_set_view_flags:
cl.viewent.drawflags |= MSG_ReadByte();
break;
case svc_clear_view_flags:
cl.viewent.drawflags &= ~MSG_ReadByte();
break;
case svc_start_effect:
CL_ParseEffect();
break;
case svc_end_effect:
CL_EndEffect();
break;
case svc_plaque:
CL_Plaque();
break;
case svc_particle_explosion:
CL_ParticleExplosion();
break;
case svc_set_view_tint:
i = MSG_ReadByte();
cl.viewent.colorshade = i;
break;
case svc_reference:
packet_loss = false;
cl.last_frame = cl.current_frame;
cl.last_sequence = cl.current_sequence;
cl.current_frame = MSG_ReadByte();
cl.current_sequence = MSG_ReadByte();
if (cl.need_build == 2)
{
// Con_Printf("CL: NB2 CL(%d,%d) R(%d)\n", cl.current_sequence, cl.current_frame,cl.reference_frame);
cl.frames[0].count = cl.frames[1].count = cl.frames[2].count = 0;
cl.need_build = 1;
cl.reference_frame = cl.current_frame;
}
else if (cl.last_sequence != cl.current_sequence)
{
// Con_Printf("CL: Sequence CL(%d,%d) R(%d)\n", cl.current_sequence, cl.current_frame,cl.reference_frame);
if (cl.reference_frame >= 1 && cl.reference_frame <= MAX_FRAMES)
{
RemovePlace = OrigPlace = NewPlace = AddedIndex = 0;
for (i = 0; i < cl.num_entities; i++)
{
if (RemovePlace >= cl.NumToRemove || cl.RemoveList[RemovePlace] != i)
{
if (NewPlace < cl.frames[1].count &&
cl.frames[1].states[NewPlace].index == i)
{
cl.frames[2].states[AddedIndex] = cl.frames[1].states[NewPlace];
AddedIndex++;
cl.frames[2].count++;
}
else if (OrigPlace < cl.frames[0].count &&
cl.frames[0].states[OrigPlace].index == i)
{
cl.frames[2].states[AddedIndex] = cl.frames[0].states[OrigPlace];
AddedIndex++;
cl.frames[2].count++;
}
}
else
RemovePlace++;
if (cl.frames[0].states[OrigPlace].index == i)
OrigPlace++;
if (cl.frames[1].states[NewPlace].index == i)
NewPlace++;
}
cl.frames[0] = cl.frames[2];
}
cl.frames[1].count = cl.frames[2].count = 0;
cl.need_build = 1;
cl.reference_frame = cl.current_frame;
}
else
{
// Con_Printf("CL: Normal CL(%d,%d) R(%d)\n", cl.current_sequence, cl.current_frame,cl.reference_frame);
cl.need_build = 0;
}
for (i = 1, ent = cl_entities+1; i < cl.num_entities; i++, ent++)
{
ent->baseline.flags &= ~BE_ON;
}
for (i = 0; i < cl.frames[0].count; i++)
{
ent = CL_EntityNum (cl.frames[0].states[i].index);
ent->model = cl.model_precache[cl.frames[0].states[i].modelindex];
ent->baseline.flags |= BE_ON;
}
break;
case svc_clear_edicts:
j = MSG_ReadByte();
if (cl.need_build)
{
cl.NumToRemove = j;
}
for (i = 0; i < j; i++)
{
k = MSG_ReadShort();
if (cl.need_build)
cl.RemoveList[i] = k;
ent = CL_EntityNum (k);
ent->baseline.flags &= ~BE_ON;
}
break;
case svc_update_inv:
sc1 = sc2 = 0;
test = MSG_ReadByte();
if (test & 1)
sc1 |= ((int)MSG_ReadByte());
if (test & 2)
sc1 |= ((int)MSG_ReadByte())<<8;
if (test & 4)
sc1 |= ((int)MSG_ReadByte())<<16;
if (test & 8)
sc1 |= ((int)MSG_ReadByte())<<24;
if (test & 16)
sc2 |= ((int)MSG_ReadByte());
if (test & 32)
sc2 |= ((int)MSG_ReadByte())<<8;
if (test & 64)
sc2 |= ((int)MSG_ReadByte())<<16;
if (test & 128)
sc2 |= ((int)MSG_ReadByte())<<24;
if (sc1 & SC1_HEALTH)
cl.v.health = MSG_ReadShort();
if (sc1 & SC1_LEVEL)
cl.v.level = MSG_ReadByte();
if (sc1 & SC1_INTELLIGENCE)
cl.v.intelligence = MSG_ReadByte();
if (sc1 & SC1_WISDOM)
cl.v.wisdom = MSG_ReadByte();
if (sc1 & SC1_STRENGTH)
cl.v.strength = MSG_ReadByte();
if (sc1 & SC1_DEXTERITY)
cl.v.dexterity = MSG_ReadByte();
if (sc1 & SC1_WEAPON)
cl.v.weapon = MSG_ReadByte();
if (sc1 & SC1_BLUEMANA)
cl.v.bluemana = MSG_ReadByte();
if (sc1 & SC1_GREENMANA)
cl.v.greenmana = MSG_ReadByte();
if (sc1 & SC1_EXPERIENCE)
cl.v.experience = MSG_ReadLong();
if (sc1 & SC1_CNT_TORCH)
cl.v.cnt_torch = MSG_ReadByte();
if (sc1 & SC1_CNT_H_BOOST)
cl.v.cnt_h_boost = MSG_ReadByte();
if (sc1 & SC1_CNT_SH_BOOST)
cl.v.cnt_sh_boost = MSG_ReadByte();
if (sc1 & SC1_CNT_MANA_BOOST)
cl.v.cnt_mana_boost = MSG_ReadByte();
if (sc1 & SC1_CNT_TELEPORT)
cl.v.cnt_teleport = MSG_ReadByte();
if (sc1 & SC1_CNT_TOME)
cl.v.cnt_tome = MSG_ReadByte();
if (sc1 & SC1_CNT_SUMMON)
cl.v.cnt_summon = MSG_ReadByte();
if (sc1 & SC1_CNT_INVISIBILITY)
cl.v.cnt_invisibility = MSG_ReadByte();
if (sc1 & SC1_CNT_GLYPH)
cl.v.cnt_glyph = MSG_ReadByte();
if (sc1 & SC1_CNT_HASTE)
cl.v.cnt_haste = MSG_ReadByte();
if (sc1 & SC1_CNT_BLAST)
cl.v.cnt_blast = MSG_ReadByte();
if (sc1 & SC1_CNT_POLYMORPH)
cl.v.cnt_polymorph = MSG_ReadByte();
if (sc1 & SC1_CNT_FLIGHT)
cl.v.cnt_flight = MSG_ReadByte();
if (sc1 & SC1_CNT_CUBEOFFORCE)
cl.v.cnt_cubeofforce = MSG_ReadByte();
if (sc1 & SC1_CNT_INVINCIBILITY)
cl.v.cnt_invincibility = MSG_ReadByte();
if (sc1 & SC1_ARTIFACT_ACTIVE)
cl.v.artifact_active = MSG_ReadFloat();
if (sc1 & SC1_ARTIFACT_LOW)
cl.v.artifact_low = MSG_ReadFloat();
if (sc1 & SC1_MOVETYPE)
cl.v.movetype = MSG_ReadByte();
if (sc1 & SC1_CAMERAMODE)
cl.v.cameramode = MSG_ReadByte();
if (sc1 & SC1_HASTED)
cl.v.hasted = MSG_ReadFloat();
if (sc1 & SC1_INVENTORY)
cl.v.inventory = MSG_ReadByte();
if (sc1 & SC1_RINGS_ACTIVE)
cl.v.rings_active = MSG_ReadFloat();
if (sc2 & SC2_RINGS_LOW)
cl.v.rings_low = MSG_ReadFloat();
if (sc2 & SC2_AMULET)
cl.v.armor_amulet = MSG_ReadByte();
if (sc2 & SC2_BRACER)
cl.v.armor_bracer = MSG_ReadByte();
if (sc2 & SC2_BREASTPLATE)
cl.v.armor_breastplate = MSG_ReadByte();
if (sc2 & SC2_HELMET)
cl.v.armor_helmet = MSG_ReadByte();
if (sc2 & SC2_FLIGHT_T)
cl.v.ring_flight = MSG_ReadByte();
if (sc2 & SC2_WATER_T)
cl.v.ring_water = MSG_ReadByte();
if (sc2 & SC2_TURNING_T)
cl.v.ring_turning = MSG_ReadByte();
if (sc2 & SC2_REGEN_T)
cl.v.ring_regeneration = MSG_ReadByte();
if (sc2 & SC2_HASTE_T)
cl.v.haste_time = MSG_ReadFloat();
if (sc2 & SC2_TOME_T)
cl.v.tome_time = MSG_ReadFloat();
if (sc2 & SC2_PUZZLE1)
q_snprintf(cl.puzzle_pieces[0], sizeof(cl.puzzle_pieces[0]), "%.9s", MSG_ReadString());
if (sc2 & SC2_PUZZLE2)
q_snprintf(cl.puzzle_pieces[1], sizeof(cl.puzzle_pieces[0]), "%.9s", MSG_ReadString());
if (sc2 & SC2_PUZZLE3)
q_snprintf(cl.puzzle_pieces[2], sizeof(cl.puzzle_pieces[0]), "%.9s", MSG_ReadString());
if (sc2 & SC2_PUZZLE4)
q_snprintf(cl.puzzle_pieces[3], sizeof(cl.puzzle_pieces[0]), "%.9s", MSG_ReadString());
if (sc2 & SC2_PUZZLE5)
q_snprintf(cl.puzzle_pieces[4], sizeof(cl.puzzle_pieces[0]), "%.9s", MSG_ReadString());
if (sc2 & SC2_PUZZLE6)
q_snprintf(cl.puzzle_pieces[5], sizeof(cl.puzzle_pieces[0]), "%.9s", MSG_ReadString());
if (sc2 & SC2_PUZZLE7)
q_snprintf(cl.puzzle_pieces[6], sizeof(cl.puzzle_pieces[0]), "%.9s", MSG_ReadString());
if (sc2 & SC2_PUZZLE8)
q_snprintf(cl.puzzle_pieces[7], sizeof(cl.puzzle_pieces[0]), "%.9s", MSG_ReadString());
if (sc2 & SC2_MAXHEALTH)
cl.v.max_health = MSG_ReadShort();
if (sc2 & SC2_MAXMANA)
cl.v.max_mana = MSG_ReadByte();
if (sc2 & SC2_FLAGS)
cl.v.flags = MSG_ReadFloat();
// SC2_OBJ, SC2_OBJ2: mission pack objectives
// With protocol 18 (PROTOCOL_RAVEN_111), these
// bits get set somehow (?!): let's avoid them.
if (cl_protocol > PROTOCOL_RAVEN_111)
{
if (sc2 & SC2_OBJ)
cl.info_mask = MSG_ReadLong();
if (sc2 & SC2_OBJ2)
cl.info_mask2 = MSG_ReadLong();
}
if ((sc1 & SC1_STAT_BAR) || (sc2 & SC2_STAT_BAR))
Sbar_Changed();
if ((sc1 & SC1_INV) || (sc2 & SC2_INV))
SB_InvChanged();
break;
case svc_mod_name:
case svc_skybox:
MSG_ReadString();
Con_DPrintf ("Ignored server msg %d (%s)\n", cmd, svc_strings[cmd]);
break;
}
}
}
static void CD_f (void)
{
char *command;
int ret;
int n;
if (Cmd_Argc() < 2)
{
Con_Printf("CD parameters:\n on\n off\n reset\n remap\n eject\n close\n play\n loop\n pause\n resume\n stop\n info\n"); // Manoel Kasimier
return;
}
command = Cmd_Argv (1);
if (Q_strcasecmp(command, "on") == 0)
{
Cvar_SetValue("cd_enabled", 1); // Manoel Kasimier - CD player in menu
return;
}
if (Q_strcasecmp(command, "off") == 0)
{
if (playing)
CDAudio_Stop();
Cvar_SetValue("cd_enabled", 0); // Manoel Kasimier - CD player in menu
return;
}
if (Q_strcasecmp(command, "reset") == 0)
{
/* // Manoel Kasimier - Windows XP fix
if (playing)
CDAudio_Stop();
for (n = 0; n < 100; n++)
remap[n] = n;
CDAudio_GetAudioDiskInfo();
*/ // Manoel Kasimier - Windows XP fix - begin
CDAudio_Shutdown();
CDAudio_Init();
// Manoel Kasimier - Windows XP fix - end
return;
}
if (Q_strcasecmp(command, "remap") == 0)
{
ret = Cmd_Argc() - 2;
if (ret <= 0)
{
for (n = 1; n < 100; n++)
if (remap[n] != n)
Con_Printf(" %u -> %u\n", n, remap[n]);
return;
}
for (n = 1; n <= ret; n++)
remap[n] = Q_atoi(Cmd_Argv (n+1));
return;
}
// Manoel Kasimier - moved the "eject" command here so empty drives can be ejected
if (Q_strcasecmp(command, "eject") == 0)
{
if (playing)
CDAudio_Stop();
CDAudio_Eject();
cdValid = false;
maxTrack = 0; // Manoel Kasimier - CD player in menu
return;
}
if (Q_strcasecmp(command, "close") == 0)
{
CDAudio_CloseDoor();
Cbuf_AddText ("wait;cd reset\n", "cd reset"); // Manoel Kasimier - CD player in menu - auto-update CD status after closing drive door
return;
}
if (Q_strcasecmp(command, "info") == 0)
{
// Manoel Kasimier - begin
if (!maxTrack)
Con_Printf("No CD in player.\n");
else
{
Con_Printf("%u tracks\n", maxTrack);
if (!cdValid)
Con_Printf("No audio tracks on disc\n");
else // List valid tracks
{
Con_Printf("Audio tracks on disc:\n");
for (n=1; n<=99; n++)
if (audioTrack[n])
{
if (!audioTrack[n+1]) // end of sequence, or isolated track
Con_Printf(" %2i\n", n);
else if (!audioTrack[n-1]) // beginning of sequence
Con_Printf(" %2i -", n);
}
if (cd_enabled.value)
{
// Manoel Kasimier - end
if (playing)
Con_Printf("Currently %s track %u\n", playLooping ? "looping" : "playing", playTrack);
else if (wasPlaying)
Con_Printf("Paused %s track %u\n", playLooping ? "looping" : "playing", playTrack);
// Manoel Kasimier - begin
}
}
}
if (!cd_enabled.value)
Con_Printf("CD audio is off\n");
// Manoel Kasimier - end
Con_Printf("Volume is %.1f\n", cdvolume); // Manoel Kasimier - edited
return;
}
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
{
// Manoel Kasimier - begin
if (maxTrack)
Con_Printf("No audio tracks on disc\n");
else
// Manoel Kasimier - end
Con_Printf("No CD in player.\n");
return;
}
}
if (Q_strcasecmp(command, "play") == 0)
{
CDAudio_Play((byte)Q_atoi(Cmd_Argv (2)), false);
return;
}
if (Q_strcasecmp(command, "loop") == 0)
{
CDAudio_Play((byte)Q_atoi(Cmd_Argv (2)), true);
return;
}
if (Q_strcasecmp(command, "stop") == 0)
{
CDAudio_Stop();
return;
}
if (Q_strcasecmp(command, "pause") == 0)
{
CDAudio_Pause();
return;
}
if (Q_strcasecmp(command, "resume") == 0)
{
CDAudio_Resume();
return;
}
Con_Printf("CD parameters:\n on\n off\n reset\n remap\n eject\n close\n play\n loop\n pause\n resume\n stop\n info\n"); // Manoel Kasimier - absent/unrecognized parameter
}
void CLNQ_ParseServerMessage (void)
{
int cmd;
int i;
qbool message_with_datagram; // hack to fix glitches when receiving a packet
// without a datagram
nq_player_teleported = false; // OMG, it's a hack!
message_with_datagram = false;
cl_entframecount++;
if (cl_shownet.value == 1)
Com_Printf ("%i ", net_message.cursize);
else if (cl_shownet.value == 2)
Com_Printf ("------------------\n");
cl.onground = false; // unless the server says otherwise
//
// parse the message
//
//MSG_BeginReading ();
while (1)
{
if (msg_badread)
Host_Error ("CL_ParseServerMessage: Bad server message");
cmd = MSG_ReadByte ();
if (cmd == -1)
{
SHOWNET("END OF MESSAGE");
if (!message_with_datagram) {
cl_entframecount--;
}
else
{
VectorCopy (nq_mviewangles[0], nq_mviewangles[1]);
VectorCopy (nq_mviewangles_temp, nq_mviewangles[0]);
}
return; // end of message
}
// if the high bit of the command byte is set, it is a fast update
if (cmd & 128)
{
SHOWNET("fast update");
NQD_ParseUpdate (cmd&127);
continue;
}
if (cmd < num_svc_strings)
SHOWNET(svc_strings[cmd]);
// other commands
switch (cmd)
{
default:
Host_Error ("CL_ParseServerMessage: Illegible server message");
break;
case svc_nop:
break;
case nq_svc_time:
nq_mtime[1] = nq_mtime[0];
nq_mtime[0] = MSG_ReadFloat ();
cl.servertime = nq_mtime[0];
message_with_datagram = true;
break;
case nq_svc_clientdata:
i = MSG_ReadShort ();
NQD_ParseClientdata (i);
break;
case nq_svc_version:
i = MSG_ReadLong ();
if (i != NQ_PROTOCOL_VERSION)
Host_Error ("CL_ParseServerMessage: Server is protocol %i instead of %i\n", i, NQ_PROTOCOL_VERSION);
break;
case svc_disconnect:
Com_Printf ("\n======== End of demo ========\n\n");
CL_NextDemo ();
Host_EndGame ();
Host_Abort ();
break;
case svc_print:
NQD_ParsePrint ();
break;
case svc_centerprint:
SCR_CenterPrint (MSG_ReadString ());
break;
case svc_stufftext:
NQD_ParseStufftext ();
break;
case svc_damage:
V_ParseDamage ();
break;
case svc_serverdata:
NQD_ParseServerData ();
break;
case svc_setangle:
for (i=0 ; i<3 ; i++)
nq_last_fixangle[i] = cl.simangles[i] = cl.viewangles[i] = MSG_ReadAngle ();
break;
case svc_setview:
nq_viewentity = MSG_ReadShort ();
if (nq_viewentity <= nq_maxclients)
cl.playernum = nq_viewentity - 1;
else {
// just let cl.playernum stay where it was
}
break;
case svc_lightstyle:
i = MSG_ReadByte ();
if (i >= MAX_LIGHTSTYLES)
Sys_Error ("svc_lightstyle > MAX_LIGHTSTYLES");
strlcpy (cl_lightstyle[i].map, MSG_ReadString(), sizeof(cl_lightstyle[0].map));
cl_lightstyle[i].length = strlen(cl_lightstyle[i].map);
break;
case svc_sound:
NQD_ParseStartSoundPacket();
break;
case svc_stopsound:
i = MSG_ReadShort();
S_StopSound(i>>3, i&7);
break;
case nq_svc_updatename:
Sbar_Changed ();
i = MSG_ReadByte ();
if (i >= nq_maxclients)
Host_Error ("CL_ParseServerMessage: svc_updatename > NQ_MAX_CLIENTS");
strlcpy (cl.players[i].name, MSG_ReadString(), sizeof(cl.players[i].name));
break;
case svc_updatefrags:
Sbar_Changed ();
i = MSG_ReadByte ();
if (i >= nq_maxclients)
Host_Error ("CL_ParseServerMessage: svc_updatefrags > NQ_MAX_CLIENTS");
cl.players[i].frags = MSG_ReadShort();
break;
case nq_svc_updatecolors:
NQD_ParseUpdatecolors ();
break;
case nq_svc_particle:
CL_ParseParticleEffect ();
break;
case svc_spawnbaseline:
i = MSG_ReadShort ();
if (i >= NQ_MAX_EDICTS)
Host_Error ("svc_spawnbaseline: ent > MAX_EDICTS");
NQD_BumpEntityCount (i);
CL_ParseBaseline (&cl_entities[i].baseline);
break;
case svc_spawnstatic:
CL_ParseStatic ();
break;
case svc_temp_entity:
CL_ParseTEnt ();
break;
case svc_setpause:
if (MSG_ReadByte() != 0)
cl.paused |= PAUSED_SERVER;
else
cl.paused &= ~PAUSED_SERVER;
if (cl.paused)
CDAudio_Pause ();
else
CDAudio_Resume ();
break;
case nq_svc_signonnum:
i = MSG_ReadByte ();
if (i <= nq_signon)
Host_Error ("Received signon %i when at %i", i, nq_signon);
nq_signon = i;
CLNQ_SignonReply ();
break;
case svc_killedmonster:
cl.stats[STAT_MONSTERS]++;
break;
case svc_foundsecret:
cl.stats[STAT_SECRETS]++;
break;
case svc_updatestat:
i = MSG_ReadByte ();
if (i < 0 || i >= MAX_CL_STATS)
Sys_Error ("svc_updatestat: %i is invalid", i);
cl.stats[i] = MSG_ReadLong ();;
break;
case svc_spawnstaticsound:
CL_ParseStaticSound ();
break;
case svc_cdtrack:
cl.cdtrack = MSG_ReadByte ();
MSG_ReadByte(); // loop track (unused)
if (nq_forcecdtrack != -1)
CDAudio_Play ((byte)nq_forcecdtrack, true);
else
CDAudio_Play ((byte)cl.cdtrack, true);
break;
case svc_intermission:
cl.intermission = 1;
cl.completed_time = cl.time;
VectorCopy (nq_last_fixangle, cl.simangles);
break;
case svc_finale:
cl.intermission = 2;
cl.completed_time = cl.time;
SCR_CenterPrint (MSG_ReadString ());
VectorCopy (nq_last_fixangle, cl.simangles);
break;
case nq_svc_cutscene:
cl.intermission = 3;
cl.completed_time = cl.time;
SCR_CenterPrint (MSG_ReadString ());
VectorCopy (nq_last_fixangle, cl.simangles);
break;
case svc_sellscreen:
break;
}
}
}
void CDAudio_Play2(int track, int looping)
{
DWORD dwReturn;
MCI_PLAY_PARMS mciPlayParms;
MCI_STATUS_PARMS mciStatusParms;
if (!enabled)
return;
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
return;
}
track = remap[track];
if (track < 1 || track > maxTrack)
{
CDAudio_Stop();
return;
}
// don't try to play a non-audio track
mciStatusParms.dwItem = MCI_CDA_STATUS_TYPE_TRACK;
mciStatusParms.dwTrack = track;
dwReturn = mciSendCommand(wDeviceID, MCI_STATUS, MCI_STATUS_ITEM | MCI_TRACK | MCI_WAIT, (DWORD) (LPVOID) &mciStatusParms);
if (dwReturn)
{
Com_DPrintf("MCI_STATUS failed (%i)\n", dwReturn);
return;
}
if (mciStatusParms.dwReturn != MCI_CDA_TRACK_AUDIO)
{
Com_Printf("CDAudio: track %i is not audio\n", track);
return;
}
// get the length of the track to be played
mciStatusParms.dwItem = MCI_STATUS_LENGTH;
mciStatusParms.dwTrack = track;
dwReturn = mciSendCommand(wDeviceID, MCI_STATUS, MCI_STATUS_ITEM | MCI_TRACK | MCI_WAIT, (DWORD) (LPVOID) &mciStatusParms);
if (dwReturn)
{
Com_DPrintf("MCI_STATUS failed (%i)\n", dwReturn);
return;
}
if (playing)
{
if (playTrack == track)
return;
CDAudio_Stop();
}
mciPlayParms.dwFrom = MCI_MAKE_TMSF(track, 0, 0, 0);
mciPlayParms.dwTo = (mciStatusParms.dwReturn << 8) | track;
mciPlayParms.dwCallback = (DWORD)cl_hwnd;
dwReturn = mciSendCommand(wDeviceID, MCI_PLAY, MCI_NOTIFY | MCI_FROM | MCI_TO, (DWORD)(LPVOID) &mciPlayParms);
if (dwReturn)
{
Com_DPrintf("CDAudio: MCI_PLAY failed (%i)\n", dwReturn);
return;
}
playLooping = looping;
playTrack = track;
playing = 1;
if ( Cvar_VariableValue( "cd_nocd" ) )
CDAudio_Pause ();
}
void CDAudio_Play(int track, qboolean looping)
{
struct cdrom_tocentry entry;
struct cdrom_ti ti;
if (cdfile == -1 || !enabled)
return;
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
return;
}
track = remap[track];
if (track < 1 || track > maxTrack)
{
Com_DPrintf("CDAudio: Bad track number %u.\n", track);
return;
}
// don't try to play a non-audio track
entry.cdte_track = track;
entry.cdte_format = CDROM_MSF;
if ( ioctl(cdfile, CDROMREADTOCENTRY, &entry) == -1 )
{
Com_DPrintf("ioctl cdromreadtocentry failed\n");
return;
}
if (entry.cdte_ctrl == CDROM_DATA_TRACK)
{
Com_Printf("CDAudio: track %i is not audio\n", track);
return;
}
if (playing)
{
if (playTrack == track)
return;
CDAudio_Stop();
}
ti.cdti_trk0 = track;
ti.cdti_trk1 = track;
ti.cdti_ind0 = 1;
ti.cdti_ind1 = 99;
if ( ioctl(cdfile, CDROMPLAYTRKIND, &ti) == -1 )
{
Com_DPrintf("ioctl cdromplaytrkind failed\n");
return;
}
if ( ioctl(cdfile, CDROMRESUME) == -1 )
Com_DPrintf("ioctl cdromresume failed\n");
playLooping = looping;
playTrack = track;
playing = true;
if (cd_volume->value == 0.0)
CDAudio_Pause ();
}
/*
=====================
CL_ParseServerMessage
=====================
*/
void CL_ParseServerMessage (void)
{
int cmd;
int i;
const char *str; //johnfitz
int total, j, lastcmd; //johnfitz
//
// if recording demos, copy the message out
//
if (cl_shownet.value == 1)
Con_Printf ("%i ",net_message.cursize);
else if (cl_shownet.value == 2)
Con_Printf ("------------------\n");
cl.onground = false; // unless the server says otherwise
//
// parse the message
//
MSG_BeginReading ();
lastcmd = 0;
while (1)
{
if (msg_badread)
Host_Error ("CL_ParseServerMessage: Bad server message");
cmd = MSG_ReadByte ();
if (cmd == -1)
{
SHOWNET("END OF MESSAGE");
return; // end of message
}
// if the high bit of the command byte is set, it is a fast update
if (cmd & U_SIGNAL) //johnfitz -- was 128, changed for clarity
{
SHOWNET("fast update");
CL_ParseUpdate (cmd&127);
continue;
}
SHOWNET(svc_strings[cmd]);
// other commands
switch (cmd)
{
default:
Host_Error ("Illegible server message, previous was %s\n", svc_strings[lastcmd]); //johnfitz -- added svc_strings[lastcmd]
break;
case svc_nop:
// Con_Printf ("svc_nop\n");
break;
case svc_time:
cl.mtime[1] = cl.mtime[0];
cl.mtime[0] = MSG_ReadFloat ();
break;
case svc_clientdata:
CL_ParseClientdata (); //johnfitz -- removed bits parameter, we will read this inside CL_ParseClientdata()
break;
case svc_version:
i = MSG_ReadLong ();
//johnfitz -- support multiple protocols
if (i != PROTOCOL_NETQUAKE && i != PROTOCOL_FITZQUAKE)
Host_Error ("Server returned version %i, not %i or %i\n", i, PROTOCOL_NETQUAKE, PROTOCOL_FITZQUAKE);
cl.protocol = i;
//johnfitz
break;
case svc_disconnect:
Host_EndGame ("Server disconnected\n");
case svc_print:
Con_Printf ("%s", MSG_ReadString ());
break;
case svc_centerprint:
//johnfitz -- log centerprints to console
str = MSG_ReadString ();
SCR_CenterPrint (str);
Con_LogCenterPrint (str);
//johnfitz
break;
case svc_stufftext:
cls.stufftext_frame = host_framecount; // allow full frame update
// in demo playback -- Pa3PyX
Cbuf_AddText (MSG_ReadString ());
break;
case svc_damage:
V_ParseDamage ();
break;
case svc_serverinfo:
CL_ParseServerInfo ();
vid.recalc_refdef = true; // leave intermission full screen
break;
case svc_setangle:
for (i=0 ; i<3 ; i++)
cl.viewangles[i] = MSG_ReadAngle ();
break;
case svc_setview:
cl.viewentity = MSG_ReadShort ();
break;
case svc_lightstyle:
i = MSG_ReadByte ();
if (i >= MAX_LIGHTSTYLES)
Sys_Error ("svc_lightstyle > MAX_LIGHTSTYLES");
q_strlcpy (cl_lightstyle[i].map, MSG_ReadString(), MAX_STYLESTRING);
cl_lightstyle[i].length = Q_strlen(cl_lightstyle[i].map);
//johnfitz -- save extra info
if (cl_lightstyle[i].length)
{
total = 0;
cl_lightstyle[i].peak = 'a';
for (j=0; j<cl_lightstyle[i].length; j++)
{
total += cl_lightstyle[i].map[j] - 'a';
cl_lightstyle[i].peak = q_max(cl_lightstyle[i].peak, cl_lightstyle[i].map[j]);
}
cl_lightstyle[i].average = total / cl_lightstyle[i].length + 'a';
}
else
cl_lightstyle[i].average = cl_lightstyle[i].peak = 'm';
//johnfitz
break;
case svc_sound:
CL_ParseStartSoundPacket();
break;
case svc_stopsound:
i = MSG_ReadShort();
S_StopSound(i>>3, i&7);
break;
case svc_updatename:
Sbar_Changed ();
i = MSG_ReadByte ();
if (i >= cl.maxclients)
Host_Error ("CL_ParseServerMessage: svc_updatename > MAX_SCOREBOARD");
q_strlcpy (cl.scores[i].name, MSG_ReadString(), MAX_SCOREBOARDNAME);
break;
case svc_updatefrags:
Sbar_Changed ();
i = MSG_ReadByte ();
if (i >= cl.maxclients)
Host_Error ("CL_ParseServerMessage: svc_updatefrags > MAX_SCOREBOARD");
cl.scores[i].frags = MSG_ReadShort ();
break;
case svc_updatecolors:
Sbar_Changed ();
i = MSG_ReadByte ();
if (i >= cl.maxclients)
Host_Error ("CL_ParseServerMessage: svc_updatecolors > MAX_SCOREBOARD");
cl.scores[i].colors = MSG_ReadByte ();
CL_NewTranslation (i);
break;
case svc_particle:
R_ParseParticleEffect ();
break;
case svc_spawnbaseline:
i = MSG_ReadShort ();
// must use CL_EntityNum() to force cl.num_entities up
CL_ParseBaseline (CL_EntityNum(i), 1); // johnfitz -- added second parameter
break;
case svc_spawnstatic:
CL_ParseStatic (1); //johnfitz -- added parameter
break;
case svc_temp_entity:
CL_ParseTEnt ();
break;
case svc_setpause:
cl.paused = MSG_ReadByte ();
if (cl.paused)
{
CDAudio_Pause ();
BGM_Pause ();
}
else
{
CDAudio_Resume ();
BGM_Resume ();
}
break;
case svc_signonnum:
i = MSG_ReadByte ();
if (i <= cls.signon)
Host_Error ("Received signon %i when at %i", i, cls.signon);
cls.signon = i;
//johnfitz -- if signonnum==2, signon packet has been fully parsed, so check for excessive static ents and efrags
if (i == 2)
{
if (cl.num_statics > 128)
Con_Warning ("%i static entities exceeds standard limit of 128.\n", cl.num_statics);
R_CheckEfrags ();
}
//johnfitz
CL_SignonReply ();
break;
case svc_killedmonster:
cl.stats[STAT_MONSTERS]++;
break;
case svc_foundsecret:
cl.stats[STAT_SECRETS]++;
break;
case svc_updatestat:
i = MSG_ReadByte ();
if (i < 0 || i >= MAX_CL_STATS)
Sys_Error ("svc_updatestat: %i is invalid", i);
cl.stats[i] = MSG_ReadLong ();;
break;
case svc_spawnstaticsound:
CL_ParseStaticSound (1); //johnfitz -- added parameter
break;
case svc_cdtrack:
cl.cdtrack = MSG_ReadByte ();
cl.looptrack = MSG_ReadByte ();
if ( (cls.demoplayback || cls.demorecording) && (cls.forcetrack != -1) )
BGM_PlayCDtrack ((byte)cls.forcetrack, true);
else
BGM_PlayCDtrack ((byte)cl.cdtrack, true);
break;
case svc_intermission:
cl.intermission = 1;
cl.completed_time = cl.time;
vid.recalc_refdef = true; // go to full screen
break;
case svc_finale:
cl.intermission = 2;
cl.completed_time = cl.time;
vid.recalc_refdef = true; // go to full screen
//johnfitz -- log centerprints to console
str = MSG_ReadString ();
SCR_CenterPrint (str);
Con_LogCenterPrint (str);
//johnfitz
break;
case svc_cutscene:
cl.intermission = 3;
cl.completed_time = cl.time;
vid.recalc_refdef = true; // go to full screen
//johnfitz -- log centerprints to console
str = MSG_ReadString ();
SCR_CenterPrint (str);
Con_LogCenterPrint (str);
//johnfitz
break;
case svc_sellscreen:
Cmd_ExecuteString ("help", src_command);
break;
//johnfitz -- new svc types
case svc_skybox:
Sky_LoadSkyBox (MSG_ReadString());
break;
case svc_bf:
Cmd_ExecuteString ("bf", src_command);
break;
case svc_fog:
Fog_ParseServerMessage ();
break;
case svc_spawnbaseline2: //PROTOCOL_FITZQUAKE
i = MSG_ReadShort ();
// must use CL_EntityNum() to force cl.num_entities up
CL_ParseBaseline (CL_EntityNum(i), 2);
break;
case svc_spawnstatic2: //PROTOCOL_FITZQUAKE
CL_ParseStatic (2);
break;
case svc_spawnstaticsound2: //PROTOCOL_FITZQUAKE
CL_ParseStaticSound (2);
break;
//johnfitz
}
lastcmd = cmd; //johnfitz
}
}
static void CD_f (void)
{
char *command;
int ret;
int n;
if (Cmd_Argc() < 2)
return;
command = Cmd_Argv (1);
if (Q_strcasecmp(command, "on") == 0)
{
enabled = true;
return;
}
if (Q_strcasecmp(command, "off") == 0)
{
if (playing)
CDAudio_Stop();
enabled = false;
return;
}
if (Q_strcasecmp(command, "reset") == 0)
{
enabled = true;
if (playing)
CDAudio_Stop();
for (n = 0; n < 100; n++)
remap[n] = n;
CDAudio_GetAudioDiskInfo();
return;
}
if (Q_strcasecmp(command, "remap") == 0)
{
ret = Cmd_Argc() - 2;
if (ret <= 0)
{
for (n = 1; n < 100; n++)
if (remap[n] != n)
Con_Printf(" %u -> %u\n", n, remap[n]);
return;
}
for (n = 1; n <= ret; n++)
remap[n] = Q_atoi(Cmd_Argv (n+1));
return;
}
if (Q_strcasecmp(command, "close") == 0)
{
CDAudio_CloseDoor();
return;
}
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
{
Con_Printf("No CD in player.\n");
return;
}
}
if (Q_strcasecmp(command, "play") == 0)
{
CDAudio_Play((byte)Q_atoi(Cmd_Argv (2)), false);
return;
}
if (Q_strcasecmp(command, "loop") == 0)
{
CDAudio_Play((byte)Q_atoi(Cmd_Argv (2)), true);
return;
}
if (Q_strcasecmp(command, "stop") == 0)
{
CDAudio_Stop();
return;
}
if (Q_strcasecmp(command, "pause") == 0)
{
CDAudio_Pause();
return;
}
if (Q_strcasecmp(command, "resume") == 0)
{
CDAudio_Resume();
return;
}
if (Q_strcasecmp(command, "eject") == 0)
{
if (playing)
CDAudio_Stop();
CDAudio_Eject();
cdValid = false;
return;
}
if (Q_strcasecmp(command, "info") == 0)
{
Con_Printf("%u tracks\n", maxTrack);
if (playing)
Con_Printf("Currently %s track %u\n", playLooping ? "looping" : "playing", playTrack);
else if (wasPlaying)
Con_Printf("Paused %s track %u\n", playLooping ? "looping" : "playing", playTrack);
Con_Printf("Volume is %f\n", cdvolume);
return;
}
}
void
CDAudio_Play (byte track, qboolean looping)
{
struct cdrom_tocentry entry0;
struct cdrom_tocentry entry1;
struct cdrom_msf msf;
if (cdfile == -1 || !enabled)
return;
if (!cdValid) {
CDAudio_GetAudioDiskInfo ();
if (!cdValid)
return;
}
track = remap[track];
if (track < 1 || track > maxTrack) {
Con_DPrintf ("CDAudio: Bad track number %u.\n", track);
return;
}
// don't try to play a non-audio track
entry0.cdte_track = track;
entry0.cdte_format = CDROM_MSF;
if (ioctl (cdfile, CDROMREADTOCENTRY, &entry0) == -1) {
Con_DPrintf ("CDAudio: ioctl cdromreadtocentry failed\n");
return;
}
entry1.cdte_track = track + 1;
entry1.cdte_format = CDROM_MSF;
if (entry1.cdte_track > maxTrack) {
entry1.cdte_track = CDROM_LEADOUT;
}
if (ioctl (cdfile, CDROMREADTOCENTRY, &entry1) == -1) {
Con_DPrintf ("CDAudio: ioctl cdromreadtocentry failed\n");
return;
}
if (entry0.cdte_ctrl == CDROM_DATA_TRACK) {
Con_Printf ("track %i is not audio\n", track);
return;
}
if (playing) {
if (playTrack == track)
return;
CDAudio_Stop ();
}
msf.cdmsf_min0 = entry0.cdte_addr.msf.minute;
msf.cdmsf_sec0 = entry0.cdte_addr.msf.second;
msf.cdmsf_frame0 = entry0.cdte_addr.msf.frame;
msf.cdmsf_min1 = entry1.cdte_addr.msf.minute;
msf.cdmsf_sec1 = entry1.cdte_addr.msf.second;
msf.cdmsf_frame1 = entry1.cdte_addr.msf.frame;
Con_DPrintf ("%2d:%02d:%02d %2d:%02d:%02d\n",
msf.cdmsf_min0,
msf.cdmsf_sec0,
msf.cdmsf_frame0,
msf.cdmsf_min1, msf.cdmsf_sec1, msf.cdmsf_frame1);
if (ioctl (cdfile, CDROMPLAYMSF, &msf) == -1) {
Con_DPrintf ("CDAudio: ioctl cdromplaytrkind failed (%s)\n",
strerror (errno));
return;
}
// if ( ioctl(cdfile, CDROMRESUME) == -1 )
// Con_DPrintf("CDAudio: ioctl cdromresume failed\n");
playLooping = looping;
playTrack = track;
playing = true;
if (cdvolume == 0.0)
CDAudio_Pause ();
}
