player-medic revived monster levels are now based on the level of the corpse instead of the medic's level; however, a bonus is applied based on the medic's level (currently 5% per level). the revived monster will die after a set amount of time and must be revived again.

Author: Vortex-Quake2

lua/variables.lua

@@ -829,7 +829,9 @@ MEDIC_BOLT_INITIAL_SPEED                 = 1500
 MEDIC_BOLT_ADDON_SPEED                   = 0
 MEDIC_BOLT_AMMO                          = 10
 MEDIC_RESURRECT_DELAY                    = 1.0
-MEDIC_RESURRECT_BONUS                    = 0.25
+MEDIC_RESURRECT_BONUS                    = 0.05
+MEDIC_RESURRECT_BASE					 = 1.0
+MEDIC_RESURRECT_TIMEOUT					 = 180.0
 
 -- Player Tank
 P_TANK_PUNCH_RADIUS                      = 128

src/characters/settings.h

@@ -848,6 +848,8 @@ extern double MEDIC_BOLT_ADDON_SPEED;
 extern double MEDIC_BOLT_AMMO;
 extern double MEDIC_RESURRECT_DELAY;
 extern double MEDIC_RESURRECT_BONUS;
+extern double MEDIC_RESURRECT_BASE;
+extern double MEDIC_RESURRECT_TIMEOUT;
 extern double P_TANK_PUNCH_RADIUS;
 extern double P_TANK_PUNCH_INITIAL_DMG;
 extern double P_TANK_PUNCH_ADDON_DMG;

src/combat/abilities/gloom.c

@@ -207,6 +207,11 @@ void organ_touch (edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *sur
 void organ_death_message(edict_t* self, edict_t* attacker, int max)
 {
 	int qty;
+
+	// don't need to print a message if the revived organ expired
+	if (attacker && attacker->inuse && attacker == world && level.time >= self->monsterinfo.resurrected_timeout)
+		return;
+
 	if (self->mtype == M_SPIKER)
 		qty = self->activator->num_spikers;
 	else if (self->mtype == M_GASSER)
@@ -315,6 +320,8 @@ void organ_remove (edict_t *self, qboolean refund)
 	self->deadflag = DEAD_DEAD;
 }
 
+// removes organ if activator becomes invalid
+// returns false if the organ was removed, true if not
 qboolean organ_checkowner (edict_t *self)
 {
 	qboolean remove = false;
@@ -337,6 +344,22 @@ qboolean organ_checkowner (edict_t *self)
 	return true;
 }
 
+// kills organ if it expires
+// return false if the organ died, true if not
+qboolean organ_checkrevived(edict_t* self)
+{
+	//gi.dprintf("%s: %d %.1f %.1f\n", __func__, self->monsterinfo.resurrected_level, self->monsterinfo.resurrected_timeout, (float)level.time);
+	// resurrected organ has expired
+	if (self->monsterinfo.resurrected_level && level.time > self->monsterinfo.resurrected_timeout)
+	{
+		// kill it!
+		self->health = 0;
+		self->die(self, world, world, 0, vec3_origin);
+		return false;
+	}
+	return true;
+}
+
 // used to restore a prevous movetype (MOVETYPE_TOSS or MOVETYPE_NONE) needed for V_Push to work (MOVETYPE_STEP)
 void organ_restoreMoveType (edict_t *self)
 {
@@ -879,7 +902,7 @@ void spiker_think (edict_t *self)
 {
 	edict_t *e=NULL;
 
-	if (!organ_checkowner(self))
+	if (!organ_checkowner(self) || !organ_checkrevived(self))
 		return;
 
 	vrx_set_pickup_owner(self); // sets owner when this entity is picked up, making it non-solid to the player
@@ -972,7 +995,7 @@ void spiker_think (edict_t *self)
 
 void spiker_grow (edict_t *self)
 {
-	if (!organ_checkowner(self))
+	if (!organ_checkowner(self) || !organ_checkrevived(self))
 		return;
 
 	vrx_set_pickup_owner(self); // sets owner when this entity is picked up, making it non-solid to the player
@@ -1397,7 +1420,7 @@ void obstacle_attack(edict_t* self)
 
 void obstacle_think (edict_t *self)
 {
-	if (!organ_checkowner(self))
+	if (!organ_checkowner(self) || !organ_checkrevived(self))
 		return;
 
 	vrx_set_pickup_owner(self); // sets owner when this entity is picked up, making it non-solid to the player
@@ -1423,7 +1446,7 @@ void obstacle_think (edict_t *self)
 
 void obstacle_grow (edict_t *self)
 {
-	if (!organ_checkowner(self))
+	if (!organ_checkowner(self) || !organ_checkrevived(self))
 		return;
 	//gi.dprintf("movetype: %d pitch: %.0f\n", self->movetype, self->s.angles[PITCH]);
 	//organ_restoreMoveType(self);
@@ -2158,7 +2181,7 @@ qboolean gasser_findtarget (edict_t *self)
 
 void gasser_think (edict_t *self)
 {
-	if (!organ_checkowner(self))
+	if (!organ_checkowner(self) || !organ_checkrevived(self))
 		return;
 
 	vrx_set_pickup_owner(self); // sets owner when this entity is picked up, making it non-solid to the player
@@ -2224,7 +2247,7 @@ void gasser_think (edict_t *self)
 
 void gasser_grow (edict_t *self)
 {
-	if (!organ_checkowner(self))
+	if (!organ_checkowner(self) || !organ_checkrevived(self))
 		return;
 
 	vrx_set_pickup_owner(self); // sets owner when this entity is picked up, making it non-solid to the player
@@ -2705,6 +2728,9 @@ void cocoon_think (edict_t *self)
 		return;
 	}
 
+	if (!organ_checkrevived(self))
+		return;
+
 	cocoon_attack(self);
 
 	if (level.time > self->lasthurt + 1.0)

src/combat/abilities/playermonster/playertomedic.c

@@ -35,24 +35,35 @@ qboolean p_medic_healframe (edict_t *ent)
 }
 
 edict_t *CreateSpiker (edict_t *ent, int skill_level);
-edict_t *CreateObstacle (edict_t *ent, int skill_level);
+edict_t* CreateObstacle(edict_t* ent, int skill_level, int talent_level);
 edict_t* CreateGasser(edict_t* ent, int skill_level, int talent_level);
 edict_t *CreateCocoon (edict_t *ent, int skill_level);
 edict_t* CreateHealer(edict_t* ent, int skill_level);
 
 void p_medic_reanimate (edict_t *ent, edict_t *target)
 {
+	int		res_level;
 	int		skill_level;
+	float	skill_bonus;
 	vec3_t	bmin, bmax;
 	edict_t *e;
 
-	skill_level = floattoint((1.0+MEDIC_RESURRECT_BONUS)*ent->myskills.abilities[MEDIC].current_level);
+	// calculate skill bonus from medic
+	skill_bonus = MEDIC_RESURRECT_BASE + MEDIC_RESURRECT_BONUS * ent->myskills.abilities[MEDIC].current_level;
+	// save the original monster's level so we don't apply the bonus more than once
+	if (!target->monsterinfo.resurrected_level)
+		res_level = target->monsterinfo.resurrected_level = target->monsterinfo.level;
+	else
+		res_level = target->monsterinfo.resurrected_level;
+	// calculate skill level of resurrected monster with bonus applied
+	skill_level = floattoint(target->monsterinfo.resurrected_level * skill_bonus);
+	//target->monsterinfo.level = skill_level; // set level with resurrect bonus
 
 	if (!strcmp(target->classname, "drone") 
 		&& (ent->num_monsters + target->monsterinfo.control_cost <= MAX_MONSTERS)
 		&& !(target->flags & FL_UNDEAD) && target->mtype != M_DECOY && target->mtype != M_GOLEM) // don't revive decoys, golem, and undead (skeletons)
 	{
-		target->monsterinfo.level = skill_level;
+		target->monsterinfo.level = skill_level; // set level with resurrect bonus
 		M_SetBoundingBox(target->mtype, bmin, bmax);
 
 		if (G_IsValidLocation(target, target->s.origin, bmin, bmax) && M_Initialize(ent, target, 0.0f))
@@ -65,6 +76,7 @@ void p_medic_reanimate (edict_t *ent, edict_t *target)
 			target->monsterinfo.resurrected_time = level.time + 2.0;
 			target->activator = ent; // transfer ownership!
 			target->nextthink = level.time + MEDIC_RESURRECT_DELAY;
+			target->monsterinfo.resurrected_timeout = target->nextthink + MEDIC_RESURRECT_TIMEOUT; // resurrected monster dies when this timer is exceeded
 			gi.linkentity(target);
 			target->monsterinfo.stand(target);
 
@@ -111,6 +123,7 @@ void p_medic_reanimate (edict_t *ent, edict_t *target)
 
 		e->activator = ent;
 		e->monsterinfo.level = skill_level;
+		e->monsterinfo.resurrected_level = res_level;
 		M_Initialize(ent, e, 0.0f);
 		e->health = 0.2f*e->max_health;
 		e->monsterinfo.power_armor_power = 0.2f*e->monsterinfo.max_armor;
@@ -134,7 +147,7 @@ void p_medic_reanimate (edict_t *ent, edict_t *target)
 		VectorCopy(start, e->s.origin);
 		gi.linkentity(e);
 		e->nextthink = level.time + MEDIC_RESURRECT_DELAY;
-
+		e->monsterinfo.resurrected_timeout = e->nextthink + MEDIC_RESURRECT_TIMEOUT; // resurrected monster dies when this timer is exceeded
 		ent->num_monsters += e->monsterinfo.control_cost;
 		ent->num_monsters_real++;
 		// gi.bprintf(PRINT_HIGH, "adding %p (%d) \n", target, ent->num_monsters_real);
@@ -154,6 +167,8 @@ void p_medic_reanimate (edict_t *ent, edict_t *target)
 			return;
 		}
 
+		e->monsterinfo.resurrected_level = res_level;
+		e->monsterinfo.resurrected_timeout = e->nextthink + MEDIC_RESURRECT_TIMEOUT; // resurrected spiker dies when this timer is exceeded
 		VectorCopy(target->s.angles, e->s.angles);
 		e->s.angles[PITCH] = 0;
 		e->monsterinfo.cost = target->monsterinfo.cost;
@@ -168,7 +183,7 @@ void p_medic_reanimate (edict_t *ent, edict_t *target)
 	}
 	else if (!strcmp(target->classname, "obstacle") && ent->num_obstacle + 1 <= OBSTACLE_MAX_COUNT)
 	{
-		e = CreateObstacle(ent, skill_level);
+		e = CreateObstacle(ent, skill_level, vrx_get_talent_level(ent, TALENT_MAGNETISM));
 		// target obstacle is flipped
 		if (target->s.angles[PITCH] == 180)
 		{
@@ -191,7 +206,8 @@ void p_medic_reanimate (edict_t *ent, edict_t *target)
 			return;
 		}
 		//gi.dprintf("obstacle will fit\n");
-		
+		e->monsterinfo.resurrected_level = res_level;
+		e->monsterinfo.resurrected_timeout = e->nextthink + MEDIC_RESURRECT_TIMEOUT; // resurrected obstacle dies when this timer is exceeded
 		e->monsterinfo.cost = target->monsterinfo.cost;
 		e->health = 0.33 * e->max_health;
 		e->s.frame = 6;
@@ -213,7 +229,8 @@ void p_medic_reanimate (edict_t *ent, edict_t *target)
 			G_FreeEdict(e);
 			return;
 		}
-		
+		e->monsterinfo.resurrected_level = res_level;
+		e->monsterinfo.resurrected_timeout = e->nextthink + MEDIC_RESURRECT_TIMEOUT; // resurrected gasser dies when this timer is exceeded
 		VectorCopy(target->s.angles, e->s.angles);
 		e->s.angles[PITCH] = 0;
 		e->monsterinfo.cost = target->monsterinfo.cost;
@@ -238,6 +255,8 @@ void p_medic_reanimate (edict_t *ent, edict_t *target)
             return;
         }
 
+		e->monsterinfo.resurrected_level = res_level;
+		e->monsterinfo.resurrected_timeout = e->nextthink + MEDIC_RESURRECT_TIMEOUT; // resurrected spiker dies when this timer is exceeded
         VectorCopy(target->s.angles, e->s.angles);
         e->s.angles[PITCH] = 0;
         e->monsterinfo.cost = target->monsterinfo.cost;
@@ -261,6 +280,8 @@ void p_medic_reanimate (edict_t *ent, edict_t *target)
 			return;
 		}
 
+		e->monsterinfo.resurrected_level = res_level;
+		e->monsterinfo.resurrected_timeout = e->nextthink + MEDIC_RESURRECT_TIMEOUT; // resurrected healer dies when this timer is exceeded
 		VectorCopy(target->s.angles, e->s.angles);
 		e->s.angles[PITCH] = 0;
 		//e->monsterinfo.cost = target->monsterinfo.cost;

src/entities/drone/drone_medic.c

@@ -645,14 +645,19 @@ static vec3_t	mymedic_cable_offsets[] =
 };
 
 edict_t *CreateSpiker (edict_t *ent, int skill_level);
-edict_t *CreateObstacle (edict_t *ent, int skill_level);
+edict_t* CreateObstacle(edict_t* ent, int skill_level, int talent_level);
 edict_t* CreateGasser(edict_t* ent, int skill_level, int talent_level);
 
 void M_Reanimate (edict_t *ent, edict_t *target, int r_level, float r_modifier, qboolean printMsg)
 {
 	vec3_t	bmin, bmax;
 	edict_t *e;
 
+	// save the original monster's level
+	// note: this isn't strictly needed for monsters since they don't apply any bonuses--it's mainly here for player-medics
+	if (!target->monsterinfo.resurrected_level)
+		target->monsterinfo.resurrected_level = target->monsterinfo.level;
+
 	if (!strcmp(target->classname, "drone") && !(target->flags & FL_UNDEAD) && target->mtype != M_DECOY && target->mtype != M_GOLEM) // can't revive decoys, golem, and undead/skeletons
 	{
 		// if the summoner is a player, check for sufficient monster slots
@@ -661,7 +666,7 @@ void M_Reanimate (edict_t *ent, edict_t *target, int r_level, float r_modifier,
 
 		target->monsterinfo.level = r_level;
 		M_SetBoundingBox(target->mtype, bmin, bmax);
-
+		
 		if (G_IsValidLocation(target, target->s.origin, bmin, bmax) && M_Initialize(ent, target, 0.0f))
 		{
 			//gi.dprintf("resurrect drone at %.1f\n", level.time);
@@ -672,6 +677,7 @@ void M_Reanimate (edict_t *ent, edict_t *target, int r_level, float r_modifier,
 			target->monsterinfo.resurrected_time = level.time + 10.0;
 			target->activator = ent; // transfer ownership!
 			target->nextthink = level.time + FRAMETIME;//1.0; note: don't delay think--this may cause undesired behavior (monster sliding)
+			target->monsterinfo.resurrected_timeout = target->nextthink + MEDIC_RESURRECT_TIMEOUT; // resurrected monster dies when this timer is exceeded
 			target->monsterinfo.attack_finished = level.time + 1.0;//delay attack--alternatively we can set the think func to drone_grow
 			gi.linkentity(target);
 			target->monsterinfo.stand(target);
@@ -753,7 +759,7 @@ void M_Reanimate (edict_t *ent, edict_t *target, int r_level, float r_modifier,
 		VectorCopy(start, e->s.origin);
 		gi.linkentity(e);
 		e->nextthink = level.time + 1.0;
-
+		e->monsterinfo.resurrected_timeout = e->nextthink + MEDIC_RESURRECT_TIMEOUT; // resurrected monster dies when this timer is exceeded
 		ent->num_monsters += e->monsterinfo.control_cost;
 		ent->num_monsters_real++;
 		// gi.bprintf(PRINT_HIGH, "adding %p (%d)\n", e, ent->num_monsters_real);
@@ -789,6 +795,7 @@ void M_Reanimate (edict_t *ent, edict_t *target, int r_level, float r_modifier,
 		e->monsterinfo.cost = target->monsterinfo.cost;
 		e->health = r_modifier * e->max_health;
 		e->monsterinfo.resurrected_time = level.time + 10.0;
+		e->monsterinfo.resurrected_timeout = e->nextthink + MEDIC_RESURRECT_TIMEOUT; // resurrected spiker dies when this timer is exceeded
 		e->s.frame = 4;
 		VectorCopy(target->s.origin, e->s.origin);
 		gi.linkentity(e);
@@ -804,7 +811,7 @@ void M_Reanimate (edict_t *ent, edict_t *target, int r_level, float r_modifier,
 		if (ent->client && (ent->num_obstacle + 1 > OBSTACLE_MAX_COUNT))
 			return;
 
-		e = CreateObstacle(ent, r_level);
+		e = CreateObstacle(ent, r_level, vrx_get_talent_level(ent, TALENT_MAGNETISM));
 
 		// make sure the new entity fits
 		if (!G_IsValidLocation(target, target->s.origin, e->mins, e->maxs))
@@ -818,6 +825,7 @@ void M_Reanimate (edict_t *ent, edict_t *target, int r_level, float r_modifier,
 		e->s.angles[PITCH] = 0;
 		e->monsterinfo.cost = target->monsterinfo.cost;
 		e->monsterinfo.resurrected_time = level.time + 10.0;
+		e->monsterinfo.resurrected_timeout = e->nextthink + MEDIC_RESURRECT_TIMEOUT; // resurrected obstacle dies when this timer is exceeded
 		e->health = r_modifier * e->max_health;
 		e->s.frame = 6;
 		VectorCopy(target->s.origin, e->s.origin);
@@ -848,6 +856,7 @@ void M_Reanimate (edict_t *ent, edict_t *target, int r_level, float r_modifier,
 		e->s.angles[PITCH] = 0;
 		e->monsterinfo.cost = target->monsterinfo.cost;
 		e->monsterinfo.resurrected_time = level.time + 10.0;
+		e->monsterinfo.resurrected_timeout = e->nextthink + MEDIC_RESURRECT_TIMEOUT; // resurrected gasser dies when this timer is exceeded
 		e->health = r_modifier * e->max_health;
 		e->s.frame = 0;
 		VectorCopy(target->s.origin, e->s.origin);

src/entities/drone/drone_misc.c

@@ -1981,6 +1981,15 @@ qboolean M_Upkeep (edict_t *self, int delay, int upkeep_cost)
 
 	e = G_GetClient(self);
 
+	// resurrected monster has expired
+	if (self->monsterinfo.resurrected_level && level.time > self->monsterinfo.resurrected_timeout)
+	{
+		// kill it!
+		self->health = 0;
+		self->die(self, world, world, 0, vec3_origin);
+		return true; // must return true for monster to continue thinking and processing death animation
+	}
+
 	if (!e)
 		return true; // probably owned by world; doesn't pay upkeep
 

src/g_local.h

@@ -636,6 +636,8 @@ typedef struct
 	float		Zchange_delay;		// delay before we can adjust Z position again (to prevent bouncing)
 	qboolean	Zchanged;			// has our Z position changed recently?
 	float		resurrected_time;	// time when resurrection from a medic is complete
+	int			resurrected_level;  // used to store the original level of the monster before resurrection bonus is applied
+	float		resurrected_timeout;// time when the resurrected monster will expire
 	float		backtrack_delay;	// delay until we can backtrack to a closer waypoint (to prevent getting stuck)
 	float		path_time;			// time when monster can compute a path
 	vec3_t		prevGoalPos;		// last goal position, used for deciding when to re-compute paths

src/quake2/g_layout.c

@@ -315,7 +315,13 @@ sidebar_entry_t layout_add_entity_info(sidebar_t* sidebar, edict_t* ent)
 	case M_SKELETON:
 	case M_GOLEM:
 		name = lva("%s", V_GetMonsterName(ent));
-		data = lva("+%d/%d", ent->health, ent->monsterinfo.power_armor_power);
+		if (ent->monsterinfo.resurrected_timeout)
+		{
+			float time_remaining = ent->monsterinfo.resurrected_timeout - level.time;
+			data = lva("(%d) +%d/%d %.0f", ent->monsterinfo.level, ent->health, ent->monsterinfo.power_armor_power, time_remaining);
+		}
+		else
+			data = lva("(%d) +%d/%d", ent->monsterinfo.level, ent->health, ent->monsterinfo.power_armor_power);
 		break;
 	case M_SENTRY:
 		name = lva("sentry");
@@ -348,7 +354,13 @@ sidebar_entry_t layout_add_entity_info(sidebar_t* sidebar, edict_t* ent)
 	case M_GASSER:
 	case M_DECOY:
 		name = lva("%s", V_GetMonsterName(ent));
-		data = lva("+%d", ent->health);
+		if (ent->monsterinfo.resurrected_timeout)
+		{
+			float time_remaining = ent->monsterinfo.resurrected_timeout - level.time;
+			data = lva("(%d) +%d %.0f", ent->monsterinfo.level, ent->health, time_remaining);
+		}
+		else
+			data = lva("(%d) +%d", ent->monsterinfo.level, ent->health);
 		break;
 	case M_BARREL:
 		name = lva("barrel");