/*
====================
CL_Init
====================
*/
void CL_Init( void )
{
qboolean loaded;
if( host.type == HOST_DEDICATED )
return; // nothing running on the client
Con_Init();
CL_InitLocal();
R_Init(); // init renderer
S_Init(); // init sound
// unreliable buffer. unsed for unreliable commands and voice stream
BF_Init( &cls.datagram, "cls.datagram", cls.datagram_buf, sizeof( cls.datagram_buf ));
loaded = CL_LoadProgs( va( "%s/%s" , GI->dll_path, GI->client_lib ));
if( !loaded )
#if defined (__ANDROID__)
{
char clientlib[256];
Q_strncpy( clientlib, getenv("XASH3D_ENGLIBDIR"), 256 );
Q_strncat( clientlib, "/" CLIENTDLL, 256 );
loaded = CL_LoadProgs( clientlib );
}
#else
loaded = CL_LoadProgs( CLIENTDLL );
#endif
if( loaded )
{
cls.initialized = true;
cl.maxclients = 1; // allow to drawing player in menu
cls.olddemonum = -1;
cls.demonum = -1;
}
}
/*
=================
CL_ReadDemoUserCmd
read the demo usercmd for predicting
and smooth movement during playback the demo
=================
*/
void CL_ReadDemoUserCmd( qboolean discard )
{
byte data[1024];
int cmdnumber;
int outgoing_sequence;
word bytes;
FS_Read( cls.demofile, &outgoing_sequence, sizeof( int ));
FS_Read( cls.demofile, &cmdnumber, sizeof( int ));
FS_Read( cls.demofile, &bytes, sizeof( short ));
FS_Read( cls.demofile, data, bytes );
if( !discard )
{
usercmd_t nullcmd = {0};
sizebuf_t buf;
BF_Init( &buf, "UserCmd", data, sizeof( data ));
// always delta'ing from null
cl.refdef.cmd = &cl.cmds[cmdnumber & CL_UPDATE_MASK ];
MSG_ReadDeltaUsercmd( &buf, &nullcmd, cl.refdef.cmd );
// NOTE: we need to have the current outgoing sequence correct
// so we can do prediction correctly during playback
cls.netchan.outgoing_sequence = outgoing_sequence;
}
}
/*
==============
CL_CheckingResFile
==============
*/
void CL_CheckingResFile( char *pResFileName )
{
sizebuf_t buf;
byte data[32];
if( FS_FileExists( pResFileName, false ))
return; // already exists
cls.downloadcount++;
if( cl_allow_fragment->integer )
{
Msg( "Starting file download: %s\n", pResFileName );
if( cls.state == ca_disconnected ) return;
BF_Init( &buf, "ClientPacket", data, sizeof( data ));
BF_WriteByte( &buf, clc_resourcelist );
BF_WriteString( &buf, pResFileName );
if( !cls.netchan.remote_address.type ) // download in singleplayer ???
cls.netchan.remote_address.type = NA_LOOPBACK;
// make sure message will be delivered
Netchan_Transmit( &cls.netchan, BF_GetNumBytesWritten( &buf ), BF_GetData( &buf ));
}
else
HTTP_AddDownload( pResFileName, -1, true );
}
/*
=======================
SV_SendClientDatagram
=======================
*/
void SV_SendClientDatagram( sv_client_t *cl )
{
byte msg_buf[NET_MAX_PAYLOAD];
sizebuf_t msg;
svs.currentPlayer = cl;
svs.currentPlayerNum = (cl - svs.clients);
BF_Init( &msg, "Datagram", msg_buf, sizeof( msg_buf ));
// always send servertime at new frame
BF_WriteByte( &msg, svc_time );
BF_WriteFloat( &msg, sv.time );
SV_WriteClientdataToMessage( cl, &msg );
SV_WriteEntitiesToClient( cl, &msg );
// copy the accumulated multicast datagram
// for this client out to the message
if( BF_CheckOverflow( &cl->datagram )) MsgDev( D_WARN, "datagram overflowed for %s\n", cl->name );
else BF_WriteBits( &msg, BF_GetData( &cl->datagram ), BF_GetNumBitsWritten( &cl->datagram ));
BF_Clear( &cl->datagram );
if( BF_CheckOverflow( &msg ))
{
// must have room left for the packet header
MsgDev( D_WARN, "msg overflowed for %s\n", cl->name );
BF_Clear( &msg );
}
// send the datagram
Netchan_TransmitBits( &cl->netchan, BF_GetNumBitsWritten( &msg ), BF_GetData( &msg ));
}
/*
==================
SV_FinalMessage
Used by SV_Shutdown to send a final message to all
connected clients before the server goes down. The messages are sent immediately,
not just stuck on the outgoing message list, because the server is going
to totally exit after returning from this function.
==================
*/
void SV_FinalMessage( char *message, qboolean reconnect )
{
sv_client_t *cl;
byte msg_buf[1024];
sizebuf_t msg;
int i;
BF_Init( &msg, "FinalMessage", msg_buf, sizeof( msg_buf ));
BF_WriteByte( &msg, svc_print );
BF_WriteByte( &msg, PRINT_HIGH );
BF_WriteString( &msg, va( "%s\n", message ));
if( reconnect )
{
BF_WriteByte( &msg, svc_changing );
if( sv.loadgame || sv_maxclients->integer > 1 || sv.changelevel )
BF_WriteOneBit( &msg, 1 ); // changelevel
else BF_WriteOneBit( &msg, 0 );
}
else
{
BF_WriteByte( &msg, svc_disconnect );
}
// send it twice
// stagger the packets to crutch operating system limited buffers
for( i = 0, cl = svs.clients; i < sv_maxclients->integer; i++, cl++ )
if( cl->state >= cs_connected && !cl->fakeclient )
Netchan_Transmit( &cl->netchan, BF_GetNumBytesWritten( &msg ), BF_GetData( &msg ));
for( i = 0, cl = svs.clients; i < sv_maxclients->integer; i++, cl++ )
if( cl->state >= cs_connected && !cl->fakeclient )
Netchan_Transmit( &cl->netchan, BF_GetNumBytesWritten( &msg ), BF_GetData( &msg ));
}
int main() {
int x,fd,i;
Record temp,record;
BF_Init();
x = Sorted_CreateFile("arxeio");
fd = Sorted_OpenFile("arxeio");
strcpy(temp.name,"nikos");
strcpy(temp.surname,"mixelis");
strcpy(temp.city,"athens");
for(i=1;i<=5;i++) {
temp.id=i;
x=HP_InsertEntry(fd,temp);
}
for(i=1;i<=1;i++) {
temp.id=7;
x=HP_InsertEntry(fd,temp);
}
for(i=8;i<=16;i++) {
temp.id=i;
x=HP_InsertEntry(fd,temp);
}
Sorted_GetAllEntries(fd,"id",NULL);
strcpy(record.name,"nikos");
strcpy(record.surname,"liappas");
strcpy(record.city,"athens");
record.id=6;
Sorted_InsertEntry(fd,record);
Sorted_GetAllEntries(fd,"id",NULL);
return 0;
}
/*
=================
CL_ReadNetMessage
=================
*/
void CL_ReadNetMessage( void )
{
size_t curSize;
while( CL_GetMessage( net_message_buffer, &curSize ))
{
BF_Init( &net_message, "ServerData", net_message_buffer, curSize );
// check for connectionless packet (0xffffffff) first
if( BF_GetMaxBytes( &net_message ) >= 4 && *(int *)net_message.pData == -1 )
{
CL_ConnectionlessPacket( net_from, &net_message );
continue;
}
// can't be a valid sequenced packet
if( cls.state < ca_connected ) continue;
if( BF_GetMaxBytes( &net_message ) < 8 )
{
MsgDev( D_WARN, "%s: runt packet\n", NET_AdrToString( net_from ));
continue;
}
// packet from server
if( !cls.demoplayback && !NET_CompareAdr( net_from, cls.netchan.remote_address ))
{
MsgDev( D_ERROR, "CL_ReadPackets: %s:sequenced packet without connection\n", NET_AdrToString( net_from ));
continue;
}
if( !cls.demoplayback && !Netchan_Process( &cls.netchan, &net_message ))
continue; // wasn't accepted for some reason
CL_ParseServerMessage( &net_message );
}
// check for fragmentation/reassembly related packets.
if( cls.state != ca_disconnected && Netchan_IncomingReady( &cls.netchan ))
{
// the header is different lengths for reliable and unreliable messages
int headerBytes = BF_GetNumBytesRead( &net_message );
// process the incoming buffer(s)
if( Netchan_CopyNormalFragments( &cls.netchan, &net_message ))
{
CL_ParseServerMessage( &net_message );
}
if( Netchan_CopyFileFragments( &cls.netchan, &net_message ))
{
// remove from resource request stuff.
CL_ProcessFile( true, cls.netchan.incomingfilename );
}
}
Netchan_UpdateProgress( &cls.netchan );
}
/*
====================
CL_Init
====================
*/
void CL_Init( void )
{
qboolean loaded;
Q_memset( &cls, 0, sizeof( cls ) );
if( Host_IsDedicated() )
return; // nothing running on the client
Con_Init();
CL_InitLocal();
R_Init(); // init renderer
S_Init(); // init sound
// unreliable buffer. unsed for unreliable commands and voice stream
BF_Init( &cls.datagram, "cls.datagram", cls.datagram_buf, sizeof( cls.datagram_buf ));
IN_TouchInit();
#if defined (__ANDROID__)
{
char clientlib[256];
Q_snprintf( clientlib, sizeof(clientlib), "%s/" CLIENTDLL, getenv("XASH3D_GAMELIBDIR"));
loaded = CL_LoadProgs( clientlib );
if( !loaded )
{
Q_snprintf( clientlib, sizeof(clientlib), "%s/" CLIENTDLL, getenv("XASH3D_ENGLIBDIR"));
loaded = CL_LoadProgs( clientlib );
}
}
#else
{
char clientlib[256];
Com_ResetLibraryError();
if( Sys_GetParmFromCmdLine( "-clientlib", clientlib ) )
loaded = CL_LoadProgs( clientlib );
else
loaded = CL_LoadProgs( va( "%s/%s" , GI->dll_path, SI.clientlib ));
if( !loaded )
{
loaded = CL_LoadProgs( CLIENTDLL );
}
}
#endif
if( loaded )
{
cls.initialized = true;
cls.keybind_changed = false;
cl.maxclients = 1; // allow to drawing player in menu
cls.olddemonum = -1;
cls.demonum = -1;
}
else
Sys_Warn("Could not load client library:\n%s", Com_GetLibraryError());
}
/*
==============================
Netchan_AllocFragbuf
==============================
*/
fragbuf_t *Netchan_AllocFragbuf( void )
{
fragbuf_t *buf;
buf = (fragbuf_t *)Mem_Alloc( net_mempool, sizeof( fragbuf_t ));
BF_Init( &buf->frag_message, "Frag Message", buf->frag_message_buf, sizeof( buf->frag_message_buf ));
return buf;
}
/*
===============
Netchan_OutOfBand
Sends an out-of-band datagram
================
*/
void Netchan_OutOfBand( int net_socket, netadr_t adr, int length, byte *data )
{
sizebuf_t send;
byte send_buf[NET_MAX_PAYLOAD];
// write the packet header
BF_Init( &send, "SequencePacket", send_buf, sizeof( send_buf ));
BF_WriteLong( &send, -1 ); // -1 sequence means out of band
BF_WriteBytes( &send, data, length );
if( !CL_IsPlaybackDemo( ))
{
// send the datagram
NET_SendPacket( net_socket, BF_GetNumBytesWritten( &send ), BF_GetData( &send ), adr );
}
}
/*
==============
Netchan_Setup
called to open a channel to a remote system
==============
*/
void Netchan_Setup( netsrc_t sock, netchan_t *chan, netadr_t adr, int qport )
{
Netchan_Clear( chan );
Q_memset( chan, 0, sizeof( *chan ));
chan->sock = sock;
chan->remote_address = adr;
chan->last_received = host.realtime;
chan->connect_time = host.realtime;
chan->incoming_sequence = 0;
chan->outgoing_sequence = 1;
chan->rate = DEFAULT_RATE;
chan->compress = false; // work but low efficiency
chan->qport = qport;
BF_Init( &chan->message, "NetData", chan->message_buf, sizeof( chan->message_buf ));
}
int main() {
int x,fd,i;
Record temp;
BF_Init();
x = HP_CreateFile("arxeio");
fd = HP_OpenFile("arxeio");
strcpy(temp.name,"nikos");
strcpy(temp.surname,"liappas");
strcpy(temp.city,"athens");
for(i=0;i<100;i++) {
temp.id=i;
x=HP_InsertEntry(fd,temp);
}
x=97;
x=HP_DeleteEntry(fd,"surname","liappas");
HP_GetAllEntries(fd,"id",NULL);
return 0;
}
/*
=====================
CL_SendDisconnectMessage
Sends a disconnect message to the server
=====================
*/
void CL_SendDisconnectMessage( void )
{
sizebuf_t buf;
byte data[32];
if( cls.state == ca_disconnected ) return;
BF_Init( &buf, "LastMessage", data, sizeof( data ));
BF_WriteByte( &buf, clc_stringcmd );
BF_WriteString( &buf, "disconnect" );
if( !cls.netchan.remote_address.type )
cls.netchan.remote_address.type = NA_LOOPBACK;
// make sure message will be delivered
Netchan_Transmit( &cls.netchan, BF_GetNumBytesWritten( &buf ), BF_GetData( &buf ));
Netchan_Transmit( &cls.netchan, BF_GetNumBytesWritten( &buf ), BF_GetData( &buf ));
Netchan_Transmit( &cls.netchan, BF_GetNumBytesWritten( &buf ), BF_GetData( &buf ));
}
/*
====================
CL_Init
====================
*/
void CL_Init( void )
{
if( host.type == HOST_DEDICATED )
return; // nothing running on the client
Con_Init();
CL_InitLocal();
R_Init(); // init renderer
S_Init(); // init sound
// unreliable buffer. unsed for unreliable commands and voice stream
BF_Init( &cls.datagram, "cls.datagram", cls.datagram_buf, sizeof( cls.datagram_buf ));
if( !CL_LoadProgs( va( "%s/client.dll", GI->dll_path )))
Host_Error( "can't initialize client.dll\n" );
cls.initialized = true;
cl.maxclients = 1; // allow to drawing player in menu
cls.olddemonum = -1;
cls.demonum = -1;
}
/*
====================
CL_WriteDemoUserCmd
Writes the current user cmd
====================
*/
void CL_WriteDemoUserCmd( int cmdnumber )
{
sizebuf_t buf;
word bytes;
byte data[1024];
if( !cls.demorecording || !cls.demofile )
return;
CL_WriteDemoCmdHeader( dem_usercmd, cls.demofile );
FS_Write( cls.demofile, &cls.netchan.outgoing_sequence, sizeof( int ));
FS_Write( cls.demofile, &cmdnumber, sizeof( int ));
// write usercmd_t
BF_Init( &buf, "UserCmd", data, sizeof( data ));
CL_WriteUsercmd( &buf, -1, cmdnumber ); // always no delta
bytes = BF_GetNumBytesWritten( &buf );
FS_Write( cls.demofile, &bytes, sizeof( word ));
FS_Write( cls.demofile, data, bytes );
}
int main(int argc, char* argv[]){
char* dbname;
if(argc!=2){
printf("Usage: %s dbname \n",argv[0]);
return 1;
}
dbname=argv[1];
if(chdir(dbname)){
printf("Cannot open database!\n");
return 1;
}
BF_Init();
HF_Init();
AM_Init();
if ((relCatFd = HF_OpenFile("relCat")) < 0) {
printf("Cannot open file relCat\n");
return 1;
}
if ((attrCatFd = HF_OpenFile("attrCat")) < 0) {
printf("Cannot open file relCat\n");
return 1;
}
/* Κλήση της συνάρτησης yyparse ή οποία */
/* θα καλεί αυτόματα τις συναρτήσεις σας */
while(yyparse() == RESTART);
system("Pause");
return 0;
}
/*
==============================
Netchan_CopyNormalFragments
==============================
*/
qboolean Netchan_CopyNormalFragments( netchan_t *chan, sizebuf_t *msg )
{
fragbuf_t *p, *n;
if( !chan->incomingready[FRAG_NORMAL_STREAM] )
return false;
if( !chan->incomingbufs[FRAG_NORMAL_STREAM] )
{
MsgDev( D_ERROR, "Netchan_CopyNormalFragments: Called with no fragments readied\n" );
chan->incomingready[FRAG_NORMAL_STREAM] = false;
return false;
}
p = chan->incomingbufs[FRAG_NORMAL_STREAM];
BF_Init( msg, "NetMessage", net_message_buffer, sizeof( net_message_buffer ));
while( p )
{
n = p->next;
// copy it in
BF_WriteBits( msg, BF_GetData( &p->frag_message ), BF_GetNumBitsWritten( &p->frag_message ));
Mem_Free( p );
p = n;
}
chan->incomingbufs[FRAG_NORMAL_STREAM] = NULL;
// reset flag
chan->incomingready[FRAG_NORMAL_STREAM] = false;
return true;
}
int main( int argc, char* argv[] ){
int i,x;
int fdhp1;
srand( time(NULL) );
BF_Init();
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
if ( (fdhp1 = HP_OpenFile("hp1")) < 0 )
{
BF_PrintError("Error opening file hp1");
return -1;
}
x=15;
printf("\nSearching for records with id 15 in file hp1\n");
HP_GetAllEntries(fdhp1, "id", &x);
printf("\nSearching for records with name VASSILIS in file hp1\n");
HP_GetAllEntries(fdhp1, "name", "VASSILIS");
printf("\nDeleting records with name VASSILIS in file hp1\n");
if ( HP_DeleteEntry (fdhp1, "name", "VASSILIS") < 0)
{
BF_PrintError("Error deleting record in file hp1");
HP_CloseFile(fdhp1);
return -1;
}
printf("\nSearching for records with name VASSILIS in file hp1\n");
HP_GetAllEntries(fdhp1, "name", "VASSILIS"); /* No entries found */
i = 0;
while ( i < 15 ) /* Insert 15 records in heap file */
{
Record r = randomRecord();
if( HP_InsertEntry (fdhp1, r) < 0)
{
BF_PrintError("Error inserting record in file hp1");
HP_CloseFile(fdhp1);
return -1;
}
printf("\nRecord (%d, %s, %s, %s) was successfully inserted in file hp1\n", r.id, r.name, r.surname, r.city);
i++;
}
/* Print everything that exists in file hp1 */
printf("Printing everything in file hp1\n");
HP_GetAllEntries(fdhp1, NULL, NULL);
x=12;
printf("\nDeleting records with id 12 in file hp1\n");
if ( HP_DeleteEntry (fdhp1, "id", &x) < 0)
{
BF_PrintError("Error deleting record in file hp1");
HP_CloseFile(fdhp1);
return -1;
}
printf("\nSearching for records with surname PAPAPETROU in file hp1\n");
HP_GetAllEntries(fdhp1, "surname", "PAPAPETROU");
if( HP_CloseFile(fdhp1) < 0)
{
BF_PrintError("Error closing file hp1");
return -1;
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
return 0;
}
/*
===================
CL_WritePacket
Create and send the command packet to the server
Including both the reliable commands and the usercmds
===================
*/
void CL_WritePacket( void )
{
sizebuf_t buf;
qboolean send_command = false;
byte data[MAX_CMD_BUFFER];
int i, from, to, key, size;
int numbackup = 2;
int numcmds;
int newcmds;
int cmdnumber;
// don't send anything if playing back a demo
if( cls.demoplayback || cls.state == ca_cinematic )
return;
if( cls.state == ca_disconnected || cls.state == ca_connecting )
return;
CL_ComputePacketLoss ();
#ifndef _DEBUG
if( cl_cmdrate->value < MIN_CMD_RATE )
{
Cvar_SetFloat( "cl_cmdrate", MIN_CMD_RATE );
}
#endif
Q_memset( data, 0, MAX_CMD_BUFFER );
BF_Init( &buf, "ClientData", data, sizeof( data ));
// Determine number of backup commands to send along
numbackup = bound( 0, cl_cmdbackup->integer, MAX_BACKUP_COMMANDS );
if( cls.state == ca_connected ) numbackup = 0;
// Check to see if we can actually send this command
// In single player, send commands as fast as possible
// Otherwise, only send when ready and when not choking bandwidth
if(( cl.maxclients == 1 ) || ( NET_IsLocalAddress( cls.netchan.remote_address ) && !host_limitlocal->integer ))
send_command = true;
else if(( host.realtime >= cls.nextcmdtime ) && Netchan_CanPacket( &cls.netchan ))
send_command = true;
if( cl.force_send_usercmd )
{
send_command = true;
cl.force_send_usercmd = false;
}
if(( cls.netchan.outgoing_sequence - cls.netchan.incoming_acknowledged ) >= CL_UPDATE_MASK )
{
if(( host.realtime - cls.netchan.last_received ) > CONNECTION_PROBLEM_TIME )
{
Con_NPrintf( 1, "^3Warning:^1 Connection Problem^7\n" );
cl.validsequence = 0;
}
}
if( cl_nodelta->integer )
{
cl.validsequence = 0;
}
// send a userinfo update if needed
if( userinfo->modified )
{
BF_WriteByte( &cls.netchan.message, clc_userinfo );
BF_WriteString( &cls.netchan.message, Cvar_Userinfo( ));
}
if( send_command )
{
int outgoing_sequence;
if( cl_cmdrate->integer > 0 )
cls.nextcmdtime = host.realtime + ( 1.0f / cl_cmdrate->value );
else cls.nextcmdtime = host.realtime; // always able to send right away
if( cls.lastoutgoingcommand == -1 )
{
outgoing_sequence = cls.netchan.outgoing_sequence;
cls.lastoutgoingcommand = cls.netchan.outgoing_sequence;
}
else outgoing_sequence = cls.lastoutgoingcommand + 1;
// begin a client move command
BF_WriteByte( &buf, clc_move );
// save the position for a checksum byte
key = BF_GetRealBytesWritten( &buf );
BF_WriteByte( &buf, 0 );
// write packet lossage percentation
BF_WriteByte( &buf, cls.packet_loss );
// say how many backups we'll be sending
BF_WriteByte( &buf, numbackup );
// how many real commands have queued up
newcmds = ( cls.netchan.outgoing_sequence - cls.lastoutgoingcommand );
// put an upper/lower bound on this
newcmds = bound( 0, newcmds, MAX_TOTAL_CMDS );
if( cls.state == ca_connected ) newcmds = 0;
BF_WriteByte( &buf, newcmds );
numcmds = newcmds + numbackup;
from = -1;
for( i = numcmds - 1; i >= 0; i-- )
{
cmdnumber = ( cls.netchan.outgoing_sequence - i ) & CL_UPDATE_MASK;
to = cmdnumber;
CL_WriteUsercmd( &buf, from, to );
from = to;
if( BF_CheckOverflow( &buf ))
Host_Error( "CL_Move, overflowed command buffer (%i bytes)\n", MAX_CMD_BUFFER );
}
// calculate a checksum over the move commands
size = BF_GetRealBytesWritten( &buf ) - key - 1;
buf.pData[key] = CRC32_BlockSequence( buf.pData + key + 1, size, cls.netchan.outgoing_sequence );
// message we are constructing.
i = cls.netchan.outgoing_sequence & CL_UPDATE_MASK;
// determine if we need to ask for a new set of delta's.
if( cl.validsequence && (cls.state == ca_active) && !( cls.demorecording && cls.demowaiting ))
{
cl.delta_sequence = cl.validsequence;
BF_WriteByte( &buf, clc_delta );
BF_WriteByte( &buf, cl.validsequence & 0xFF );
}
else
{
// request delta compression of entities
cl.delta_sequence = -1;
}
if( BF_CheckOverflow( &buf ))
{
Host_Error( "CL_Move, overflowed command buffer (%i bytes)\n", MAX_CMD_BUFFER );
}
// remember outgoing command that we are sending
cls.lastoutgoingcommand = cls.netchan.outgoing_sequence;
// composite the rest of the datagram..
if( BF_GetNumBitsWritten( &cls.datagram ) <= BF_GetNumBitsLeft( &buf ))
BF_WriteBits( &buf, BF_GetData( &cls.datagram ), BF_GetNumBitsWritten( &cls.datagram ));
BF_Clear( &cls.datagram );
// deliver the message (or update reliable)
Netchan_Transmit( &cls.netchan, BF_GetNumBytesWritten( &buf ), BF_GetData( &buf ));
}
else
{
// increment sequence number so we can detect that we've held back packets.
cls.netchan.outgoing_sequence++;
}
if( cls.demorecording )
{
// Back up one because we've incremented outgoing_sequence each frame by 1 unit
cmdnumber = ( cls.netchan.outgoing_sequence - 1 ) & CL_UPDATE_MASK;
CL_WriteDemoUserCmd( cmdnumber );
}
// update download/upload slider.
Netchan_UpdateProgress( &cls.netchan );
}
/*
==============================
Netchan_CopyFileFragments
==============================
*/
qboolean Netchan_CopyFileFragments( netchan_t *chan, sizebuf_t *msg )
{
fragbuf_t *p, *n;
char filename[CS_SIZE];
int nsize;
byte *buffer;
int pos;
if( !chan->incomingready[FRAG_FILE_STREAM] )
return false;
if( !chan->incomingbufs[FRAG_FILE_STREAM] )
{
MsgDev( D_WARN, "Netchan_CopyFileFragments: Called with no fragments readied\n" );
chan->incomingready[FRAG_FILE_STREAM] = false;
return false;
}
p = chan->incomingbufs[FRAG_FILE_STREAM];
BF_Init( msg, "NetMessage", net_message_buffer, sizeof( net_message_buffer ));
// copy in first chunk so we can get filename out
BF_WriteBits( msg, BF_GetData( &p->frag_message ), BF_GetNumBitsWritten( &p->frag_message ));
BF_SeekToBit( msg, 0 ); // rewind buffer
//Q_strncpy( filename, BF_ReadString( msg ), sizeof( filename ));
Q_snprintf( filename, sizeof( filename ), "downloaded/%s", BF_ReadString( msg ) );
if( Q_strlen( filename ) <= 0 )
{
MsgDev( D_ERROR, "File fragment received with no filename\nFlushing input queue\n" );
// clear out bufs
Netchan_FlushIncoming( chan, FRAG_FILE_STREAM );
return false;
}
else if( Q_strstr( filename, ".." ))
{
MsgDev( D_ERROR, "File fragment received with relative path, ignoring\n" );
// clear out bufs
Netchan_FlushIncoming( chan, FRAG_FILE_STREAM );
return false;
}
Q_strncpy( chan->incomingfilename, filename, sizeof( chan->incomingfilename ));
if( FS_FileExists( filename, false ))
{
MsgDev( D_ERROR, "Can't download %s, already exists\n", filename );
// clear out bufs
Netchan_FlushIncoming( chan, FRAG_FILE_STREAM );
return true;
}
// create file from buffers
nsize = 0;
while ( p )
{
nsize += BF_GetNumBytesWritten( &p->frag_message ); // Size will include a bit of slop, oh well
if( p == chan->incomingbufs[FRAG_FILE_STREAM] )
{
nsize -= BF_GetNumBytesRead( msg );
}
p = p->next;
}
buffer = Mem_Alloc( net_mempool, nsize + 1 );
p = chan->incomingbufs[ FRAG_FILE_STREAM ];
pos = 0;
while( p )
{
int cursize;
n = p->next;
cursize = BF_GetNumBytesWritten( &p->frag_message );
// first message has the file name, don't write that into the data stream,
// just write the rest of the actual data
if( p == chan->incomingbufs[FRAG_FILE_STREAM] )
{
// copy it in
cursize -= BF_GetNumBytesRead( msg );
Q_memcpy( &buffer[pos], &p->frag_message.pData[BF_GetNumBytesRead( msg )], cursize );
}
else
{
Q_memcpy( &buffer[pos], p->frag_message.pData, cursize );
}
pos += cursize;
Mem_Free( p );
p = n;
}
FS_WriteFile( filename, buffer, pos );
Mem_Free( buffer );
// clear remnants
BF_Clear( msg );
chan->incomingbufs[FRAG_FILE_STREAM] = NULL;
// reset flag
chan->incomingready[FRAG_FILE_STREAM] = false;
return true;
}
int main()
{
int athletesFd;
int athletesBlockNum;
char *athletesBlockBuf;
int athleteId;
char athleteName[BF_MAIN_NAME_SIZE];
char athleteSurName[BF_MAIN_NAME_SIZE];
/* Αρχικοποίηση του επιπέδου αρχείου μπλοκ */
BF_Init();
/* ’νοιγμα του αρχείου ATHLETES */
athletesFd = BF_OpenFile("ATHLETES");
if (athletesFd < 0)
{
BF_PrintError("Error in BF_OpenFile called on ATHLETES.");
return;
}
/* Εκτύπωση όλων των αθλητών */
if (BF_GetFirstBlock(athletesFd, &athletesBlockNum, &athletesBlockBuf) != BFE_OK)
BF_PrintError("Error in BF_GetFirstBlock called on ATHLETES.");
printf("File ATHLETES contains the following athletes:\nID NAME\n--- ----------------------------\n");
do
{
int i;
for (i = 0; i < BF_MAIN_MAX_NUM_OF_RECS; i++)
{
athleteId = * (int *) athletesBlockBuf;
athletesBlockBuf += sizeof(int);
strcpy(athleteName, athletesBlockBuf);
athletesBlockBuf += BF_MAIN_NAME_SIZE;
strcpy(athleteSurName, athletesBlockBuf);
athletesBlockBuf += BF_MAIN_NAME_SIZE;
if (strlen(athleteName) == 0) break;
printf("%03d %s %s\n", athleteId, athleteName, athleteSurName);
}
BF_UnpinBlock(athletesFd, athletesBlockNum, FALSE);
} while(BF_GetNextBlock(athletesFd, &athletesBlockNum, &athletesBlockBuf) == BFE_OK);
printf("\n**********************\n\n");
/* Κλείσιμο του αρχείου ATHLETES. */
if (BF_CloseFile(athletesFd) < 0)
BF_PrintError("Error in BF_CloseFile called on ATHLETES.");
/* Σβήσιμο των τριών αρχείων */
if (BF_DestroyFile("EVENTS") != BFE_OK)
BF_PrintError("Error in BF_DestroyFile called on EVENTS.");
else printf("File EVENTS successfully destroyed.\n");
if (BF_DestroyFile("ATHLETES") != BFE_OK)
BF_PrintError("Error in BF_DestroyFile called on ATHLETES.");
else printf("File ATHLETES successfully destroyed.\n");
if (BF_DestroyFile("PARTICIPATIONS") != BFE_OK)
BF_PrintError("Error in BF_DestroyFile called on PARTICIPATIONS.");
else printf("File PARTICIPATIONS successfully destroyed.\n");
return 0;
}
/*
================
SV_SpawnServer
Change the server to a new map, taking all connected
clients along with it.
================
*/
qboolean SV_SpawnServer( const char *mapname, const char *startspot )
{
int i, current_skill;
qboolean loadgame, paused;
qboolean background, changelevel;
// save state
loadgame = sv.loadgame;
background = sv.background;
changelevel = sv.changelevel;
paused = sv.paused;
if( sv.state == ss_dead )
SV_InitGame(); // the game is just starting
else if( !sv_maxclients->modified )
Cmd_ExecuteString( "latch\n", src_command );
else MsgDev( D_ERROR, "SV_SpawnServer: while 'maxplayers' was modified.\n" );
sv_maxclients->modified = false;
deathmatch->modified = false;
teamplay->modified = false;
coop->modified = false;
if( !svs.initialized )
return false;
svgame.globals->changelevel = false; // will be restored later if needed
svs.timestart = Sys_DoubleTime();
svs.spawncount++; // any partially connected client will be restarted
if( startspot )
{
MsgDev( D_INFO, "Spawn Server: %s [%s]\n", mapname, startspot );
}
else
{
MsgDev( D_INFO, "Spawn Server: %s\n", mapname );
}
sv.state = ss_dead;
Host_SetServerState( sv.state );
Q_memset( &sv, 0, sizeof( sv )); // wipe the entire per-level structure
// restore state
sv.paused = paused;
sv.loadgame = loadgame;
sv.background = background;
sv.changelevel = changelevel;
sv.time = 1.0f; // server spawn time it's always 1.0 second
svgame.globals->time = sv.time;
// initialize buffers
BF_Init( &sv.datagram, "Datagram", sv.datagram_buf, sizeof( sv.datagram_buf ));
BF_Init( &sv.reliable_datagram, "Datagram R", sv.reliable_datagram_buf, sizeof( sv.reliable_datagram_buf ));
BF_Init( &sv.multicast, "Multicast", sv.multicast_buf, sizeof( sv.multicast_buf ));
BF_Init( &sv.signon, "Signon", sv.signon_buf, sizeof( sv.signon_buf ));
BF_Init( &sv.spectator_datagram, "Spectator Datagram", sv.spectator_buf, sizeof( sv.spectator_buf ));
// leave slots at start for clients only
for( i = 0; i < sv_maxclients->integer; i++ )
{
// needs to reconnect
if( svs.clients[i].state > cs_connected )
svs.clients[i].state = cs_connected;
}
// make cvars consistant
if( Cvar_VariableInteger( "coop" )) Cvar_SetFloat( "deathmatch", 0 );
current_skill = (int)(Cvar_VariableValue( "skill" ) + 0.5f);
current_skill = bound( 0, current_skill, 3 );
Cvar_SetFloat( "skill", (float)current_skill );
if( sv.background )
{
// tell the game parts about background state
Cvar_FullSet( "sv_background", "1", CVAR_READ_ONLY );
Cvar_FullSet( "cl_background", "1", CVAR_READ_ONLY );
}
else
{
Cvar_FullSet( "sv_background", "0", CVAR_READ_ONLY );
Cvar_FullSet( "cl_background", "0", CVAR_READ_ONLY );
}
// make sure what server name doesn't contain path and extension
FS_FileBase( mapname, sv.name );
if( startspot )
Q_strncpy( sv.startspot, startspot, sizeof( sv.startspot ));
else sv.startspot[0] = '\0';
Q_snprintf( sv.model_precache[1], sizeof( sv.model_precache[0] ), "maps/%s.bsp", sv.name );
Mod_LoadWorld( sv.model_precache[1], &sv.checksum, false );
sv.worldmodel = Mod_Handle( 1 ); // get world pointer
for( i = 1; i < sv.worldmodel->numsubmodels; i++ )
{
Q_sprintf( sv.model_precache[i+1], "*%i", i );
Mod_RegisterModel( sv.model_precache[i+1], i+1 );
}
// precache and static commands can be issued during map initialization
sv.state = ss_loading;
Host_SetServerState( sv.state );
// clear physics interaction links
SV_ClearWorld();
// tell dlls about new level started
svgame.dllFuncs.pfnParmsNewLevel();
return true;
}
/*
=================
SV_ReadPackets
=================
*/
void SV_ReadPackets( void )
{
sv_client_t *cl;
int i, qport, curSize;
while( NET_GetPacket( NS_SERVER, &net_from, net_message_buffer, &curSize ))
{
BF_Init( &net_message, "ClientPacket", net_message_buffer, curSize );
// check for connectionless packet (0xffffffff) first
if( BF_GetMaxBytes( &net_message ) >= 4 && *(int *)net_message.pData == -1 )
{
SV_ConnectionlessPacket( net_from, &net_message );
continue;
}
// read the qport out of the message so we can fix up
// stupid address translating routers
BF_Clear( &net_message );
BF_ReadLong( &net_message ); // sequence number
BF_ReadLong( &net_message ); // sequence number
qport = (int)BF_ReadShort( &net_message ) & 0xffff;
// check for packets from connected clients
for( i = 0, cl = svs.clients; i < sv_maxclients->integer; i++, cl++ )
{
if( cl->state == cs_free || cl->fakeclient )
continue;
if( !NET_CompareBaseAdr( net_from, cl->netchan.remote_address ))
continue;
if( cl->netchan.qport != qport )
continue;
if( cl->netchan.remote_address.port != net_from.port )
{
MsgDev( D_INFO, "SV_ReadPackets: fixing up a translated port\n");
cl->netchan.remote_address.port = net_from.port;
}
if( Netchan_Process( &cl->netchan, &net_message ))
{
cl->send_message = true; // reply at end of frame
// this is a valid, sequenced packet, so process it
if( cl->state != cs_zombie )
{
cl->lastmessage = host.realtime; // don't timeout
SV_ExecuteClientMessage( cl, &net_message );
svgame.globals->frametime = host.frametime;
svgame.globals->time = sv.time;
}
}
// fragmentation/reassembly sending takes priority over all game messages, want this in the future?
if( Netchan_IncomingReady( &cl->netchan ))
{
if( Netchan_CopyNormalFragments( &cl->netchan, &net_message ))
{
BF_Clear( &net_message );
SV_ExecuteClientMessage( cl, &net_message );
}
if( Netchan_CopyFileFragments( &cl->netchan, &net_message ))
{
SV_ProcessFile( cl, cl->netchan.incomingfilename );
}
}
break;
}
if( i != sv_maxclients->integer )
continue;
}
}
/*
===============
SV_Init
Only called at startup, not for each game
===============
*/
void SV_Init( void )
{
SV_InitOperatorCommands();
skill = Cvar_Get ("skill", "1", CVAR_LATCH, "game skill level" );
deathmatch = Cvar_Get ("deathmatch", "0", CVAR_LATCH|CVAR_SERVERINFO, "displays deathmatch state" );
teamplay = Cvar_Get ("teamplay", "0", CVAR_LATCH|CVAR_SERVERINFO, "displays teamplay state" );
coop = Cvar_Get ("coop", "0", CVAR_LATCH|CVAR_SERVERINFO, "displays cooperative state" );
Cvar_Get ("protocol", va( "%i", PROTOCOL_VERSION ), CVAR_INIT, "displays server protocol version" );
Cvar_Get ("defaultmap", "", CVAR_SERVERNOTIFY, "holds the multiplayer mapname" );
Cvar_Get ("showtriggers", "0", CVAR_LATCH, "debug cvar shows triggers" );
Cvar_Get ("sv_aim", "0", CVAR_ARCHIVE, "enable auto-aiming" );
Cvar_Get ("mapcyclefile", "mapcycle.txt", 0, "name of multiplayer map cycle configuration file" );
Cvar_Get ("servercfgfile","server.cfg", 0, "name of dedicated server configuration file" );
Cvar_Get ("lservercfgfile","listenserver.cfg", 0, "name of listen server configuration file" );
Cvar_Get ("motdfile", "motd.txt", 0, "name of 'message of the day' file" );
Cvar_Get ("sv_language", "0", 0, "game language (currently unused)" );
Cvar_Get ("suitvolume", "0.25", CVAR_ARCHIVE, "HEV suit volume" );
Cvar_Get ("sv_background", "0", CVAR_READ_ONLY, "indicate what background map is running" );
Cvar_Get( "gamedir", GI->gamefolder, CVAR_SERVERINFO|CVAR_SERVERNOTIFY|CVAR_INIT, "game folder" );
Cvar_Get( "sv_alltalk", "1", 0, "allow to talking for all players (legacy, unused)" );
Cvar_Get( "sv_airmove", "1", CVAR_SERVERNOTIFY, "enable airmovement (legacy, unused)" );
Cvar_Get( "mp_autocrosshair", "0", 0, "allow auto crosshair in multiplayer (legacy, unused)" );
Cvar_Get( "sv_allow_PhysX", "1", CVAR_ARCHIVE, "allow XashXT to usage PhysX engine" ); //XashXT cvar
Cvar_Get( "sv_precache_meshes", "1", CVAR_ARCHIVE, "cache SOLID_CUSTOM meshes before level loading" ); // Paranoia 2 cvar
Cvar_Get( "mp_allowmonsters", "0", CVAR_SERVERNOTIFY | CVAR_LATCH, "allow auto monsters in multiplayer" );
// half-life shared variables
sv_zmax = Cvar_Get ("sv_zmax", "4096", CVAR_PHYSICINFO, "zfar server value" );
sv_wateramp = Cvar_Get ("sv_wateramp", "0", CVAR_PHYSICINFO, "global water wave height" );
sv_skycolor_r = Cvar_Get ("sv_skycolor_r", "255", CVAR_PHYSICINFO, "skycolor red" );
sv_skycolor_g = Cvar_Get ("sv_skycolor_g", "255", CVAR_PHYSICINFO, "skycolor green" );
sv_skycolor_b = Cvar_Get ("sv_skycolor_b", "255", CVAR_PHYSICINFO, "skycolor blue" );
sv_skyvec_x = Cvar_Get ("sv_skyvec_x", "0", CVAR_PHYSICINFO, "skylight direction x" );
sv_skyvec_y = Cvar_Get ("sv_skyvec_y", "0", CVAR_PHYSICINFO, "skylight direction y" );
sv_skyvec_z = Cvar_Get ("sv_skyvec_z", "0", CVAR_PHYSICINFO, "skylight direction z" );
sv_skyname = Cvar_Get ("sv_skyname", "desert", CVAR_PHYSICINFO, "skybox name (can be dynamically changed in-game)" );
sv_skydir_x = Cvar_Get ("sv_skydir_x", "0", CVAR_PHYSICINFO, "sky rotation direction x" );
sv_skydir_y = Cvar_Get ("sv_skydir_y", "0", CVAR_PHYSICINFO, "sky rotation direction y" );
sv_skydir_z = Cvar_Get ("sv_skydir_z", "1", CVAR_PHYSICINFO, "sky rotation direction z" ); // g-cont. add default sky rotate direction
sv_skyangle = Cvar_Get ("sv_skyangle", "0", CVAR_PHYSICINFO, "skybox rotational angle (in degrees)" );
sv_skyspeed = Cvar_Get ("sv_skyspeed", "0", 0, "skybox rotational speed" );
sv_footsteps = Cvar_Get ("mp_footsteps", "1", CVAR_PHYSICINFO, "can hear footsteps from other players" );
sv_wateralpha = Cvar_Get ("sv_wateralpha", "1", CVAR_PHYSICINFO, "world surfaces water transparency factor. 1.0 - solid, 0.0 - fully transparent" );
rcon_password = Cvar_Get( "rcon_password", "", 0, "remote connect password" );
sv_stepsize = Cvar_Get( "sv_stepsize", "18", CVAR_ARCHIVE|CVAR_PHYSICINFO, "how high you can step up" );
sv_newunit = Cvar_Get( "sv_newunit", "0", 0, "sets to 1 while new unit is loading" );
hostname = Cvar_Get( "hostname", "unnamed", CVAR_SERVERNOTIFY|CVAR_SERVERNOTIFY|CVAR_ARCHIVE, "host name" );
timeout = Cvar_Get( "timeout", "125", CVAR_SERVERNOTIFY, "connection timeout" );
zombietime = Cvar_Get( "zombietime", "2", CVAR_SERVERNOTIFY, "timeout for clients-zombie (who died but not respawned)" );
sv_pausable = Cvar_Get( "pausable", "1", CVAR_SERVERNOTIFY, "allow players to pause or not" );
sv_allow_studio_attachment_angles = Cvar_Get( "sv_allow_studio_attachment_angles", "0", CVAR_ARCHIVE, "enable calc angles for attachment points (on studio models)" );
sv_allow_rotate_pushables = Cvar_Get( "sv_allow_rotate_pushables", "0", CVAR_ARCHIVE, "let the pushers rotate pushables with included origin-brush" );
sv_validate_changelevel = Cvar_Get( "sv_validate_changelevel", "1", CVAR_ARCHIVE, "test change level for level-designer errors" );
sv_clienttrace = Cvar_Get( "sv_clienttrace", "1", CVAR_SERVERNOTIFY, "scaling factor for client hitboxes" );
sv_wallbounce = Cvar_Get( "sv_wallbounce", "1.0", CVAR_PHYSICINFO, "bounce factor for client with MOVETYPE_BOUNCE" );
sv_spectatormaxspeed = Cvar_Get( "sv_spectatormaxspeed", "500", CVAR_PHYSICINFO, "spectator maxspeed" );
sv_waterfriction = Cvar_Get( "sv_waterfriction", "1", CVAR_PHYSICINFO, "how fast you slow down in water" );
sv_wateraccelerate = Cvar_Get( "sv_wateraccelerate", "10", CVAR_PHYSICINFO, "rate at which a player accelerates to sv_maxspeed while in the water" );
sv_rollangle = Cvar_Get( "sv_rollangle", "0", CVAR_PHYSICINFO, "how much to tilt the view when strafing" );
sv_rollspeed = Cvar_Get( "sv_rollspeed", "200", CVAR_PHYSICINFO, "how much strafing is necessary to tilt the view" );
sv_airaccelerate = Cvar_Get("sv_airaccelerate", "10", CVAR_PHYSICINFO, "player accellerate in air" );
sv_maxvelocity = Cvar_Get( "sv_maxvelocity", "2000", CVAR_PHYSICINFO, "max world velocity" );
sv_gravity = Cvar_Get( "sv_gravity", "800", CVAR_PHYSICINFO, "world gravity" );
sv_maxspeed = Cvar_Get( "sv_maxspeed", "320", CVAR_PHYSICINFO, "maximum speed a player can accelerate to when on ground");
sv_accelerate = Cvar_Get( "sv_accelerate", "10", CVAR_PHYSICINFO, "rate at which a player accelerates to sv_maxspeed" );
sv_friction = Cvar_Get( "sv_friction", "4", CVAR_PHYSICINFO, "how fast you slow down" );
sv_edgefriction = Cvar_Get( "edgefriction", "2", CVAR_PHYSICINFO, "how much you slow down when nearing a ledge you might fall off" );
sv_stopspeed = Cvar_Get( "sv_stopspeed", "100", CVAR_PHYSICINFO, "how fast you come to a complete stop" );
sv_maxclients = Cvar_Get( "maxplayers", "1", CVAR_LATCH|CVAR_SERVERNOTIFY, "server clients limit" );
sv_check_errors = Cvar_Get( "sv_check_errors", "0", CVAR_ARCHIVE, "check edicts for errors" );
physinfo = Cvar_Get( "@physinfo", "0", CVAR_READ_ONLY, "" ); // use ->modified value only
serverinfo = Cvar_Get( "@serverinfo", "0", CVAR_READ_ONLY, "" ); // use ->modified value only
public_server = Cvar_Get ("public", "0", 0, "change server type from private to public" );
sv_lighting_modulate = Cvar_Get( "r_lighting_modulate", "0.6", CVAR_ARCHIVE, "lightstyles modulate scale" );
sv_reconnect_limit = Cvar_Get ("sv_reconnect_limit", "3", CVAR_ARCHIVE, "max reconnect attempts" );
sv_failuretime = Cvar_Get( "sv_failuretime", "0.5", 0, "after this long without a packet from client, don't send any more until client starts sending again" );
sv_unlag = Cvar_Get( "sv_unlag", "1", 0, "allow lag compensation on server-side" );
sv_maxunlag = Cvar_Get( "sv_maxunlag", "0.5", 0, "max latency which can be interpolated" );
sv_unlagpush = Cvar_Get( "sv_unlagpush", "0.0", 0, "unlag push bias" );
sv_unlagsamples = Cvar_Get( "sv_unlagsamples", "1", 0, "max samples to interpolate" );
sv_allow_upload = Cvar_Get( "sv_allow_upload", "1", 0, "allow uploading custom resources from clients" );
sv_allow_download = Cvar_Get( "sv_allow_download", "1", 0, "allow download missed resources to clients" );
sv_send_logos = Cvar_Get( "sv_send_logos", "1", 0, "send custom player decals to other clients" );
sv_send_resources = Cvar_Get( "sv_send_resources", "1", 0, "send generic resources that specified in 'mapname.res'" );
sv_sendvelocity = Cvar_Get( "sv_sendvelocity", "1", CVAR_ARCHIVE, "force to send velocity for event_t structure across network" );
sv_quakehulls = Cvar_Get( "sv_quakehulls", "0", CVAR_ARCHIVE, "using quake style hull select instead of half-life style hull select" );
mp_consistency = Cvar_Get( "mp_consistency", "1", CVAR_SERVERNOTIFY, "enbale consistency check in multiplayer" );
clockwindow = Cvar_Get( "clockwindow", "0.5", 0, "timewindow to execute client moves" );
sv_novis = Cvar_Get( "sv_novis", "0", 0, "force to ignore server visibility" );
SV_ClearSaveDir (); // delete all temporary *.hl files
BF_Init( &net_message, "NetMessage", net_message_buffer, sizeof( net_message_buffer ));
}
