void JNI(setColor)(JNIEnv *env, jclass* clazz, jint location, jint c, jfloat alpha)
{
if (alpha >= 1)
alpha = COLOR_A(c);
else if (alpha < 0)
alpha = 0;
else
alpha *= COLOR_A(c);
if (alpha == 1)
{
glUniform4f((GLint) location,
(GLfloat) COLOR_R(c),
(GLfloat) COLOR_G(c),
(GLfloat) COLOR_B(c),
(GLfloat) alpha);
}
else
{
glUniform4f((GLint) location,
(GLfloat) (COLOR_R(c) * alpha),
(GLfloat) (COLOR_G(c) * alpha),
(GLfloat) (COLOR_B(c) * alpha),
(GLfloat) alpha);
}
}
void JNI(setColorBlend)(JNIEnv *env, jclass* clazz, jint location, jint c1, jint c2, jfloat mix)
{
float a1 = COLOR_A(c1) * (1 - mix);
float a2 = COLOR_A(c2) * mix;
glUniform4f((GLint) location,
(GLfloat) (COLOR_R(c1) * a1 + COLOR_R(c2) * a2),
(GLfloat) (COLOR_G(c1) * a1 + COLOR_G(c2) * a2),
(GLfloat) (COLOR_B(c1) * a1 + COLOR_B(c2) * a2),
(GLfloat) (a1 + a2));
}
//==============
// CG_TeamColor
//==============
vec_t *CG_TeamColor( int team, vec4_t color )
{
cvar_t *teamForceColor = NULL;
int forcedteam;
forcedteam = CG_ForceTeam( cg.view.POVent, team ); // check all teams against the client
if( forcedteam < TEAM_PLAYERS || forcedteam >= GS_MAX_TEAMS ) // limit out of range and spectators team
forcedteam = TEAM_PLAYERS;
switch( forcedteam )
{
case TEAM_ALPHA:
teamForceColor = cg_teamALPHAcolor;
break;
case TEAM_BETA:
teamForceColor = cg_teamBETAcolor;
break;
case TEAM_PLAYERS:
default:
teamForceColor = cg_teamPLAYERScolor;
break;
}
if( teamForceColor->modified )
CG_RegisterTeamColor( forcedteam );
color[0] = COLOR_R( cgs.teamColor[forcedteam] ) * ( 1.0/255.0 );
color[1] = COLOR_G( cgs.teamColor[forcedteam] ) * ( 1.0/255.0 );
color[2] = COLOR_B( cgs.teamColor[forcedteam] ) * ( 1.0/255.0 );
color[3] = 1.0f;
return color;
}
static void M_GetTeamColor( void )
{
int rgbcolor;
menucommon_t *menuitem;
rgbcolor = COM_ReadColorRGBString( color->string );
if( rgbcolor == -1 )
{
rgbcolor = COM_ReadColorRGBString( color->dvalue );
}
if( rgbcolor != -1 )
{
Vector4Set( playerColor, COLOR_R( rgbcolor ), COLOR_G( rgbcolor ), COLOR_B( rgbcolor ), 255 );
}
else
{
Vector4Set( playerColor, 255, 255, 255, 255 ); // start white
}
// update the bars
menuitem = UI_MenuItemByName( "m_TeamConfig_colorred" );
menuitem->curvalue = playerColor[0];
menuitem = UI_MenuItemByName( "m_TeamConfig_colorgreen" );
menuitem->curvalue = playerColor[1];
menuitem = UI_MenuItemByName( "m_TeamConfig_colorblue" );
menuitem->curvalue = playerColor[2];
}
int WarpSpectrum(Canvas *c, EffectManager *em, char mode)
{
static uint8_t ci = 0;
static unsigned short pos[CANVAS_WIDTH];
static char currentMode = -1;
if(mode != currentMode){ // performed only once
switch(mode){
case EFFECTMODE_INTRO:
for(uint8_t x = 0; x < CANVAS_WIDTH; x++){
pos[x] = CANVAS_HM1;
for(uint8_t y = 0; y < CANVAS_HEIGHT; y++)
c->PutPixel(x, y, 0);
}
break;
}
currentMode = mode;
}
else{ // step
unsigned short *spectrum = em->GetSpectrum();
for(uint8_t x = 0; x < CANVAS_WIDTH; x++){
short spc = spectrum[(x >> 1) + 3];
if(spc > 800)
ci = MOD32(ci + 1);
pos[x] -= (spc - 150) * 10;
}
}
for(uint8_t x = 0; x < CANVAS_WIDTH; x++){
uint8_t px = pos[x] / 6554;
for(uint8_t y = 0; y < CANVAS_HEIGHT; y++){
if(y == px){ // shot of color
c->PutPixel(x, y, lerpColor(c->GetPixel(x, y), colorwheel_lut[ci], 0.5));
}
else if(y == px - 1 || y == px + 1){ // shot of color
c->PutPixel(x, y, lerpColor(c->GetPixel(x, y), colorwheel_lut[ci], 0.1));
}
else{ // fade out
Color_t px_color = c->GetPixel(x, y);
c->PutPixel(x, y, COLOR_B(
MAX(0, char(RED(px_color)) - 2),
MAX(0, char(GREEN(px_color)) - 2),
MAX(0, char(BLUE(px_color)) - 2)
));
}
}
}
return 1;
}
static void do_filter(AndroidBitmapInfo* info, void* pixels,
float intensity, Filter t)
{
int row;
for (row = 0; row < info->height; row++) {
uint32_t* line = (uint32_t*)pixels;
int col;
for (col = 0; col < info->width; col++) {
uint32_t color = line[col];
uint32_t a = COLOR_A(color);
uint8_t r = COLOR_R(color);
uint8_t g = COLOR_G(color);
uint8_t b = COLOR_B(color);
uint8_t lum = calcY(r, g, b);
switch(t) {
case ROSE:
{
line[col] = a | (lum << 16) | (g << 8) | b;
break;
}
case WEIRD:
{
line[col] = a | (r << 16) | (lum << 8) | lum;
break;
}
case CHILL:
{
uint8_t tint = (b - lum) * intensity;
line[col] = a | (r << 16) | (g << 8) | tint;
break;
}
default:
{
line[col] = a | (lum << 16) | (lum << 8) | lum;
break;
}
}
}
// go to next line
pixels = (char*)pixels + info->stride;
}
}
/**********************************************************************
* TABToolDefTable::WriteAllToolDefs()
*
* Write all tool definition structures to the TABMAPToolBlock.
*
* Note that at the end of this call, poBlock->CommitToFile() will have
* been called.
*
* Returns 0 on success, -1 on error.
**********************************************************************/
int TABToolDefTable::WriteAllToolDefs(TABMAPToolBlock *poBlock)
{
int i, nStatus = 0;
/*-----------------------------------------------------------------
* Write Pen Defs
*----------------------------------------------------------------*/
for(i=0; nStatus == 0 && i< m_numPen; i++)
{
// The pen width is encoded over 2 bytes
GByte byPixelWidth=1, byPointWidth=0;
if (m_papsPen[i]->nPointWidth > 0)
{
byPointWidth = (GByte)(m_papsPen[i]->nPointWidth & 0xff);
if (m_papsPen[i]->nPointWidth > 255)
byPixelWidth = 8 + (GByte)(m_papsPen[i]->nPointWidth/0x100);
}
else
byPixelWidth = MIN(MAX(m_papsPen[i]->nPixelWidth, 1), 7);
poBlock->CheckAvailableSpace(TABMAP_TOOL_PEN);
poBlock->WriteByte(TABMAP_TOOL_PEN); // Def Type = Pen
poBlock->WriteInt32(m_papsPen[i]->nRefCount);
poBlock->WriteByte(byPixelWidth);
poBlock->WriteByte(m_papsPen[i]->nLinePattern);
poBlock->WriteByte(byPointWidth);
poBlock->WriteByte(COLOR_R(m_papsPen[i]->rgbColor));
poBlock->WriteByte(COLOR_G(m_papsPen[i]->rgbColor));
poBlock->WriteByte(COLOR_B(m_papsPen[i]->rgbColor));
if (CPLGetLastErrorNo() != 0)
{
// An error happened reading this tool definition... stop now.
nStatus = -1;
}
}
/*-----------------------------------------------------------------
* Write Brush Defs
*----------------------------------------------------------------*/
for(i=0; nStatus == 0 && i< m_numBrushes; i++)
{
poBlock->CheckAvailableSpace(TABMAP_TOOL_BRUSH);
poBlock->WriteByte(TABMAP_TOOL_BRUSH); // Def Type = Brush
poBlock->WriteInt32(m_papsBrush[i]->nRefCount);
poBlock->WriteByte(m_papsBrush[i]->nFillPattern);
poBlock->WriteByte(m_papsBrush[i]->bTransparentFill);
poBlock->WriteByte(COLOR_R(m_papsBrush[i]->rgbFGColor));
poBlock->WriteByte(COLOR_G(m_papsBrush[i]->rgbFGColor));
poBlock->WriteByte(COLOR_B(m_papsBrush[i]->rgbFGColor));
poBlock->WriteByte(COLOR_R(m_papsBrush[i]->rgbBGColor));
poBlock->WriteByte(COLOR_G(m_papsBrush[i]->rgbBGColor));
poBlock->WriteByte(COLOR_B(m_papsBrush[i]->rgbBGColor));
if (CPLGetLastErrorNo() != 0)
{
// An error happened reading this tool definition... stop now.
nStatus = -1;
}
}
/*-----------------------------------------------------------------
* Write Font Defs
*----------------------------------------------------------------*/
for(i=0; nStatus == 0 && i< m_numFonts; i++)
{
poBlock->CheckAvailableSpace(TABMAP_TOOL_FONT);
poBlock->WriteByte(TABMAP_TOOL_FONT); // Def Type = Font name
poBlock->WriteInt32(m_papsFont[i]->nRefCount);
poBlock->WriteBytes(32, (GByte*)m_papsFont[i]->szFontName);
if (CPLGetLastErrorNo() != 0)
{
// An error happened reading this tool definition... stop now.
nStatus = -1;
}
}
/*-----------------------------------------------------------------
* Write Symbol Defs
*----------------------------------------------------------------*/
for(i=0; nStatus == 0 && i< m_numSymbols; i++)
{
poBlock->CheckAvailableSpace(TABMAP_TOOL_SYMBOL);
poBlock->WriteByte(TABMAP_TOOL_SYMBOL); // Def Type = Symbol
poBlock->WriteInt32(m_papsSymbol[i]->nRefCount);
poBlock->WriteInt16(m_papsSymbol[i]->nSymbolNo);
poBlock->WriteInt16(m_papsSymbol[i]->nPointSize);
poBlock->WriteByte(m_papsSymbol[i]->_nUnknownValue_);
poBlock->WriteByte(COLOR_R(m_papsSymbol[i]->rgbColor));
poBlock->WriteByte(COLOR_G(m_papsSymbol[i]->rgbColor));
poBlock->WriteByte(COLOR_B(m_papsSymbol[i]->rgbColor));
if (CPLGetLastErrorNo() != 0)
{
// An error happened reading this tool definition... stop now.
nStatus = -1;
}
}
if (nStatus == 0)
nStatus = poBlock->CommitToFile();
return nStatus;
}
/*
* ClientUserinfoChanged
* called whenever the player updates a userinfo variable.
*
* The game can override any of the settings in place
* (forcing skins or names, etc) before copying it off.
*/
void ClientUserinfoChanged( edict_t *ent, char *userinfo )
{
char *s;
char oldname[MAX_INFO_VALUE];
gclient_t *cl;
int rgbcolor, i;
assert( ent && ent->r.client );
assert( userinfo && Info_Validate( userinfo ) );
// check for malformed or illegal info strings
if( !Info_Validate( userinfo ) )
{
trap_DropClient( ent, DROP_TYPE_GENERAL, "Error: Invalid userinfo" );
return;
}
cl = ent->r.client;
// ip
s = Info_ValueForKey( userinfo, "ip" );
if( !s )
{
trap_DropClient( ent, DROP_TYPE_GENERAL, "Error: Server didn't provide client IP" );
return;
}
Q_strncpyz( cl->ip, s, sizeof( cl->ip ) );
// socket
s = Info_ValueForKey( userinfo, "socket" );
if( !s )
{
trap_DropClient( ent, DROP_TYPE_GENERAL, "Error: Server didn't provide client socket" );
return;
}
Q_strncpyz( cl->socket, s, sizeof( cl->socket ) );
// color
s = Info_ValueForKey( userinfo, "color" );
if( s )
rgbcolor = COM_ReadColorRGBString( s );
else
rgbcolor = -1;
if( rgbcolor != -1 )
{
rgbcolor = COM_ValidatePlayerColor( rgbcolor );
Vector4Set( cl->color, COLOR_R( rgbcolor ), COLOR_G( rgbcolor ), COLOR_B( rgbcolor ), 255 );
}
else
{
Vector4Set( cl->color, 255, 255, 255, 255 );
}
// set name, it's validated and possibly changed first
Q_strncpyz( oldname, cl->netname, sizeof( oldname ) );
G_SetName( ent, Info_ValueForKey( userinfo, "name" ) );
if( oldname[0] && Q_stricmp( oldname, cl->netname ) && !cl->isTV && !CheckFlood( ent, false ) )
G_PrintMsg( NULL, "%s%s is now known as %s%s\n", oldname, S_COLOR_WHITE, cl->netname, S_COLOR_WHITE );
if( !Info_SetValueForKey( userinfo, "name", cl->netname ) )
{
trap_DropClient( ent, DROP_TYPE_GENERAL, "Error: Couldn't set userinfo (name)" );
return;
}
// clan tag
G_SetClan( ent, Info_ValueForKey( userinfo, "clan" ) );
// handedness
s = Info_ValueForKey( userinfo, "hand" );
if( !s )
cl->hand = 2;
else
cl->hand = bound( atoi( s ), 0, 2 );
// handicap
s = Info_ValueForKey( userinfo, "handicap" );
if( s )
{
i = atoi( s );
if( i > 90 || i < 0 )
{
G_PrintMsg( ent, "Handicap must be defined in the [0-90] range.\n" );
cl->handicap = 0;
}
else
{
cl->handicap = i;
}
}
s = Info_ValueForKey( userinfo, "cg_movementStyle" );
if( s )
{
i = bound( atoi( s ), 0, GS_MAXBUNNIES - 1 );
if( trap_GetClientState( PLAYERNUM(ent) ) < CS_SPAWNED )
{
if( i != cl->movestyle )
cl->movestyle = cl->movestyle_latched = i;
}
else if( cl->movestyle_latched != cl->movestyle )
{
G_PrintMsg( ent, "A movement style change is already in progress. Please wait.\n" );
}
else if( i != cl->movestyle_latched )
{
cl->movestyle_latched = i;
if( cl->movestyle_latched != cl->movestyle )
{
edict_t *switcher;
switcher = G_Spawn();
switcher->think = think_MoveTypeSwitcher;
switcher->nextThink = level.time + 10000;
switcher->s.ownerNum = ENTNUM( ent );
G_PrintMsg( ent, "Movement style will change in 10 seconds.\n" );
}
}
}
// update the movement features depending on the movestyle
if( !G_ISGHOSTING( ent ) && g_allow_bunny->integer )
{
if( cl->movestyle == GS_CLASSICBUNNY )
cl->ps.pmove.stats[PM_STAT_FEATURES] &= ~PMFEAT_FWDBUNNY;
else
cl->ps.pmove.stats[PM_STAT_FEATURES] |= PMFEAT_FWDBUNNY;
}
s = Info_ValueForKey( userinfo, "cg_noAutohop" );
if( s && s[0] )
{
if( atoi( s ) != 0 )
cl->ps.pmove.stats[PM_STAT_FEATURES] &= ~PMFEAT_CONTINOUSJUMP;
else
cl->ps.pmove.stats[PM_STAT_FEATURES] |= PMFEAT_CONTINOUSJUMP;
}
#ifdef UCMDTIMENUDGE
s = Info_ValueForKey( userinfo, "cl_ucmdTimeNudge" );
if( !s )
{
cl->ucmdTimeNudge = 0;
}
else
{
cl->ucmdTimeNudge = atoi( s );
clamp( cl->ucmdTimeNudge, -MAX_UCMD_TIMENUDGE, MAX_UCMD_TIMENUDGE );
}
#endif
// mm session
// TODO: remove the key after storing it to gclient_t !
s = Info_ValueForKey( userinfo, "cl_mm_session" );
cl->mm_session = ( s == NULL ) ? 0 : atoi( s );
s = Info_ValueForKey( userinfo, "mmflags" );
cl->mmflags = ( s == NULL ) ? 0 : strtoul( s, NULL, 10 );
// tv
if( cl->isTV )
{
s = Info_ValueForKey( userinfo, "tv_port" );
cl->tv.port = s ? atoi( s ) : 0;
s = Info_ValueForKey( userinfo, "tv_port6" );
cl->tv.port6 = s ? atoi( s ) : 0;
s = Info_ValueForKey( userinfo, "max_cl" );
cl->tv.maxclients = s ? atoi( s ) : 0;
s = Info_ValueForKey( userinfo, "num_cl" );
cl->tv.numclients = s ? atoi( s ) : 0;
s = Info_ValueForKey( userinfo, "chan" );
cl->tv.channel = s ? atoi( s ) : 0;
}
if( !G_ISGHOSTING( ent ) && trap_GetClientState( PLAYERNUM( ent ) ) >= CS_SPAWNED )
G_Client_AssignTeamSkin( ent, userinfo );
// save off the userinfo in case we want to check something later
Q_strncpyz( cl->userinfo, userinfo, sizeof( cl->userinfo ) );
G_UpdatePlayerInfoString( PLAYERNUM( ent ) );
G_UpdateMMPlayerInfoString( PLAYERNUM( ent ) );
G_Gametype_ScoreEvent( cl, "userinfochanged", oldname );
}
qbyte *_ColorForEntity( int entNum, byte_vec4_t color, qboolean player )
{
centity_t *cent;
int team;
centity_t *owner;
cvar_t *teamForceColor = NULL;
int rgbcolor;
int *forceColor;
if( entNum < 1 || entNum >= MAX_EDICTS )
{
Vector4Set( color, 255, 255, 255, 255 );
return color;
}
owner = cent = &cg_entities[entNum];
if( cent->current.type == ET_CORPSE && cent->current.bodyOwner ) // it's a body
owner = &cg_entities[cent->current.bodyOwner];
team = CG_ForceTeam( owner->current.number, owner->current.team );
switch( team )
{
case TEAM_ALPHA:
{
teamForceColor = cg_teamALPHAcolor;
forceColor = &cgs.teamColor[TEAM_ALPHA];
}
break;
case TEAM_BETA:
{
teamForceColor = cg_teamBETAcolor;
forceColor = &cgs.teamColor[TEAM_BETA];
}
break;
case TEAM_PLAYERS:
default:
{
teamForceColor = cg_teamPLAYERScolor;
forceColor = &cgs.teamColor[TEAM_PLAYERS];
}
break;
}
if( teamForceColor->modified )
{
CG_RegisterTeamColor( team );
}
//if forced models is enabled or it is color forced team we do,
if( (teamForceColor->string[0] || team >= TEAM_ALPHA) && cent->current.type != ET_CORPSE )
{
// skin color to team color
rgbcolor = *forceColor;
Vector4Set( color, COLOR_R( rgbcolor ), COLOR_G( rgbcolor ), COLOR_B( rgbcolor ), 255 );
}
// user defined colors if it's a player
else if( ( player && ( owner->current.number - 1 < gs.maxclients ) ) && cent->current.type != ET_CORPSE )
{
Vector4Copy( cgs.clientInfo[owner->current.number - 1].color, color );
}
// Make corpses grey
else if ( cent->current.type == ET_CORPSE && cent->current.bodyOwner )
{
Vector4Set( color, 60, 60, 60, 60 );
}
else // white for everything else
{
Vector4Set( color, 255, 255, 255, 255 );
}
return color;
}
/*
* CG_EntityEvent
*/
void CG_EntityEvent( entity_state_t *ent, int ev, int parm, qboolean predicted )
{
//static orientation_t projection;
vec3_t dir;
qboolean viewer = ISVIEWERENTITY( ent->number );
vec4_t color;
int weapon = 0, fireMode = 0, count = 0;
if( viewer && ( ev < PREDICTABLE_EVENTS_MAX ) && ( predicted != cg.view.playerPrediction ) )
return;
switch( ev )
{
case EV_NONE:
default:
break;
// PREDICTABLE EVENTS
case EV_WEAPONACTIVATE:
CG_PModel_AddAnimation( ent->number, 0, TORSO_WEAPON_SWITCHIN, 0, EVENT_CHANNEL );
weapon = ( parm & ~EV_INVERSE );
fireMode = ( parm & EV_INVERSE ) ? FIRE_MODE_STRONG : FIRE_MODE_WEAK;
if( predicted )
{
cg_entities[ent->number].current.weapon = weapon;
if( fireMode == FIRE_MODE_STRONG )
cg_entities[ent->number].current.effects |= EF_STRONG_WEAPON;
CG_ViewWeapon_RefreshAnimation( &cg.weapon );
}
if( viewer )
cg.predictedWeaponSwitch = 0;
if( viewer )
trap_S_StartGlobalSound( CG_MediaSfx( cgs.media.sfxWeaponUp ), CHAN_AUTO, cg_volume_effects->value );
else
trap_S_StartFixedSound( CG_MediaSfx( cgs.media.sfxWeaponUp ), ent->origin, CHAN_AUTO, cg_volume_effects->value, ATTN_NORM );
break;
case EV_SMOOTHREFIREWEAPON: // the server never sends this event
if( predicted )
{
weapon = ( parm & ~EV_INVERSE );
fireMode = ( parm & EV_INVERSE ) ? FIRE_MODE_STRONG : FIRE_MODE_WEAK;
cg_entities[ent->number].current.weapon = weapon;
if( fireMode == FIRE_MODE_STRONG )
cg_entities[ent->number].current.effects |= EF_STRONG_WEAPON;
CG_ViewWeapon_RefreshAnimation( &cg.weapon );
if( weapon == WEAP_LASERGUN )
CG_Event_LaserBeam( ent->number, weapon, fireMode );
}
break;
case EV_FIREWEAPON:
weapon = ( parm & ~EV_INVERSE );
fireMode = ( parm & EV_INVERSE ) ? FIRE_MODE_STRONG : FIRE_MODE_WEAK;
if( predicted )
{
cg_entities[ent->number].current.weapon = weapon;
if( fireMode == FIRE_MODE_STRONG )
cg_entities[ent->number].current.effects |= EF_STRONG_WEAPON;
}
CG_FireWeaponEvent( ent->number, weapon, fireMode );
// riotgun bullets, electrobolt and instagun beams are predicted when the weapon is fired
if( predicted )
{
vec3_t origin;
if( ( weapon == WEAP_ELECTROBOLT
#ifndef ELECTROBOLT_TEST
&& fireMode == FIRE_MODE_STRONG
#endif
)
|| weapon == WEAP_INSTAGUN )
{
VectorCopy( cg.predictedPlayerState.pmove.origin, origin );
origin[2] += cg.predictedPlayerState.viewheight;
AngleVectors( cg.predictedPlayerState.viewangles, dir, NULL, NULL );
CG_Event_WeaponBeam( origin, dir, cg.predictedPlayerState.POVnum, weapon, fireMode );
}
else if( weapon == WEAP_RIOTGUN || weapon == WEAP_MACHINEGUN )
{
int seed = cg.predictedEventTimes[EV_FIREWEAPON] & 255;
VectorCopy( cg.predictedPlayerState.pmove.origin, origin );
origin[2] += cg.predictedPlayerState.viewheight;
AngleVectors( cg.predictedPlayerState.viewangles, dir, NULL, NULL );
if( weapon == WEAP_RIOTGUN )
CG_Event_FireRiotgun( origin, dir, weapon, fireMode, seed, cg.predictedPlayerState.POVnum );
else
CG_Event_FireMachinegun( origin, dir, weapon, fireMode, seed, cg.predictedPlayerState.POVnum );
}
else if( weapon == WEAP_LASERGUN )
{
CG_Event_LaserBeam( ent->number, weapon, fireMode );
}
}
break;
case EV_ELECTROTRAIL:
// check the owner for predicted case
if( ISVIEWERENTITY( parm ) && ( ev < PREDICTABLE_EVENTS_MAX ) && ( predicted != cg.view.playerPrediction ) )
return;
CG_Event_WeaponBeam( ent->origin, ent->origin2, parm, WEAP_ELECTROBOLT, ent->firemode );
break;
case EV_INSTATRAIL:
// check the owner for predicted case
if( ISVIEWERENTITY( parm ) && ( ev < PREDICTABLE_EVENTS_MAX ) && ( predicted != cg.view.playerPrediction ) )
return;
CG_Event_WeaponBeam( ent->origin, ent->origin2, parm, WEAP_INSTAGUN, FIRE_MODE_STRONG );
break;
case EV_FIRE_RIOTGUN:
case EV_FIRE_BULLET:
{
// check the owner for predicted case
if( ISVIEWERENTITY( ent->ownerNum ) && ( ev < PREDICTABLE_EVENTS_MAX ) && ( predicted != cg.view.playerPrediction ) )
return;
if( ev == EV_FIRE_RIOTGUN )
CG_Event_FireRiotgun( ent->origin, ent->origin2, ( ent->weapon & ~EV_INVERSE ),
( ent->weapon & EV_INVERSE ), parm, ent->ownerNum );
else
CG_Event_FireMachinegun( ent->origin, ent->origin2, ( ent->weapon & ~EV_INVERSE ),
( ent->weapon & EV_INVERSE ), parm, ent->ownerNum );
}
break;
case EV_NOAMMOCLICK:
if( viewer )
trap_S_StartGlobalSound( CG_MediaSfx( cgs.media.sfxWeaponUpNoAmmo ), CHAN_ITEM, cg_volume_effects->value );
else
trap_S_StartFixedSound( CG_MediaSfx( cgs.media.sfxWeaponUpNoAmmo ), ent->origin, CHAN_ITEM, cg_volume_effects->value, ATTN_IDLE );
break;
case EV_DASH:
CG_Event_Dash( ent, parm );
break;
case EV_WALLJUMP:
case EV_WALLJUMP_FAILED:
CG_Event_WallJump( ent, parm, ev );
break;
case EV_DOUBLEJUMP:
CG_Event_DoubleJump( ent, parm );
break;
case EV_JUMP:
CG_Event_Jump( ent, parm );
break;
case EV_JUMP_PAD:
CG_TouchJumpPad( ent->number );
break;
case EV_FALL:
CG_Event_Fall( ent, parm );
break;
// NON PREDICTABLE EVENTS
case EV_WEAPONDROP: // deactivate is not predictable
CG_PModel_AddAnimation( ent->number, 0, TORSO_WEAPON_SWITCHOUT, 0, EVENT_CHANNEL );
break;
case EV_SEXEDSOUND:
if( parm == 2 )
CG_SexedSound( ent->number, CHAN_AUTO, S_PLAYER_GASP, cg_volume_players->value );
else if( parm == 1 )
CG_SexedSound( ent->number, CHAN_AUTO, S_PLAYER_DROWN, cg_volume_players->value );
break;
case EV_PAIN:
CG_Event_Pain( ent, parm );
break;
case EV_DIE:
CG_Event_Die( ent, parm );
break;
case EV_GIB:
break;
case EV_EXPLOSION1:
CG_GenericExplosion( ent->origin, vec3_origin, FIRE_MODE_WEAK, parm * 8 );
break;
case EV_EXPLOSION2:
CG_GenericExplosion( ent->origin, vec3_origin, FIRE_MODE_STRONG, parm * 16 );
break;
case EV_GREEN_LASER:
CG_GreenLaser( ent->origin, ent->origin2 );
break;
case EV_PNODE:
color[0] = COLOR_R( ent->colorRGBA ) * ( 1.0 / 255.0 );
color[1] = COLOR_G( ent->colorRGBA ) * ( 1.0 / 255.0 );
color[2] = COLOR_B( ent->colorRGBA ) * ( 1.0 / 255.0 );
color[3] = COLOR_A( ent->colorRGBA ) * ( 1.0 / 255.0 );
CG_PLink( ent->origin, ent->origin2, color, parm );
break;
case EV_SPARKS:
ByteToDir( parm, dir );
if( ent->damage > 0 )
{
count = (int)( ent->damage * 0.25f );
clamp( count, 1, 10 );
}
else
count = 6;
CG_ParticleEffect( ent->origin, dir, 1.0f, 0.67f, 0.0f, count );
break;
case EV_BULLET_SPARKS:
ByteToDir( parm, dir );
CG_BulletExplosion( ent->origin, dir, NULL );
CG_ParticleEffect( ent->origin, dir, 1.0f, 0.67f, 0.0f, 6 );
trap_S_StartFixedSound( CG_MediaSfx( cgs.media.sfxRic[rand()&2] ), ent->origin, CHAN_AUTO,
cg_volume_effects->value, ATTN_STATIC );
break;
case EV_LASER_SPARKS:
ByteToDir( parm, dir );
CG_ParticleEffect2( ent->origin, dir,
COLOR_R( ent->colorRGBA ) * ( 1.0 / 255.0 ),
COLOR_G( ent->colorRGBA ) * ( 1.0 / 255.0 ),
COLOR_B( ent->colorRGBA ) * ( 1.0 / 255.0 ),
ent->eventCount );
break;
case EV_GESTURE:
CG_SexedSound( ent->number, CHAN_BODY, "*taunt", cg_volume_players->value );
break;
case EV_DROP:
CG_PModel_AddAnimation( ent->number, 0, TORSO_DROP, 0, EVENT_CHANNEL );
break;
case EV_SPOG:
CG_SmallPileOfGibs( ent->origin, parm, ent->origin2 );
break;
case EV_ITEM_RESPAWN:
cg_entities[ent->number].respawnTime = cg.time;
trap_S_StartRelativeSound( CG_MediaSfx( cgs.media.sfxItemRespawn ), ent->number, CHAN_AUTO,
cg_volume_effects->value, ATTN_IDLE );
break;
case EV_PLAYER_RESPAWN:
if( (unsigned)ent->ownerNum == cgs.playerNum + 1 )
{
CG_ResetKickAngles();
CG_ResetColorBlend();
CG_ResetDamageIndicator();
}
// fallthrough
case EV_PLAYER_TELEPORT_IN:
if( ISVIEWERENTITY( ent->ownerNum ) )
{
trap_S_StartGlobalSound( CG_MediaSfx( cgs.media.sfxTeleportIn ), CHAN_AUTO,
cg_volume_effects->value );
}
else
{
trap_S_StartFixedSound( CG_MediaSfx( cgs.media.sfxTeleportIn ), ent->origin, CHAN_AUTO,
cg_volume_effects->value, ATTN_NORM );
}
if( ent->ownerNum && ent->ownerNum < gs.maxclients + 1 )
cg_entities[ent->ownerNum].localEffects[LOCALEFFECT_EV_PLAYER_TELEPORT_IN] = cg.time;
break;
case EV_PLAYER_TELEPORT_OUT:
if( ISVIEWERENTITY( ent->ownerNum ) )
{
trap_S_StartGlobalSound( CG_MediaSfx( cgs.media.sfxTeleportOut ), CHAN_AUTO,
cg_volume_effects->value );
}
else
{
trap_S_StartFixedSound( CG_MediaSfx( cgs.media.sfxTeleportOut ), ent->origin, CHAN_AUTO,
cg_volume_effects->value, ATTN_NORM );
}
if( ent->ownerNum && ent->ownerNum < gs.maxclients + 1 )
{
cg_entities[ent->ownerNum].localEffects[LOCALEFFECT_EV_PLAYER_TELEPORT_OUT] = cg.time;
VectorCopy( ent->origin, cg_entities[ent->ownerNum].teleportedFrom );
}
break;
case EV_PLASMA_EXPLOSION:
ByteToDir( parm, dir );
CG_PlasmaExplosion( ent->origin, dir, ent->firemode, (float)ent->weapon * 8.0f );
if( ent->firemode == FIRE_MODE_STRONG )
{
trap_S_StartFixedSound( CG_MediaSfx( cgs.media.sfxPlasmaStrongHit ), ent->origin, CHAN_AUTO, cg_volume_effects->value, ATTN_IDLE );
CG_StartKickAnglesEffect( ent->origin, 50, ent->weapon * 8, 100 );
}
else
{
trap_S_StartFixedSound( CG_MediaSfx( cgs.media.sfxPlasmaWeakHit ), ent->origin, CHAN_AUTO, cg_volume_effects->value, ATTN_IDLE );
CG_StartKickAnglesEffect( ent->origin, 30, ent->weapon * 8, 75 );
}
break;
case EV_BOLT_EXPLOSION:
ByteToDir( parm, dir );
CG_BoltExplosionMode( ent->origin, dir, ent->firemode );
break;
case EV_INSTA_EXPLOSION:
ByteToDir( parm, dir );
CG_InstaExplosionMode( ent->origin, dir, ent->firemode );
break;
case EV_GRENADE_EXPLOSION:
if( parm )
{ // we have a direction
ByteToDir( parm, dir );
CG_GrenadeExplosionMode( ent->origin, dir, ent->firemode, (float)ent->weapon*8.0f );
}
else
{ // no direction
CG_GrenadeExplosionMode( ent->origin, vec3_origin, ent->firemode, (float)ent->weapon*8.0f );
}
if( ent->firemode == FIRE_MODE_STRONG )
CG_StartKickAnglesEffect( ent->origin, 135, ent->weapon*8, 325 );
else
CG_StartKickAnglesEffect( ent->origin, 125, ent->weapon*8, 300 );
break;
case EV_ROCKET_EXPLOSION:
ByteToDir( parm, dir );
CG_RocketExplosionMode( ent->origin, dir, ent->firemode, (float)ent->weapon * 8.0f );
if( ent->firemode == FIRE_MODE_STRONG )
CG_StartKickAnglesEffect( ent->origin, 135, ent->weapon * 8, 300 );
else
CG_StartKickAnglesEffect( ent->origin, 125, ent->weapon * 8, 275 );
break;
case EV_GRENADE_BOUNCE:
if( parm == FIRE_MODE_STRONG )
trap_S_StartRelativeSound( CG_MediaSfx( cgs.media.sfxGrenadeStrongBounce[rand()&1] ), ent->number, CHAN_AUTO, cg_volume_effects->value, ATTN_IDLE );
else
trap_S_StartRelativeSound( CG_MediaSfx( cgs.media.sfxGrenadeWeakBounce[rand()&1] ), ent->number, CHAN_AUTO, cg_volume_effects->value, ATTN_IDLE );
break;
case EV_BLADE_IMPACT:
CG_BladeImpact( ent->origin, ent->origin2 );
break;
case EV_GUNBLADEBLAST_IMPACT:
ByteToDir( parm, dir );
CG_GunBladeBlastImpact( ent->origin, dir, (float)ent->weapon*8 );
if( ent->skinnum > 64 )
{
trap_S_StartFixedSound( CG_MediaSfx( cgs.media.sfxGunbladeStrongHit[2] ), ent->origin, CHAN_AUTO,
cg_volume_effects->value, ATTN_DISTANT );
}
else if( ent->skinnum > 34 )
{
trap_S_StartFixedSound( CG_MediaSfx( cgs.media.sfxGunbladeStrongHit[1] ), ent->origin, CHAN_AUTO,
cg_volume_effects->value, ATTN_NORM );
}
else
{
trap_S_StartFixedSound( CG_MediaSfx( cgs.media.sfxGunbladeStrongHit[0] ), ent->origin, CHAN_AUTO,
cg_volume_effects->value, ATTN_IDLE );
}
//ent->skinnum is knockback value
CG_StartKickAnglesEffect( ent->origin, ent->skinnum*8, ent->weapon*8, 200 );
break;
case EV_BLOOD:
if( cg_showBloodTrail->integer == 2 && ISVIEWERENTITY( ent->ownerNum ) )
break;
ByteToDir( parm, dir );
CG_BloodDamageEffect( ent->origin, dir, ent->damage );
CG_CartoonHitEffect( ent->origin, dir, ent->damage );
break;
// func movers
case EV_PLAT_HIT_TOP:
case EV_PLAT_HIT_BOTTOM:
case EV_PLAT_START_MOVING:
case EV_DOOR_HIT_TOP:
case EV_DOOR_HIT_BOTTOM:
case EV_DOOR_START_MOVING:
case EV_BUTTON_FIRE:
case EV_TRAIN_STOP:
case EV_TRAIN_START:
{
vec3_t so;
CG_GetEntitySpatilization( ent->number, so, NULL );
trap_S_StartFixedSound( cgs.soundPrecache[parm], so, CHAN_AUTO, cg_volume_effects->value, ATTN_STATIC );
}
break;
case EV_VSAY:
CG_StartVoiceTokenEffect( ent->ownerNum, EV_VSAY, parm );
break;
}
}
int SimpleSpectrum(Canvas *c, EffectManager *em, char mode)
{
static unsigned n = 0;
static char currentMode = -1;
if (mode != currentMode)
{
// Performed only once.
switch(mode)
{
case EFFECTMODE_INTRO:
break;
case EFFECTMODE_LOOP:
break;
case EFFECTMODE_OUTRO:
break;
}
currentMode = mode;
} else {
// 0b00011111 = 0x1F
n++;// = (n+1) & 0x1F;
}
unsigned short *bands = em->GetSpectrum();
for (unsigned char y = 0; y < CANVAS_HEIGHT; y++)
{
unsigned high;
Color_t color;
switch (y)
{
case 0: // Yellow
color = COLOR_B(31,31,0);
high = 900;
break;
case 1:
color = COLOR_B(23,23,0);
high = 800;
break;
case 2:
color = COLOR(31,31,0);
high = 700;
break;
case 3: // Green
color = COLOR_B(0,31,0);
high = 600;
break;
case 4:
color = COLOR_B(0,23,0);
high = 500;
break;
case 5:
color = COLOR(0,31,0);
high = 400;
break;
case 6: // Red
color = COLOR_B(31,0,0);
high = 300;
break;
case 7:
color = COLOR_B(23,0,0);
high = 200;
break;
case 8:
color = COLOR(31,0,0);
high = 100;
break;
case 9:
color = COLOR(16,0,0);
high = 0;
break;
default:
color = 0;
}
for (unsigned char x = 0; x < CANVAS_WIDTH; x++)
{
c->PutPixel(x, y, (bands[x + 1] > high) ? color : 0);
}
}
return 1;
}
// step
unsigned short level = em->GetSpectrum()[4];
vel *= 0.95;
vel += level;
pos -= vel;
for(uint8_t y = 0; y < CANVAS_HEIGHT; y++){
Color_t color;
if(vel > 10000){
uint8_t cw_pos = (pos + (y << 12)) >> 11;
color = colorwheel_lut[cw_pos];
}
else{
uint8_t sin_pos = (pos + (y << 13)) >> 11; // 65536 -> 32
uint8_t gs = sin_lut[sin_pos] >> 3; // 256 -> 32
color = COLOR_B(gs, gs, gs);
}
for(uint8_t x = 0; x < CANVAS_WIDTH; x++){
c->PutPixel(x, y, color);
}
}
return 1;
}
#define CTRX ((CANVAS_WM1 * 100) / 2)
#define CTRY ((CANVAS_HM1 * 100) / 2)
int PinwheelSpectrum(Canvas *c, EffectManager *em, char mode)
{
static int step = 0;
