Removed mage Improved Magicbolt talent. Added mage Wizardry talent, which replaces spell's ability delay with a spell-specific timer, allowing multiple spells to be used simultaneously. Added mage CL Storm talent, which adds a chance for lightning storm to fire a chain lightning bolt. Finally, reworked chain lightning to use TE_HEATBEAM graphics.

Author: Vortex-Quake2

src/characters/Talents.c

@@ -66,7 +66,9 @@ const talentdef_t talents_necromancer[] = {
 const talentdef_t talents_mage[] = {
   //     {TALENT_ICE_BOLT,      5, false},
  //       {TALENT_FROST_NOVA,    5, false},
-        {TALENT_IMP_MAGICBOLT, 5, false},
+ //       {TALENT_IMP_MAGICBOLT, 5, false},
+        {TALENT_CL_STORM,      5, false},
+        {TALENT_WIZARDRY,      5, false},
         {TALENT_MANASHIELD,    5, false},
         {TALENT_MEDITATION,    5, false},
         {TALENT_OVERLOAD,      5, false},
@@ -445,11 +447,22 @@ int writeTalentDescription(edict_t *ent, int talentID) {
             menu_add_line(ent, "Special nova spell", MENU_WHITE_CENTERED);
             menu_add_line(ent, "that chills players.", MENU_WHITE_CENTERED);
             menu_add_line(ent, "(cmd frostnova)", MENU_WHITE_CENTERED);
-            return 3;*/
+            return 3;
         case TALENT_IMP_MAGICBOLT:
             menu_add_line(ent, "Power cubes are refunded", MENU_WHITE_CENTERED);
             menu_add_line(ent, "on successful hits.", MENU_WHITE_CENTERED);
-            return 2;
+            return 2;*/
+        case TALENT_WIZARDRY:
+            menu_add_line(ent, "Switches spell timers to be", MENU_WHITE_CENTERED);
+            menu_add_line(ent, "ability-specific instead of", MENU_WHITE_CENTERED);
+            menu_add_line(ent, "global, allowing you to use", MENU_WHITE_CENTERED);
+            menu_add_line(ent, "them simultaneously!", MENU_WHITE_CENTERED);
+            return 4;
+        case TALENT_CL_STORM:
+            menu_add_line(ent, "Adds chance for lightning", MENU_WHITE_CENTERED);
+            menu_add_line(ent, "storms to fire chain", MENU_WHITE_CENTERED);
+            menu_add_line(ent, "lightning!", MENU_WHITE_CENTERED);
+            return 3;
         case TALENT_MANASHIELD:
             menu_add_line(ent, "Reduces physical damage", MENU_WHITE_CENTERED);
             menu_add_line(ent, "by 80%%. All damage", MENU_WHITE_CENTERED);

src/characters/Talents.h

@@ -30,8 +30,8 @@
 #define TALENT_ICE_BOLT				40
 #define TALENT_MEDITATION			41
 #define TALENT_OVERLOAD				42
-#define TALENT_FROST_NOVA			43
-#define TALENT_IMP_MAGICBOLT		44
+#define TALENT_CL_STORM				43 //TALENT_FROST_NOVA
+#define TALENT_WIZARDRY				44 //TALENT_IMP_MAGICBOLT
 #define TALENT_MANASHIELD			45
 //Engineer
 //#define TALENT_DEFENSIVE_CRATE     350

src/characters/v_utils.c

@@ -424,8 +424,12 @@ char *GetTalentString(int talent_ID) {
             return "Mana Charge";
         //case TALENT_FROST_NOVA:
         //    return "Frost Nova";
-        case TALENT_IMP_MAGICBOLT:
-            return "Imp. Magicbolt";
+        //case TALENT_IMP_MAGICBOLT:
+         //   return "Imp. Magicbolt";
+        case TALENT_CL_STORM:
+            return "CL Storm";
+        case TALENT_WIZARDRY:
+            return "Wizardry";
         case TALENT_MANASHIELD:
             return "Mana Shield";
         case TALENT_OVERLOAD:

src/combat/abilities/chainlightning.c

@@ -2,6 +2,8 @@
 
 #define CLIGHTNING_MAX_HOPS 4
 
+void lightningstorm_sound(edict_t* self);
+
 void G_SpawnParticleTrail (vec3_t start, vec3_t end, int particles, int color)
 {
 	int		i, spacing;
@@ -64,6 +66,170 @@ qboolean ChainLightning_Attack (edict_t *ent, edict_t *target, int damage, int m
 	return result;
 }
 
+void CL_attack(edict_t* self, edict_t *target, int damage)
+{
+	//if (G_ValidTarget(self, target, true, false))
+	//{
+		// do less damage to corpses
+		if (target->health < 1 && damage > 100)
+			damage = 100;
+		//gi.dprintf("CL did %d damage at %d\n", damage, (int)level.framenum);
+		// deal damage
+		T_Damage(target, self, self, vec3_origin, target->s.origin, vec3_origin, damage, 0, DAMAGE_ENERGY, MOD_LIGHTNING);
+		//return true;
+	//}
+	//return false;
+}
+
+qboolean CL_targetinlist(edict_t* self, edict_t *target)
+{
+	for (int i = 0; i < self->monsterinfo.target_index; i++)
+	{
+		if (target == self->monsterinfo.dmglist[i].player)
+			return true;
+	}
+	return false;
+}
+
+edict_t *CL_findtarget(edict_t* self, vec3_t org, float radius, qboolean check_list)
+{
+	edict_t* e = NULL;
+
+	while ((e = findclosestradius(e, org, radius)) != NULL)
+	{
+		if (!G_ValidTarget(self, e, true, false))
+			continue;
+		if (check_list && CL_targetinlist(self, e))
+			continue;
+		return e;
+	}
+	return NULL;
+}
+
+void chainlightning_think(edict_t* self)
+{
+	edict_t *enemy = CL_findtarget(self, self->s.origin, self->monsterinfo.sight_range, true);
+
+	if (self->light_level && enemy) // have ammo and valid target
+	{
+		vec3_t start;
+
+		//gi.dprintf("%d: CL is attacking, ammo: %d\n", (int)level.framenum, self->light_level);
+		// add enemy to the list so we don't attack the same target twice
+		self->monsterinfo.dmglist[self->monsterinfo.target_index++].player = enemy;
+
+		CL_attack(self, enemy, self->dmg);
+		// move
+		G_EntMidPoint(enemy, start);
+		VectorCopy(start, self->s.origin);
+		gi.linkentity(self);
+
+		// lightning graphical effect
+		gi.WriteByte(svc_temp_entity);
+		gi.WriteByte(TE_HEATBEAM);
+		gi.WriteShort(self - g_edicts);
+		gi.WritePosition(self->s.old_origin);
+		gi.WritePosition(self->s.origin);
+		gi.multicast(self->s.origin, MULTICAST_PVS);
+
+		VectorCopy(start, self->s.old_origin);
+
+		// reduce ammo
+		self->light_level--;
+		// increase damage for next hop
+		self->dmg *= CLIGHTNING_DMG_MOD;
+	}
+	else
+	{
+		//gi.dprintf("%d: CL is being removed, ammo: %d\n", (int)level.framenum, self->light_level);
+
+		G_FreeEdict(self);
+		return;
+	}
+
+	self->nextthink = level.time + FRAMETIME;
+}
+
+void fire_chainlightning(edict_t* self, vec3_t start, vec3_t aimdir, int damage, float radius, int attack_range, int hop_range, int max_hops)
+{
+	vec3_t end;
+	edict_t* enemy = NULL;
+
+	// calling entity made a sound, used to alert monsters
+	self->lastsound = level.framenum;
+	// play sound
+	gi.sound(self, CHAN_ITEM, gi.soundindex("abilities/thunderbolt.wav"), 1, ATTN_NORM, 0);
+	//lightningstorm_sound(self);
+
+	// get ending position
+	VectorMA(start, attack_range, aimdir, end);
+
+	// trace from attacker to ending position
+	trace_t tr = gi.trace(start, NULL, NULL, end, self, MASK_SHOT);
+
+	//vec3_t org;
+	// try to attack
+	if (radius > 0)
+	{
+		edict_t* targ;
+		if ((targ = CL_findtarget(self, tr.endpos, radius, false)) != NULL)
+		{
+			//FIXME: randomize endpos within the bbox of target
+			CL_attack(self, targ, damage);
+			enemy = targ;
+			G_EntMidPoint(targ, end);
+			end[0] = end[0] + GetRandom(0, (int)targ->maxs[0]) * crandom();
+			end[1] = end[1] + GetRandom(0, (int)targ->maxs[1]) * crandom();
+			// recalculate starting position directly above endpoint
+			trace_t tr = gi.trace(end, NULL, NULL, tv(end[0], end[1], 8192), self, MASK_SOLID);
+			VectorCopy(tr.endpos, start);
+		}
+		else
+			VectorCopy(tr.endpos, end);
+	}
+	else if (G_ValidTarget(self, tr.ent, true, false))
+	{
+		CL_attack(self, tr.ent, damage);
+		enemy = tr.ent;
+		VectorCopy(tr.endpos, end);
+	}
+	//else
+	//	return;
+
+	// lightning graphical effect
+	gi.WriteByte(svc_temp_entity);
+	gi.WriteByte(TE_HEATBEAM);
+	gi.WriteShort(self - g_edicts);
+	gi.WritePosition(start);
+	gi.WritePosition(end);
+	gi.multicast(end, MULTICAST_PVS);
+
+	if (!enemy)
+		return;
+
+	//gi.dprintf("%d: spawned CL ent\n", (int)level.framenum);
+	// spawn lightning entity
+	edict_t* lightning = G_Spawn();
+	lightning->classname = "lightning";
+	lightning->solid = SOLID_NOT;
+	lightning->svflags |= SVF_NOCLIENT;
+	lightning->owner = G_GetClient(self); // for lightning storm: to ensure the owner is the player, not the LS!
+	//lightning->delay = level.time + duration;
+	lightning->nextthink = level.time + FRAMETIME;
+	lightning->think = chainlightning_think;
+	VectorCopy(end, lightning->s.origin);
+	VectorCopy(end, lightning->s.old_origin);
+	VectorCopy(aimdir, lightning->movedir);
+	lightning->dmg_radius = radius;
+	lightning->dmg = damage * CLIGHTNING_DMG_MOD; // damage increases with each hop
+	lightning->monsterinfo.sight_range = hop_range;
+	lightning->light_level = max_hops;
+	gi.linkentity(lightning);
+
+	// add enemy to the list so we don't attack again
+	lightning->monsterinfo.dmglist[lightning->monsterinfo.target_index++].player = enemy;
+}
+
 void ChainLightning (edict_t *ent, vec3_t start, vec3_t aimdir, int damage, int attack_range, int hop_range)
 {
 	int		i=0, hops=CLIGHTNING_MAX_HOPS;
@@ -201,9 +367,18 @@ void Cmd_ChainLightning_f (edict_t *ent, float skill_mult, float cost_mult)
 	VectorSet(offset, 0, 8,  ent->viewheight-8);
 	P_ProjectSource(ent->client, ent->s.origin, offset, forward, right, start);
 
-	ChainLightning(ent, start, forward, damage, attack_range, hop_range);
+	//ChainLightning(ent, start, forward, damage, attack_range, hop_range);
+	fire_chainlightning(ent, start, forward, damage, 0, attack_range, hop_range, 4);
 
-	ent->client->ability_delay = level.time + CLIGHTNING_DELAY/* * cost_mult*/;
+	//Talent: Wizardry - makes spell timer ability-specific instead of global
+	int talentLevel = vrx_get_talent_level(ent, TALENT_WIZARDRY);
+	if (talentLevel > 0)
+	{
+		ent->myskills.abilities[LIGHTNING].delay = level.time + CLIGHTNING_DELAY;
+		ent->client->ability_delay = level.time + CLIGHTNING_DELAY * (1 - 0.2 * talentLevel);
+	}
+	else
+		ent->client->ability_delay = level.time + CLIGHTNING_DELAY/* * cost_mult*/;
 	ent->client->pers.inventory[power_cube_index] -= cost;
 }
 

src/combat/abilities/fire.c

@@ -284,7 +284,16 @@ void Cmd_Fireball_f(edict_t* ent, float skill_mult, float cost_mult)
 
 	fire_fireball(ent, start, forward, damage, radius, speed, flames, flamedmg);
 
-	ent->client->ability_delay = level.time + FIREBALL_DELAY/* * cost_mult*/;
+	//Talent: Wizardry - makes spell timer ability-specific instead of global
+	int talentLevel = vrx_get_talent_level(ent, TALENT_WIZARDRY);
+	if (talentLevel > 0)
+	{
+		ent->myskills.abilities[FIREBALL].delay = level.time + FIREBALL_DELAY;
+		ent->client->ability_delay = level.time + FIREBALL_DELAY * (1 - 0.2 * talentLevel);
+	}
+	else
+		ent->client->ability_delay = level.time + FIREBALL_DELAY/* * cost_mult*/;
+
 	ent->client->pers.inventory[power_cube_index] -= cost;
 
 	// write a nice effect so everyone knows we've cast a spell
@@ -542,7 +551,15 @@ void Cmd_Firewall_f(edict_t* ent, float skill_mult, float cost_mult)
 	//  entity made a sound, used to alert monsters
 	ent->lastsound = level.framenum;
 
-	ent->client->ability_delay = level.time + FIREWALL_DELAY;
+	//Talent: Wizardry - makes spell timer ability-specific instead of global
+	int talentLevel = vrx_get_talent_level(ent, TALENT_WIZARDRY);
+	if (talentLevel > 0)
+	{
+		ent->myskills.abilities[FIREWALL].delay = level.time + FIREWALL_DELAY;
+		ent->client->ability_delay = level.time + FIREWALL_DELAY * (1 - 0.2 * talentLevel);
+	}
+	else
+		ent->client->ability_delay = level.time + FIREWALL_DELAY;
 	ent->client->pers.inventory[power_cube_index] -= cost;
 	ent->num_firewalls++;// increase firewall counter
 }

src/combat/abilities/flying_skull.c

@@ -381,7 +381,7 @@ void skull_movetogoal (edict_t *self, edict_t *goal)
 	gi.linkentity(self);
 }
 
-void ChainLightning(edict_t* ent, vec3_t start, vec3_t aimdir, int damage, int attack_range, int hop_range);
+//void ChainLightning(edict_t* ent, vec3_t start, vec3_t aimdir, int damage, int attack_range, int hop_range);
 
 void skull_attack (edict_t *self)
 {
@@ -447,7 +447,8 @@ void skull_attack (edict_t *self)
 		{
 			int cl_dmg = 10 * damage;
 			//gi.dprintf("hellspawn firing CL. base dmg %d modified %d CL %d\n", self->dmg, damage, cl_dmg);
-			ChainLightning(self, start, v, cl_dmg, SKULL_ATTACK_RANGE, CLIGHTNING_INITIAL_HR);
+			//ChainLightning(self, start, v, cl_dmg, SKULL_ATTACK_RANGE, CLIGHTNING_INITIAL_HR);
+			fire_chainlightning(self, start, v, cl_dmg, 0, SKULL_ATTACK_RANGE, CLIGHTNING_INITIAL_HR, 4);
 			self->autocurse_delay = level.framenum + (int)(1 / FRAMETIME);
 			return; // done attacking
 		}

src/combat/abilities/ice.c

@@ -327,6 +327,8 @@ void Cmd_GlacialSpike_f(edict_t* ent, float skill_mult, float cost_mult)
 	radius = GLACIAL_SPIKE_INITIAL_RADIUS + GLACIAL_SPIKE_ADDON_RADIUS * skill_level;
 	speed = GLACIAL_SPIKE_INITIAL_SPEED + GLACIAL_SPIKE_ADDON_SPEED * skill_level;
 
+	
+
 	//gi.dprintf("dmg:%d slvl:%d skill_mult:%f chill_duration:%f\n",damage,slvl,skill_mult,chill_duration);
 
 	// get starting position and forward vector
@@ -336,7 +338,16 @@ void Cmd_GlacialSpike_f(edict_t* ent, float skill_mult, float cost_mult)
 
 	fire_icebolt(ent, start, forward, damage, radius, speed, 2 * skill_level, chill_duration, freeze_duration);
 
-	ent->client->ability_delay = level.time + GLACIAL_SPIKE_DELAY/* * cost_mult*/;
+	//Talent: Wizardry - makes spell timer ability-specific instead of global
+	int talentLevel = vrx_get_talent_level(ent, TALENT_WIZARDRY);
+	if (talentLevel > 0)
+	{
+		ent->myskills.abilities[GLACIAL_SPIKE].delay = level.time + GLACIAL_SPIKE_DELAY;
+		ent->client->ability_delay = level.time + GLACIAL_SPIKE_DELAY * (1 - 0.2 * talentLevel);
+	}
+	else
+		ent->client->ability_delay = level.time + GLACIAL_SPIKE_DELAY/* * cost_mult*/;
+
 	ent->client->pers.inventory[power_cube_index] -= cost;
 
 	// write a nice effect so everyone knows we've cast a spell
@@ -546,7 +557,16 @@ void Cmd_FrozenOrb_f(edict_t* ent, float skill_mult, float cost_mult)
 
 	fire_frozenorb(ent, start, forward, damage, (2 * skill_level), chill_duration);
 
-	ent->client->ability_delay = level.time + FROZEN_ORB_DELAY;
+	//Talent: Wizardry - makes spell timer ability-specific instead of global
+	int talentLevel = vrx_get_talent_level(ent, TALENT_WIZARDRY);
+	if (talentLevel > 0)
+	{
+		ent->myskills.abilities[FROZEN_ORB].delay = level.time + FROZEN_ORB_DELAY;
+		ent->client->ability_delay = level.time + FROZEN_ORB_DELAY * (1 - 0.2 * talentLevel);
+		//gi.dprintf("%d: %s: delay: %.1f ability_delay: %.1f\n", (int)level.framenum, __func__, ent->myskills.abilities[GLACIAL_SPIKE].delay, ent->client->ability_delay);
+	}
+	else
+		ent->client->ability_delay = level.time + FROZEN_ORB_DELAY;
 	ent->client->pers.inventory[power_cube_index] -= cost;
 
 	// write a nice effect so everyone knows we've cast a spell