Add cg_damagePlums

code/cgame/cg_cvar.h

@@ -111,6 +111,7 @@ CG_CVAR( cg_timescaleFadeEnd, "cg_timescaleFadeEnd", "1", 0 )
 CG_CVAR( cg_timescaleFadeSpeed, "cg_timescaleFadeSpeed", "0", 0 )
 CG_CVAR( cg_timescale, "timescale", "1", 0 )
 CG_CVAR( cg_scorePlum, "cg_scorePlums", "1", CVAR_USERINFO | CVAR_ARCHIVE )
+CG_CVAR( cg_damagePlums, "cg_damagePlums", "0", CVAR_USERINFO | CVAR_ARCHIVE )
 CG_CVAR( cg_smoothClients, "cg_smoothClients", "0", CVAR_USERINFO | CVAR_ARCHIVE )
 CG_CVAR( cg_cameraMode, "com_cameraMode", "0", CVAR_CHEAT )
 CG_CVAR( cg_noTaunt, "cg_noTaunt", "0", CVAR_ARCHIVE )

code/cgame/cg_effects.c

@@ -428,6 +428,52 @@ void CG_ScorePlum( int client, const vec3_t origin, int score ) {
 	AnglesToAxis( angles, re->axis );
 }
 
+/*
+==================
+CG_DamagePlum
+==================
+*/
+void CG_DamagePlum( vec3_t org, int damage ) {
+	localEntity_t	*le;
+	refEntity_t		*re;
+	vec3_t			angles;
+	float			random_x, random_y;
+
+	if ( cg_damagePlums.integer == 0 ) {
+		return;
+	}
+
+	le = CG_AllocLocalEntity();
+	le->leFlags = 0;
+	le->leType = LE_DAMAGEPLUM;
+	le->startTime = cg.time;
+	le->endTime = cg.time + 1000;
+	le->lifeRate = 1.0 / ( le->endTime - le->startTime );
+
+	le->color[0] = 1.0;
+	le->color[1] = 0.5;
+	le->color[2] = 0.0;
+	le->color[3] = 1.0;
+	le->radius = damage;
+
+	VectorCopy( org, le->pos.trBase );
+
+	random_x = (random() * 2.0 - 1.0);
+	random_y = (random() * 2.0 - 1.0);
+
+	le->pos.trDelta[0] = random_x;
+	le->pos.trDelta[1] = random_y;
+	le->pos.trDelta[2] = 0.5 + random() * 0.5;
+
+	re = &le->refEntity;
+
+	re->reType = RT_SPRITE;
+	re->radius = 16;
+
+	VectorClear(angles);
+	AnglesToAxis( angles, re->axis );
+}
+
 
 /*
 ====================

code/cgame/cg_event.c

@@ -963,6 +963,10 @@ void CG_EntityEvent( centity_t *cent, vec3_t position, int entityNum ) {
 		CG_ScorePlum( cent->currentState.otherEntityNum, cent->lerpOrigin, cent->currentState.time );
 		break;
 
+	case EV_DAMAGEPLUM:
+		CG_DamagePlum( cent->lerpOrigin, cent->currentState.time );
+		break;
+
 	//
 	// missile impacts
 	//

code/cgame/cg_local.h

@@ -232,6 +232,7 @@ typedef enum {
 	LE_FADE_RGB,
 	LE_SCALE_FADE,
 	LE_SCOREPLUM,
+	LE_DAMAGEPLUM,
 #ifdef MISSIONPACK
 	LE_KAMIKAZE,
 	LE_INVULIMPACT,
@@ -1405,6 +1406,7 @@ void CG_InvulnerabilityJuiced( vec3_t org );
 void CG_LightningBoltBeam( vec3_t start, vec3_t end );
 #endif
 void CG_ScorePlum( int client, const vec3_t origin, int score );
+void CG_DamagePlum( vec3_t org, int damage );
 
 void CG_GibPlayer( const vec3_t playerOrigin );
 void CG_BigExplode( vec3_t playerOrigin );

code/cgame/cg_localents.c

@@ -870,6 +870,109 @@ void CG_AddScorePlum( localEntity_t *le ) {
 	}
 }
 
+/*
+===================
+CG_AddDamagePlum
+===================
+*/
+void CG_AddDamagePlum( localEntity_t *le ) {
+	refEntity_t	*re;
+	vec3_t		origin, delta, dir, vec, up = {0, 0, 1};
+	float		c, len, distance;
+	int			i, damage, digits[10], numdigits, negative;
+	float		progress, fade, spread_x, spread_y, vertical_offset, peak_height;
+
+	re = &le->refEntity;
+
+	c = ( le->endTime - cg.time ) * le->lifeRate;
+
+	damage = le->radius;
+
+	// Color based on damage amount - gradient from blue to red
+	if (damage > 75) {
+		// Red
+		re->shaderRGBA[0] = 0xff;
+		re->shaderRGBA[1] = 0x00;
+		re->shaderRGBA[2] = 0x00;
+	} else if (damage > 50) {
+		// Orange
+		re->shaderRGBA[0] = 0xff;
+		re->shaderRGBA[1] = 0x80;
+		re->shaderRGBA[2] = 0x00;
+	} else if (damage > 25) {
+		// Yellow
+		re->shaderRGBA[0] = 0xff;
+		re->shaderRGBA[1] = 0xff;
+		re->shaderRGBA[2] = 0x00;
+	} else {
+		// Blue
+		re->shaderRGBA[0] = 0x00;
+		re->shaderRGBA[1] = 0x80;
+		re->shaderRGBA[2] = 0xff;
+	}
+
+	// Fade out after 75% of arc (750ms)
+	progress = 1.0 - c;  // 0.0 at start, 1.0 at end
+	if (progress < 0.75f) {
+		fade = 1.0f;  // Full opacity for first 750ms
+	} else {
+		fade = 1.0f - ((progress - 0.75f) / 0.25f);  // Fade out over remaining 250ms
+	}
+	re->shaderRGBA[3] = 0xff * fade;
+
+	VectorCopy(le->pos.trBase, origin);
+
+	// Calculate distance to base origin for scaling sprite and arc
+	VectorSubtract( origin, cg.refdef.vieworg, delta );
+	len = VectorLengthSquared( delta );
+	if ( len < 20*20 ) {
+		// if the view would be "inside" the sprite, kill the sprite
+		CG_FreeLocalEntity( le );
+		return;
+	}
+
+	distance = sqrt(len);
+	re->radius = (NUMBER_SIZE / 1280.0f) * distance * tan(cg.refdef.fov_x * M_PI / 360.0f);
+
+	// Horizontal spread
+	spread_x = le->pos.trDelta[0] * 20.0 * re->radius * progress;
+	spread_y = le->pos.trDelta[1] * 20.0 * re->radius * progress;
+	origin[0] += spread_x;
+	origin[1] += spread_y;
+
+	// Vertical arc - symmetric rise and fall over the full duration
+	// Uses sine wave for smooth, even arc that peaks at 50% progress
+	peak_height = 15.0 * le->pos.trDelta[2] * re->radius;
+	vertical_offset = peak_height * sin(progress * M_PI);
+	origin[2] += vertical_offset;
+
+	VectorSubtract(cg.refdef.vieworg, origin, dir);
+	CrossProduct(dir, up, vec);
+	VectorNormalize(vec);
+
+	negative = qfalse;
+	if (damage < 0) {
+		negative = qtrue;
+		damage = -damage;
+	}
+
+	for (numdigits = 0; !(numdigits && !damage); numdigits++) {
+		digits[numdigits] = damage % 10;
+		damage = damage / 10;
+	}
+
+	if (negative) {
+		digits[numdigits] = 10;
+		numdigits++;
+	}
+
+	for (i = 0; i < numdigits; i++) {
+		VectorMA(origin, (float) (((float) numdigits / 2) - i) * (re->radius * 2), vec, re->origin);
+		re->customShader = cgs.media.numberShaders[digits[numdigits-1-i]];
+		trap_R_AddRefEntityToScene( re );
+	}
+}
+
 
 
 
@@ -936,6 +1039,10 @@ void CG_AddLocalEntities( void ) {
 			CG_AddScorePlum( le );
 			break;
 
+		case LE_DAMAGEPLUM:
+			CG_AddDamagePlum( le );
+			break;
+
 #ifdef MISSIONPACK
 		case LE_KAMIKAZE:
 			CG_AddKamikaze( le );

code/game/bg_events.h

@@ -108,7 +108,9 @@ DECLARE_EVENT( EV_TAUNT_NO ),
 DECLARE_EVENT( EV_TAUNT_FOLLOWME ),
 DECLARE_EVENT( EV_TAUNT_GETFLAG ),
 DECLARE_EVENT( EV_TAUNT_GUARDBASE ),
-DECLARE_EVENT( EV_TAUNT_PATROL )
+DECLARE_EVENT( EV_TAUNT_PATROL ),
+
+DECLARE_EVENT( EV_DAMAGEPLUM )				// damage plum
 
 #ifdef EVENT_ENUMS
 	, DECLARE_EVENT( EV_MAX )

code/game/g_active.c

@@ -1217,6 +1217,12 @@ void ClientEndFrame( gentity_t *ent ) {
 		client->damage.team = 0;
 	}
 
+	// send accumulated damage plums
+	for ( i = 0; i < client->damagePlumCount; i++ ) {
+		DamagePlum( ent, client->damagePlums[i].origin, client->damagePlums[i].damage );
+	}
+	client->damagePlumCount = 0;
+
 	// set the bit for the reachability area the client is currently in
 //	i = trap_AAS_PointReachabilityAreaIndex( ent->client->ps.origin );
 //	ent->client->areabits[i >> 3] |= 1 << (i & 7);

code/game/g_client.c

@@ -624,6 +624,13 @@ qboolean ClientUserinfoChanged( int clientNum ) {
 		client->pers.predictItemPickup = qtrue;
 	}
 
+	// client wants damage plum data?
+	if ( atoi( Info_ValueForKey( userinfo, "cg_damagePlums" ) ) ) {
+		client->pers.damagePlums = qtrue;
+	} else {
+		client->pers.damagePlums = qfalse;
+	}
+
 	// set name
 	Q_strncpyz( oldname, client->pers.netname, sizeof( oldname ) );
 	s = Info_ValueForKey( userinfo, "name" );

code/game/g_combat.c

@@ -22,6 +22,27 @@ void ScorePlum( gentity_t *ent, vec3_t origin, int score ) {
 	plum->s.time = score;
 }
 
+/*
+============
+DamagePlum
+============
+*/
+void DamagePlum( gentity_t *attacker, vec3_t origin, int damage ) {
+	gentity_t *plum;
+
+	if ( !attacker || !attacker->client || !attacker->client->pers.damagePlums) {
+		return;
+	}
+
+	plum = G_TempEntity( origin, EV_DAMAGEPLUM );
+	// only send this temp entity to the attacker
+	plum->r.svFlags |= SVF_SINGLECLIENT;
+	plum->r.singleClient = attacker->s.number;
+	//
+	plum->s.otherEntityNum = attacker->s.number;
+	plum->s.time = damage;
+}
+
 /*
 ============
 AddScore
@@ -805,6 +826,8 @@ void G_Damage( gentity_t *targ, gentity_t *inflictor, gentity_t *attacker,
 	int			asave;
 	int			knockback;
 	int			max;
+	int			i;
+	qboolean	found;
 #ifdef MISSIONPACK
 	vec3_t		bouncedir, impactpoint;
 #endif
@@ -1018,6 +1041,24 @@ void G_Damage( gentity_t *targ, gentity_t *inflictor, gentity_t *attacker,
 			attacker->client->damage.amount += take + asave;
 		}
 #endif
+		if ( !OnSameTeam( targ, attacker ) ) {
+			// accumulate damage per target for damage plums
+			found = qfalse;
+			for ( i = 0; i < attacker->client->damagePlumCount; i++ ) {
+				if ( attacker->client->damagePlums[i].clientNum == targ->s.number ) {
+					attacker->client->damagePlums[i].damage += take + asave;
+					found = qtrue;
+					break;
+				}
+			}
+			if ( !found && attacker->client->damagePlumCount < MAX_CLIENTS ) {
+				attacker->client->damagePlums[attacker->client->damagePlumCount].clientNum = targ->s.number;
+				attacker->client->damagePlums[attacker->client->damagePlumCount].damage = take + asave;
+				VectorCopy( targ->r.currentOrigin, attacker->client->damagePlums[attacker->client->damagePlumCount].origin );
+				attacker->client->damagePlums[attacker->client->damagePlumCount].origin[2] += 24;
+				attacker->client->damagePlumCount++;
+			}
+		}
 	}
 
 	// add to the damage inflicted on a player this frame

code/game/g_local.h

@@ -240,6 +240,7 @@ typedef struct {
 	int			teamVoted;
 
 	qboolean	inGame;
+	qboolean	damagePlums;		// do we want to display damage numbers?
 } clientPersistant_t;
 
 // unlagged
@@ -334,6 +335,14 @@ struct gclient_s {
 		int		enemy;
 		int		amount;
 	} damage;
+
+	// damage plums - track damage per target for this frame
+	struct {
+		int		clientNum;
+		int		damage;
+		vec3_t	origin;
+	} damagePlums[MAX_CLIENTS];
+	int			damagePlumCount;
 };
 
 
@@ -528,6 +537,7 @@ const char *BuildShaderStateConfig( void );
 qboolean CanDamage (gentity_t *targ, vec3_t origin);
 void G_Damage (gentity_t *targ, gentity_t *inflictor, gentity_t *attacker, vec3_t dir, vec3_t point, int damage, int dflags, int mod);
 qboolean G_RadiusDamage (vec3_t origin, gentity_t *attacker, float damage, float radius, gentity_t *ignore, int mod);
+void DamagePlum( gentity_t *attacker, vec3_t origin, int damage );
 int G_InvulnerabilityEffect( gentity_t *targ, vec3_t dir, vec3_t point, vec3_t impactpoint, vec3_t bouncedir );
 void body_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath );
 void TossClientItems( gentity_t *self );

code/game/g_main.c

@@ -1467,6 +1467,7 @@ static void G_WarmupEnd( void )
 		client->ps.persistant[PERS_ATTACKER] = ENTITYNUM_NONE;
 		client->ps.persistant[PERS_ATTACKEE_ARMOR] = 0;
 		client->damage.enemy = client->damage.team = 0;
+		client->damagePlumCount = 0;
 
 		client->ps.stats[STAT_CLIENTS_READY] = 0;
 		client->ps.stats[STAT_HOLDABLE_ITEM] = 0;