930 lines
21 KiB
C
930 lines
21 KiB
C
/*
|
|
===========================================================================
|
|
Copyright (C) 1999-2005 Id Software, Inc.
|
|
Copyright (C) 2007 HermitWorks Entertainment Corporation
|
|
|
|
This file is part of the Space Trader source code.
|
|
|
|
The Space Trader source code is free software; you can redistribute it
|
|
and/or modify it under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation; either version 2 of the License,
|
|
or (at your option) any later version.
|
|
|
|
The Space Trader source code is distributed in the hope that it will be
|
|
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with the Space Trader source code; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "client.h"
|
|
|
|
#include "../botlib/botlib.h"
|
|
|
|
extern botlib_export_t *botlib_export;
|
|
|
|
extern sqlInfo_t com_db;
|
|
|
|
vm_t *uivm;
|
|
|
|
/*
|
|
====================
|
|
GetClientState
|
|
====================
|
|
*/
|
|
static void GetClientState( uiClientState_t *state ) {
|
|
state->connectPacketCount = clc.connectPacketCount;
|
|
state->connState = cls.state;
|
|
Q_strncpyz( state->servername, cls.servername, sizeof( state->servername ) );
|
|
Q_strncpyz( state->updateInfoString, cls.updateInfoString, sizeof( state->updateInfoString ) );
|
|
Q_strncpyz( state->messageString, clc.serverMessage, sizeof( state->messageString ) );
|
|
state->clientNum = cl.snap.ps.clientNum;
|
|
}
|
|
|
|
/*
|
|
=======================
|
|
LAN_UpdateVisiblePings
|
|
=======================
|
|
*/
|
|
qboolean LAN_UpdateVisiblePings(int source ) {
|
|
return CL_UpdateVisiblePings_f(source);
|
|
}
|
|
|
|
/*
|
|
====================
|
|
LAN_GetServerStatus
|
|
====================
|
|
*/
|
|
int LAN_GetServerStatus( char *serverAddress, char *serverStatus, int maxLen ) {
|
|
return CL_ServerStatus( serverAddress, serverStatus, maxLen );
|
|
}
|
|
|
|
/*
|
|
====================
|
|
CL_GetGlConfig
|
|
====================
|
|
*/
|
|
static void CL_GetGlconfig( vidConfig_t *config ) {
|
|
*config = cls.glconfig;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
QGetClipboardData
|
|
====================
|
|
*/
|
|
static void QGetClipboardData( char *buf, int buflen ) {
|
|
char *cbd;
|
|
|
|
cbd = Sys_GetClipboardData();
|
|
|
|
if ( !cbd ) {
|
|
*buf = 0;
|
|
return;
|
|
}
|
|
|
|
Q_strncpyz( buf, cbd, buflen );
|
|
|
|
Z_Free( cbd );
|
|
}
|
|
|
|
/*
|
|
====================
|
|
Key_KeynumToStringBuf
|
|
====================
|
|
*/
|
|
static void Key_KeynumToStringBuf( int keynum, char *buf, int buflen ) {
|
|
Q_strncpyz( buf, Key_KeynumToString( keynum ), buflen );
|
|
}
|
|
|
|
/*
|
|
====================
|
|
Key_GetBindingBuf
|
|
====================
|
|
*/
|
|
static void Key_GetBindingBuf( int keynum, char *buf, int buflen ) {
|
|
char *value;
|
|
|
|
value = Key_GetBinding( keynum );
|
|
if ( value ) {
|
|
Q_strncpyz( buf, value, buflen );
|
|
}
|
|
else {
|
|
*buf = 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
====================
|
|
Key_GetCatcher
|
|
====================
|
|
*/
|
|
int Key_GetCatcher( void ) {
|
|
return cls.keyCatchers;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
Ket_SetCatcher
|
|
====================
|
|
*/
|
|
void Key_SetCatcher( int catcher ) {
|
|
cls.keyCatchers = catcher;
|
|
}
|
|
|
|
|
|
/*
|
|
====================
|
|
GetConfigString
|
|
====================
|
|
*/
|
|
static int GetConfigString(int index, char *buf, int size)
|
|
{
|
|
int offset;
|
|
|
|
if (index < 0 || index >= MAX_CONFIGSTRINGS)
|
|
return qfalse;
|
|
|
|
offset = cl.gameState.stringOffsets[index];
|
|
if (!offset) {
|
|
if( size ) {
|
|
buf[0] = 0;
|
|
}
|
|
return qfalse;
|
|
}
|
|
|
|
Q_strncpyz( buf, cl.gameState.stringData+offset, size);
|
|
|
|
return qtrue;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
FloatAsInt
|
|
====================
|
|
*/
|
|
static int FloatAsInt( float f ) {
|
|
fi_t t;
|
|
t.f = f;
|
|
return t.i;
|
|
}
|
|
|
|
int CL_UpdateGameState( globalState_t * gs )
|
|
{
|
|
if ( !cl.snap.valid )
|
|
return 0;
|
|
|
|
// copy game state to vm
|
|
Com_Memcpy( gs, &cl.snap.ps.gs, sizeof(globalState_t) );
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
CL_GetRadar
|
|
====================
|
|
*/
|
|
int CL_GetRadar( radarInfo_t *out_ents, int maxEnts, const radarFilter_t *filters, int numFilters, float range )
|
|
{
|
|
int i, c;
|
|
int count;
|
|
clSnapshot_t *clSnap;
|
|
float r2, invR, theta;
|
|
|
|
//if the frame is not valid, we can't return it
|
|
clSnap = &cl.snapshots[cl.snap.messageNum & PACKET_MASK];
|
|
if( !clSnap->valid )
|
|
return 0;
|
|
|
|
//if the entities in the frame have fallen out of their
|
|
//circular buffer, we can't return it
|
|
if( cl.parseEntitiesNum - clSnap->parseEntitiesNum >= MAX_PARSE_ENTITIES )
|
|
return 0;
|
|
|
|
count = clSnap->numEntities;
|
|
|
|
r2 = range * range;
|
|
invR = 1.0F / range;
|
|
|
|
theta = -DEG2RAD( cl.snap.ps.viewangles[YAW] + 90 );
|
|
|
|
c = 0;
|
|
for( i = 0; i < count; i++ )
|
|
{
|
|
int j;
|
|
|
|
entityState_t * e = cl.parseEntities + ((clSnap->parseEntitiesNum + i) & (MAX_PARSE_ENTITIES - 1));
|
|
|
|
float d;
|
|
float x = 0;
|
|
float y = 0;
|
|
|
|
for( j = 0; j < numFilters; j++ )
|
|
{
|
|
if( filters[j].type == e->eType )
|
|
{
|
|
float *pos = (float*)((byte*)e + filters[j].offset_to_pos);
|
|
x = pos[0];
|
|
y = pos[1];
|
|
|
|
out_ents[c].ent = *e;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( j == numFilters )
|
|
continue;
|
|
|
|
x = x - cl.snap.ps.origin[0];
|
|
y = y - cl.snap.ps.origin[1];
|
|
|
|
d = x * x + y * y;
|
|
|
|
if( d > r2 )
|
|
continue;
|
|
|
|
d = sqrtf( d );
|
|
|
|
out_ents[c].r = d * invR;
|
|
out_ents[c].theta = theta - atan2f( x, y );
|
|
|
|
c++;
|
|
|
|
if( c == maxEnts )
|
|
break;
|
|
}
|
|
|
|
return c;
|
|
}
|
|
|
|
void CL_DownloadProgress( void ) {
|
|
|
|
float const w = 4.0f;
|
|
float const h = 6.0f;
|
|
float const s = 2.0f;
|
|
vec4_t color = { 0.8f, 0.8f, 0.8f, 0.8f };
|
|
float rect[4];
|
|
int sofar,total;
|
|
int i;
|
|
float x;
|
|
|
|
sql_prepare( &com_db, "SELECT SUM(xfer), SUM(length) FROM openfiles;" );
|
|
|
|
if ( sql_step( &com_db ) ) {
|
|
|
|
sofar = sql_columnasint( &com_db, 0 );
|
|
total = sql_columnasint( &com_db, 1 );
|
|
|
|
if ( sofar != total && total > 0 && sofar < total ) {
|
|
|
|
rect[ 0 ] = Cvar_VariableValue( "com_downloadbar_x" );
|
|
rect[ 1 ] = Cvar_VariableValue( "com_downloadbar_y" );
|
|
rect[ 2 ] = Cvar_VariableValue( "com_downloadbar_w" );
|
|
rect[ 3 ] = Cvar_VariableValue( "com_downloadbar_h" );
|
|
|
|
if ( rect[ 2 ] > 0.0f && rect[ 3 ] > 0.0f ) {
|
|
char * rate = Cvar_VariableString( "com_downloaded_rate" );
|
|
int n = (int)(rect[2] / (w+s));
|
|
float p = (float)sofar / (float)total;
|
|
float r = p * n;
|
|
|
|
int c = (int)floorf( r );
|
|
|
|
r = r-c;
|
|
|
|
if ( cls.font ) {
|
|
CL_RenderText( rect, 0.3f, colorWhite, va("%d%%... %s kb/s", (int)(p*100), rate ), -1, TEXT_ALIGN_CENTER, TEXT_ALIGN_CENTER, TEXT_STYLE_SHADOWED, -1, 0, cls.font, 0 );
|
|
}
|
|
|
|
for ( i=0; i<c; i++ ) {
|
|
x = ((float)i)*(w+s);
|
|
SCR_FillSquareRect( rect[0] + x, rect[1]+rect[3]-h, w, h, color );
|
|
}
|
|
|
|
x = ((float)i)*(w+s);
|
|
color[3] *= r;
|
|
SCR_FillSquareRect( rect[0] + x, rect[1]+rect[3]-h, w, h, color );
|
|
}
|
|
}
|
|
}
|
|
sql_done( &com_db );
|
|
}
|
|
|
|
|
|
static void UI_Con_GetText( char *buf, int size, int c )
|
|
{
|
|
size_t len, cp, ofs;
|
|
const char *conText;
|
|
|
|
conText = Con_GetText( c );
|
|
len = strlen( conText );
|
|
|
|
if( len > size )
|
|
{
|
|
cp = size - 1;
|
|
ofs = len - cp;
|
|
}
|
|
else
|
|
{
|
|
cp = len;
|
|
ofs = 0;
|
|
}
|
|
|
|
memcpy( buf, conText + ofs, cp );
|
|
buf[len] = 0;
|
|
}
|
|
|
|
extern int select_from_server( const char * src, char * segment, char * buffer, int size );
|
|
|
|
/*
|
|
====================
|
|
CL_UISystemCalls
|
|
|
|
The ui module is making a system call
|
|
====================
|
|
*/
|
|
intptr_t CL_UISystemCalls( intptr_t *args ) {
|
|
switch( args[0] ) {
|
|
case UI_ERROR:
|
|
Com_Error( args[1], "%s", VMA(2) );
|
|
return 0;
|
|
|
|
case UI_PRINT:
|
|
Com_Printf( "%s", VMA(1) );
|
|
return 0;
|
|
|
|
case UI_MILLISECONDS:
|
|
return Sys_Milliseconds();
|
|
|
|
case UI_CVAR_REGISTER:
|
|
Cvar_Register( VMA(1), VMA(2), VMA(3), args[4] );
|
|
return 0;
|
|
|
|
case UI_CVAR_UPDATE:
|
|
Cvar_Update( VMA(1) );
|
|
return 0;
|
|
|
|
case UI_CVAR_SET:
|
|
Cvar_Set( VMA(1), VMA(2) );
|
|
return 0;
|
|
|
|
case UI_CVAR_VARIABLEVALUE:
|
|
return FloatAsInt( Cvar_VariableValue( VMA(1) ) );
|
|
|
|
case UI_CVAR_VARIABLEINT:
|
|
return Cvar_VariableIntegerValue( VMA(1) );
|
|
|
|
case UI_CVAR_VARIABLESTRINGBUFFER:
|
|
Cvar_VariableStringBuffer( VMA(1), VMA(2), args[3] );
|
|
return 0;
|
|
|
|
case UI_CVAR_SETVALUE:
|
|
Cvar_SetValue( VMA(1), VMF(2) );
|
|
return 0;
|
|
|
|
case UI_CVAR_RESET:
|
|
Cvar_Reset( VMA(1) );
|
|
return 0;
|
|
|
|
case UI_CVAR_CREATE:
|
|
Cvar_Get( VMA(1), VMA(2), args[3] );
|
|
return 0;
|
|
|
|
case UI_CVAR_INFOSTRINGBUFFER:
|
|
Cvar_InfoStringBuffer( args[1], VMA(2), args[3] );
|
|
return 0;
|
|
|
|
case UI_ARGC:
|
|
return Cmd_Argc();
|
|
|
|
case UI_ARGV:
|
|
Cmd_ArgvBuffer( args[1], VMA(2), args[3] );
|
|
return 0;
|
|
|
|
case UI_ARGVI:
|
|
return atoi( Cmd_Argv( args[1] ) );
|
|
|
|
case UI_CMD_EXECUTETEXT:
|
|
Cbuf_ExecuteText( args[1], VMA(2) );
|
|
return 0;
|
|
|
|
case UI_FS_FOPENFILE:
|
|
return FS_FOpenFileByMode( VMA(1), VMA(2), args[3] );
|
|
|
|
case UI_FS_READ:
|
|
FS_Read( VMA(1), args[2], args[3] );
|
|
return 0;
|
|
|
|
case UI_FS_WRITE:
|
|
FS_Write( VMA(1), args[2], args[3] );
|
|
return 0;
|
|
|
|
case UI_FS_FCLOSEFILE:
|
|
FS_FCloseFile( args[1] );
|
|
return 0;
|
|
|
|
case UI_FS_GETFILELIST:
|
|
return FS_GetFileList( VMA(1), VMA(2), (char*)args[3], VMA(3), args[4] );
|
|
|
|
case UI_FS_SEEK:
|
|
return FS_Seek( args[1], args[2], args[3] );
|
|
|
|
case UI_R_REGISTERMODEL:
|
|
return re.RegisterModel( VMA(1) );
|
|
|
|
case UI_R_REGISTERSKIN:
|
|
return re.RegisterSkin( VMA(1) );
|
|
|
|
case UI_R_REGISTERSHADER:
|
|
return re.RegisterShader( VMA(1) );
|
|
|
|
case UI_R_REGISTERSHADERNOMIP:
|
|
return re.RegisterShaderNoMip( VMA(1) );
|
|
|
|
case UI_R_CLEARSCENE:
|
|
re.ClearScene();
|
|
return 0;
|
|
|
|
case UI_R_BUILDPOSE:
|
|
{
|
|
animGroupTransition_t trans;
|
|
trans.animGroup = 0;
|
|
trans.interp = 0;
|
|
|
|
return re.BuildPose( args[1], VMA( 2 ), args[3], VMA( 4 ), args[5], NULL, 0, NULL, 0, &trans, 1 );
|
|
}
|
|
case UI_R_BUILDPOSE2:
|
|
return re.BuildPose( args[1], VMA( 2 ), 2, VMA( 3 ), 2, VMA( 4 ), 2, VMA( 5 ), 2, VMA( 6 ), 2 );
|
|
|
|
case UI_R_BUILDPOSE3:
|
|
return re.BuildPose( args[1], VMA( 2 ), 1, 0, 0, VMA( 3 ), 1, 0, 0, VMA( 4 ), 1 );
|
|
|
|
case UI_R_SHAPECREATE:
|
|
{
|
|
curve_t * c = VMA(1);
|
|
int n = args[3];
|
|
int i;
|
|
for( i = 0; i < n; i++ )
|
|
{
|
|
c[i].pts = (vec2_t*)VM_ArgPtr((intptr_t)c[i].pts);
|
|
c[i].uvs = (vec2_t*)VM_ArgPtr((intptr_t)c[i].uvs);
|
|
c[i].colors = (vec4_t*)VM_ArgPtr((intptr_t)c[i].colors);
|
|
c[i].indices = (short*)VM_ArgPtr((intptr_t)c[i].indices );
|
|
}
|
|
return re.ShapeCreate( c, VMA( 2 ), n );
|
|
}
|
|
|
|
case UI_R_SHAPEDRAW:
|
|
re.ShapeDraw( args[1], args[2], VMA(3) );
|
|
return 0;
|
|
|
|
case UI_R_SHAPEDRAWMULTI:
|
|
re.ShapeDrawMulti( VMA( 1 ), args[2], args[3] );
|
|
return 0;
|
|
|
|
case UI_R_ADDREFENTITYTOSCENE:
|
|
re.AddRefEntityToScene( VMA(1) );
|
|
return 0;
|
|
|
|
case UI_R_ADDPOLYTOSCENE:
|
|
re.AddPolyToScene( args[1], args[2], VMA(3), 1 );
|
|
return 0;
|
|
|
|
case UI_R_ADDLIGHTTOSCENE:
|
|
re.AddLightToScene( VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
|
|
return 0;
|
|
|
|
case UI_R_RENDERSCENE:
|
|
re.RenderScene( VMA(1) );
|
|
return 0;
|
|
|
|
case UI_R_SETCOLOR:
|
|
re.SetColor( VMA(1) );
|
|
return 0;
|
|
|
|
case UI_R_DRAWSTRETCHPIC:
|
|
re.DrawStretchPic( VMF( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), NULL, VMF( 5 ), VMF( 6 ), VMF( 7 ), VMF( 8 ), args[ 9 ] );
|
|
return 0;
|
|
|
|
case UI_R_DRAWSPRITE:
|
|
{
|
|
float * uv = VMA(6);
|
|
re.DrawStretchPic( VMF( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMA(5), uv[0],uv[1],uv[2],uv[3], args[ 7 ] );
|
|
} return 0;
|
|
|
|
case UI_R_RENDERTEXT:
|
|
CL_RenderText( VMA(1), VMF(2), VMA(3), VMA(4), args[5], (args[6])>>16, args[6]&0xFFFF, args[7], args[8], Key_GetOverstrikeMode()?'|':'_', args[9], VMA(10) );
|
|
return 0;
|
|
|
|
case UI_R_FLOWTEXT:
|
|
{
|
|
const char * offset = (const char *)args[5];
|
|
int i,n;
|
|
const char * text = VMA(5);
|
|
lineInfo_t * lines = (lineInfo_t*)VMA(9);
|
|
|
|
if ( text ) {
|
|
n = CL_RenderText_ExtractLines( VMA(1), VMF(2), VMA(3), VMA(4), text, args[6], args[7], VMF(8), lines, 0, args[10] );
|
|
|
|
if ( lines ) {
|
|
for ( i=0; i<n; i++ ) {
|
|
lines[ i ].text = offset + (lines[ i ].text - text);
|
|
}
|
|
}
|
|
} else
|
|
n = 0;
|
|
|
|
return n;
|
|
}
|
|
|
|
case UI_R_GETFONT:
|
|
memcpy( VMA(3), re.GetFontFromFontSet( args[1], VMF(2) ), sizeof(fontInfo_t) );
|
|
return 0;
|
|
|
|
case UI_R_ROUNDRECT:
|
|
SCR_FillRect( VMF(1), VMF(2), VMF(3), VMF(4), VMA(5), args[6] );
|
|
return 0;
|
|
|
|
case UI_R_MODELBOUNDS:
|
|
re.ModelBounds( args[1], VMA(2), VMA(3) );
|
|
return 0;
|
|
|
|
case UI_UPDATESCREEN:
|
|
SCR_UpdateScreen();
|
|
return 0;
|
|
|
|
case UI_CM_LERPTAG:
|
|
re.LerpTag( VMA(1), args[2], args[3], args[4], VMF(5), VMA(6) );
|
|
return 0;
|
|
|
|
case UI_S_REGISTERSOUND:
|
|
return S_RegisterSound( VMA(1), args[2] );
|
|
|
|
case UI_S_STARTLOCALSOUND:
|
|
S_StartLocalSound( args[1], args[2] );
|
|
return 0;
|
|
|
|
case UI_KEY_KEYNUMTOSTRINGBUF:
|
|
Key_KeynumToStringBuf( args[1], VMA(2), args[3] );
|
|
return 0;
|
|
|
|
case UI_KEY_GETBINDINGBUF:
|
|
Key_GetBindingBuf( args[1], VMA(2), args[3] );
|
|
return 0;
|
|
|
|
case UI_KEY_SETBINDING:
|
|
Key_SetBinding( args[1], VMA(2) );
|
|
return 0;
|
|
|
|
case UI_KEY_ISDOWN:
|
|
return Key_IsDown( args[1] );
|
|
|
|
case UI_KEY_GETOVERSTRIKEMODE:
|
|
return Key_GetOverstrikeMode();
|
|
|
|
case UI_KEY_SETOVERSTRIKEMODE:
|
|
Key_SetOverstrikeMode( args[1] );
|
|
return 0;
|
|
|
|
case UI_KEY_CLEARSTATES:
|
|
Key_ClearStates();
|
|
return 0;
|
|
|
|
case UI_KEY_GETCATCHER:
|
|
return Key_GetCatcher();
|
|
|
|
case UI_KEY_SETCATCHER:
|
|
Key_SetCatcher( args[1] );
|
|
return 0;
|
|
case UI_KEY_GETKEY:
|
|
return Key_GetKey( VMA(1) );
|
|
|
|
case UI_GETCLIPBOARDDATA:
|
|
QGetClipboardData( VMA(1), args[2] );
|
|
return 0;
|
|
|
|
case UI_GETCLIENTSTATE:
|
|
GetClientState( VMA(1) );
|
|
return 0;
|
|
|
|
case UI_GETCLIENTNUM:
|
|
return cl.snap.ps.clientNum;
|
|
|
|
case UI_GETGLCONFIG:
|
|
CL_GetGlconfig( VMA(1) );
|
|
return 0;
|
|
|
|
case UI_GETCONFIGSTRING:
|
|
return GetConfigString( args[1], VMA(2), args[3] );
|
|
|
|
case UI_UPDATEGAMESTATE:
|
|
return CL_UpdateGameState( VMA(1) );
|
|
|
|
case UI_LAN_UPDATEVISIBLEPINGS:
|
|
return LAN_UpdateVisiblePings( args[1] );
|
|
|
|
case UI_LAN_SERVERSTATUS:
|
|
return LAN_GetServerStatus( VMA(1), VMA(2), args[3] );
|
|
|
|
case UI_MEMORY_REMAINING:
|
|
return Hunk_MemoryRemaining();
|
|
|
|
case UI_SET_PBCLSTATUS:
|
|
return 0;
|
|
|
|
case UI_R_REGISTERFONT:
|
|
return re.RegisterFont( VMA(1) );
|
|
|
|
case UI_R_GETFONTS:
|
|
re.GetFonts( VMA(1), args[2] );
|
|
return 0;
|
|
|
|
case UI_MEMSET:
|
|
Com_Memset( VMA(1), args[2], args[3] );
|
|
return 0;
|
|
|
|
case UI_MEMCPY:
|
|
Com_Memcpy( VMA(1), VMA(2), args[3] );
|
|
return 0;
|
|
|
|
case UI_STRNCPY:
|
|
strncpy( VMA(1), VMA(2), args[3] );
|
|
return args[1];
|
|
|
|
case UI_SIN:
|
|
return FloatAsInt( sin( VMF(1) ) );
|
|
|
|
case UI_COS:
|
|
return FloatAsInt( cos( VMF(1) ) );
|
|
|
|
case UI_ATAN2:
|
|
return FloatAsInt( atan2( VMF(1), VMF(2) ) );
|
|
|
|
case UI_SQRT:
|
|
return FloatAsInt( sqrt( VMF(1) ) );
|
|
|
|
case UI_FLOOR:
|
|
return FloatAsInt( floor( VMF(1) ) );
|
|
|
|
case UI_CEIL:
|
|
return FloatAsInt( ceil( VMF(1) ) );
|
|
|
|
case UI_ACOS: return FloatAsInt( acos( VMF(1) ) );
|
|
case UI_LOG: return FloatAsInt( log( VMF(1) ) );
|
|
case UI_POW: return FloatAsInt( pow( VMF(1), VMF(2) ) );
|
|
case UI_ATAN: return FloatAsInt( atan( VMF(1) ) );
|
|
case UI_FMOD: return FloatAsInt( fmod( VMF(1), VMF(2) ) );
|
|
case UI_TAN: return FloatAsInt( tan( VMF(1) ) );
|
|
|
|
case UI_PC_ADD_GLOBAL_DEFINE:
|
|
return botlib_export->PC_AddGlobalDefine( VMA(1) );
|
|
case UI_PC_LOAD_SOURCE:
|
|
return botlib_export->PC_LoadSourceHandle( VMA(1) );
|
|
case UI_PC_FREE_SOURCE:
|
|
return botlib_export->PC_FreeSourceHandle( args[1] );
|
|
case UI_PC_READ_TOKEN:
|
|
return botlib_export->PC_ReadTokenHandle( args[1], VMA(2) );
|
|
case UI_PC_SOURCE_FILE_AND_LINE:
|
|
return botlib_export->PC_SourceFileAndLine( args[1], VMA(2), VMA(3) );
|
|
|
|
case UI_S_STOPBACKGROUNDTRACK:
|
|
S_StopBackgroundTrack();
|
|
return 0;
|
|
case UI_S_STARTBACKGROUNDTRACK:
|
|
S_StartBackgroundTrack( VMA(1), VMA(2));
|
|
return 0;
|
|
|
|
case UI_REAL_TIME:
|
|
return Com_RealTime( VMA(1) );
|
|
|
|
case UI_CIN_PLAYCINEMATIC:
|
|
Com_DPrintf("UI_CIN_PlayCinematic\n");
|
|
return CIN_PlayCinematic(VMA(1), args[2], args[3], args[4], args[5], args[6]);
|
|
|
|
case UI_CIN_STOPCINEMATIC:
|
|
return CIN_StopCinematic(args[1]);
|
|
|
|
case UI_CIN_RUNCINEMATIC:
|
|
return CIN_RunCinematic(args[1]);
|
|
|
|
case UI_CIN_DRAWCINEMATIC:
|
|
CIN_DrawCinematic(args[1]);
|
|
return 0;
|
|
|
|
case UI_CIN_SETEXTENTS:
|
|
CIN_SetExtents(args[1], args[2], args[3], args[4], args[5]);
|
|
return 0;
|
|
|
|
case UI_R_REMAP_SHADER:
|
|
//ToDo: remove this trap!
|
|
return 0;
|
|
|
|
case UI_CON_PRINT:
|
|
return Con_Print( args[ 1 ], VMA( 2 ) );
|
|
|
|
case UI_CON_DRAW:
|
|
Con_Draw( args[ 1 ], VMF( 2 ), qfalse, qfalse );
|
|
return 0;
|
|
case UI_CON_HANDLEMOUSE:
|
|
Con_HandleMouse( args[ 1 ], VMF( 2 ), VMF( 3 ) );
|
|
return 0;
|
|
case UI_CON_HANDLEKEY:
|
|
Con_HandleKey( args[ 1 ], args[ 2 ] );
|
|
return 0;
|
|
case UI_CON_CLEAR:
|
|
Con_Clear( args[ 1 ] );
|
|
return 0;
|
|
case UI_CON_RESIZE:
|
|
Con_Resize( args[ 1 ], args[ 2 ], VMF( 3 ), VMF( 4 ), VMF( 5 ), VMF( 6 ) );
|
|
return 0;
|
|
|
|
case UI_CON_GETTEXT:
|
|
UI_Con_GetText( VMA( 1 ), args[2], args[3] );
|
|
return 0;
|
|
|
|
case UI_GET_RADAR:
|
|
return CL_GetRadar( VMA( 1 ), args[2], VMA( 3 ), args[4], VMF( 5 ) );
|
|
|
|
case UI_Q_rand:
|
|
return Rand_NextUInt32( &cl.db.rand );
|
|
|
|
case UI_SQL_LOADDB:
|
|
{
|
|
char * buffer;
|
|
int length;
|
|
char * file = VMA(1);
|
|
length = FS_ReadFile( file, &buffer );
|
|
if ( length <= 0 ) {
|
|
Com_Error( ERR_FATAL, "Can't open db: '%s'\n", file );
|
|
}
|
|
|
|
cl.db.create_filter = VMA(2);
|
|
|
|
sql_exec( &cl.db, buffer );
|
|
FS_FreeFile(buffer);
|
|
|
|
cl.db.create_filter = 0;
|
|
|
|
return 0;
|
|
} break;
|
|
|
|
case UI_SQL_EXEC: return sql_exec( &cl.db, VMA(1) );
|
|
case UI_SQL_PREPARE: return sql_prepare( &cl.db, VMA(1) ) != 0;
|
|
case UI_SQL_BIND: return sql_bind( &cl.db, args );
|
|
case UI_SQL_BINDTEXT: return sql_bindtext( &cl.db, args[1], VMA(2) );
|
|
case UI_SQL_BINDINT: return sql_bindint( &cl.db, args[1], args[2] );
|
|
case UI_SQL_BINDARGS:
|
|
{
|
|
int i,n = Cmd_Argc();
|
|
for ( i=1; i<n; i++ )
|
|
{
|
|
if ( !sql_bindtext( &cl.db, i, Cmd_Argv( i ) ) )
|
|
return 0;
|
|
}
|
|
|
|
} return 1;
|
|
|
|
case UI_SQL_STEP: return sql_step( &cl.db );
|
|
case UI_SQL_COLUMNCOUNT: return sql_columncount( &cl.db );
|
|
case UI_SQL_COLUMNASTEXT:
|
|
Q_strncpyz( VMA(1), sql_columnastext( &cl.db,args[3] ), args[2] );
|
|
break;
|
|
case UI_SQL_COLUMNASINT: return sql_columnasint( &cl.db, args[1] );
|
|
case UI_SQL_COLUMNNAME:
|
|
Q_strncpyz( VMA(1), sql_columnname( &cl.db, args[3] ), args[2] );
|
|
break;
|
|
case UI_SQL_DONE: return sql_done( &cl.db );
|
|
case UI_SQL_SELECT: return sql_select( &cl.db, VMA(1), (char*)args[2], VMA(2), args[3] );
|
|
case UI_SQL_COMPILE: return sql_compile( &cl.db, VMA(1) );
|
|
|
|
case UI_SQL_RUN:
|
|
{
|
|
char * buffer = VMA(1);
|
|
int size = args[2];
|
|
int id = args[3];
|
|
int i;
|
|
formatInfo_t * stmt = (formatInfo_t*)cl.db.stmts_byindex[ id ];
|
|
|
|
if ( stmt && id >= 0 && id < cl.db.stmts_byindex_count ) {
|
|
|
|
sqlData_t params[ 3 ];
|
|
const char * r;
|
|
|
|
for ( i=0; i<3; i++ ) {
|
|
|
|
params[ i ].format = INTEGER;
|
|
params[ i ].payload.integer = args[ 4+i ];
|
|
}
|
|
|
|
r = sql_eval( &cl.db, stmt->print, 0, 0, 0, 0, params, 0 ).string;
|
|
|
|
Q_strncpyz( buffer, r, size );
|
|
} else {
|
|
buffer[ 0 ] = '\0';
|
|
}
|
|
|
|
} break;
|
|
|
|
// give ui read access to file system info
|
|
case UI_SQL_SV_SELECT:
|
|
{
|
|
if ( com_sv_running->integer ) {
|
|
return select_from_server( VMA(1), (char*)args[2], VMA(2), args[3] );
|
|
}
|
|
} break;
|
|
|
|
|
|
default:
|
|
Com_Error( ERR_DROP, "Bad UI system trap: %i", args[0] );
|
|
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
CL_ShutdownUI
|
|
====================
|
|
*/
|
|
void CL_ShutdownUI( qboolean save_menustack ) {
|
|
cls.keyCatchers &= ~KEYCATCH_UI;
|
|
cls.uiStarted = qfalse;
|
|
if ( !uivm ) {
|
|
return;
|
|
}
|
|
VM_Call( uivm, UI_SHUTDOWN, save_menustack );
|
|
VM_Free( uivm );
|
|
uivm = NULL;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
CL_InitUI
|
|
====================
|
|
*/
|
|
void CL_InitUI( void ) {
|
|
int v;
|
|
vmInterpret_t interpret;
|
|
|
|
// dont start ui if no config file present
|
|
//if ( Cvar_VariableIntegerValue( "fs_noconfig" ) == 1 ) {
|
|
// return;
|
|
//}
|
|
|
|
// load the dll or bytecode
|
|
if ( cl_connectedToPureServer != 0 ) {
|
|
// if sv_pure is set we only allow qvms to be loaded
|
|
interpret = VMI_COMPILED;
|
|
}
|
|
else {
|
|
interpret = Cvar_VariableValue( "vm_ui" );
|
|
}
|
|
uivm = VM_Create( "ui", CL_UISystemCalls, interpret );
|
|
if ( uivm ) {
|
|
//Com_Error( ERR_FATAL, "VM_Create on UI failed" );
|
|
|
|
// sanity check
|
|
v = VM_Call( uivm, UI_GETAPIVERSION );
|
|
if (v != UI_API_VERSION) {
|
|
Com_Error( ERR_DROP, "User Interface is version %d, expected %d", v, UI_API_VERSION );
|
|
cls.uiStarted = qfalse;
|
|
}
|
|
else {
|
|
#ifdef USE_WEBAUTH
|
|
botlib_export->PC_AddGlobalDefine( "USE_WEBAUTH" );
|
|
#endif
|
|
|
|
// init for this gamestate
|
|
VM_Call( uivm, UI_INIT, (cls.state >= CA_AUTHORIZING && cls.state <= CA_ACTIVE), clc.clientNum );
|
|
}
|
|
|
|
#ifdef USE_WEBAUTH
|
|
// if the session id has something in it, then assume that the browser sent it from the
|
|
// command line and tell ui we're already logged in.
|
|
if ( com_sessionid->string[0] ) {
|
|
VM_Call( uivm, UI_AUTHORIZED, AUTHORIZE_OK );
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/*
|
|
====================
|
|
UI_GameCommand
|
|
|
|
See if the current console command is claimed by the ui
|
|
====================
|
|
*/
|
|
qboolean UI_GameCommand( void ) {
|
|
if ( !uivm ) {
|
|
return qfalse;
|
|
}
|
|
|
|
return VM_Call( uivm, UI_CONSOLE_COMMAND, cls.realtime );
|
|
}
|