CSSZombieEscape/sm-zombiereloaded-3
7
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Implemented infect immunity mode. Debug messages are still enabled, and some parts aren't updated yet (compiler warnings).

Browse Source
This commit is contained in:
Richard Helgeby 2013-01-05 02:44:46 +01:00
parent cd604c2f95
commit 31c727f0a5
6 changed files with 428 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
cstrike/addons/sourcemod/configs/zr/playerclasses.txt
View File

@ -32,14 +32,15 @@
// fov number Field of view value. 90 is default.
// has_napalm yes/no Allows player to throw napalm grenades. Humans only.
// napalm_time decimal Napalm burn duration. Zombies only.
// immunity_mode test How the human is infected (humans only):
// immunity_mode test Special immunity modes. Some modes only works on humans or zombies:
// "none" - Instant infection.
// "full" - Immune to infection. Careful with this, it might not be that fun.
// "damage" - Allow zombies to stab humans to death, or below a HP threshold.
// "full" - Completely immune. Humans can't be infected, zombies don't receive damage or knock back. Careful with this, it might not be that fun.
// "infect" - Humans are immune to infections until HP go below a threshold. Threshold at zero enable stabbing to death.
// "damage" - Zombies are immune to damage from humans/grenades, but still vulnerable to knock back.
// "delay" - Delay infection for a certain number of seconds.
// "shield" - Allow human to deploy a shield that will give a temporary full immunity against infections.
// "shield" - Shield against infections (humans) or knock back (zombies) for a certain amount of seconds (similar to TF2's übercharge).
// immunity_amount number Immunity data value (humans only). Depends on the immunity mode above:
// "damage" - HP threshold. Infection will be allowed when HP go below this value. Zero will enable stabbing to death.
// "infect" - HP threshold. Infection will be allowed when HP go below this value. Zero will enable stabbing to death.
// "delay" - Number of seconds the infection is delayed since first hit by a zombie.
// "shield" - Number of seconds the shield is active.
// immunity_cooldown number Number of seconds of cooldown for temporary immunity effects (currently just shield mode).
@ -90,7 +91,8 @@
// Player behavior
"immunity_mode" "none"
"immunity_amount" "0"
"immunity_amount" "1"
"immunity_cooldown" "60"
"no_fall_damage" "yes"
"health" "2500"
@ -134,7 +136,8 @@
// Player behavior
"immunity_mode" "none"
"immunity_amount" "0"
"immunity_amount" "1"
"immunity_cooldown" "60"
"no_fall_damage" "yes"
"health" "2000"
@ -178,7 +181,8 @@
// Player behavior
"immunity_mode" "none"
"immunity_amount" "0"
"immunity_amount" "1"
"immunity_cooldown" "60"
"no_fall_damage" "yes"
"health" "3500"
@ -222,7 +226,8 @@
// Player behavior
"immunity_mode" "none"
"immunity_amount" "0"
"immunity_amount" "1"
"immunity_cooldown" "60"
"no_fall_damage" "yes"
"health" "4000"
@ -266,7 +271,8 @@
// Player behavior
"immunity_mode" "none"
"immunity_amount" "0"
"immunity_amount" "1"
"immunity_cooldown" "60"
"no_fall_damage" "yes"
"health" "2500"
@ -310,7 +316,8 @@
// Player behavior
"immunity_mode" "none"
"immunity_amount" "0"
"immunity_amount" "1"
"immunity_cooldown" "60"
"no_fall_damage" "yes"
"health" "3500"
@ -360,7 +367,8 @@
// Player behavior
"immunity_mode" "none"
"immunity_amount" "0"
"immunity_amount" "1"
"immunity_cooldown" "60"
"no_fall_damage" "no"
"health" "100"
@ -404,7 +412,8 @@
// Player behavior
"immunity_mode" "none"
"immunity_amount" "0"
"immunity_amount" "1"
"immunity_cooldown" "60"
"no_fall_damage" "yes"
"health" "200"
@ -448,7 +457,8 @@
// Player behavior
"immunity_mode" "none"
"immunity_amount" "0"
"immunity_amount" "1"
"immunity_cooldown" "60"
"no_fall_damage" "yes"
"health" "200"
@ -492,7 +502,8 @@
// Player behavior
"immunity_mode" "none"
"immunity_amount" "0"
"immunity_amount" "1"
"immunity_cooldown" "60"
"no_fall_damage" "0"
"health" "100"
@ -535,8 +546,9 @@
"napalm_time" "0.0"
// Player behavior
"immunity_mode" "none"
"immunity_amount" "0"
"immunity_mode" "infect" // Immune against infection,
"immunity_amount" "10" // when HP is above 10.
"immunity_cooldown" "60"
"no_fall_damage" "yes"
"health" "100"

5
src/zombiereloaded.sp
View File

@ -38,11 +38,13 @@
#include <sdkhooks>
#define ACTION_CONTINUE Plugin_Continue
#define ACTION_CHANGED Plugin_Changed
#define ACTION_HANDLED Plugin_Handled
#else
#include <zrtools>
#define ACTION_CONTINUE ZRTools_Continue
#define ACTION_CHANGED ZRTools_Changed
#define ACTION_HANDLED ZRTools_Handled
#endif
@ -198,6 +200,7 @@ public OnMapEnd()
VolOnMapEnd();
VEffectsOnMapEnd();
ZombieSoundsOnMapEnd();
ImmunityOnMapEnd();
}
/**
@ -260,6 +263,7 @@ public OnClientPutInServer(client)
RespawnClientInit(client);
ZTeleClientInit(client);
ZHPClientInit(client);
ImmunityClientInit(client);
}
/**
@ -312,6 +316,7 @@ public OnClientDisconnect(client)
AntiStickOnClientDisconnect(client);
ZSpawnOnClientDisconnect(client);
VolOnPlayerDisconnect(client);
ImmunityOnClientDisconnect(client);
}
/**

22
src/zr/damage.inc
View File

@ -216,6 +216,14 @@ public ZRTools_Action:DamageTraceAttack(client, inflictor, attacker, Float:damag
// Here we know that attacker and client are different teams.
// Check if immunity module requires damage to be blocked.
if (ImmunityOnClientTraceAttack(client, attacker, damage, hitgroup, damagetype))
{
// Block damage.
PrintToChatAll("DamageTraceAttack - Blocking damage.");
return ACTION_HANDLED;
}
// If client is a human, then allow damage.
if (InfectIsClientHuman(client))
{
@ -271,6 +279,8 @@ public Action:DamageOnTakeDamage(client, &attacker, &inflictor, &Float:damage, &
public ZRTools_Action:DamageOnTakeDamage(client, inflictor, attacker, Float:damage, damagetype, ammotype)
#endif
{
PrintToChatAll("DamageOnTakeDamage - damage:%f", damage);
// Get classname of the inflictor.
decl String:classname[64];
GetEdictClassname(inflictor, classname, sizeof(classname));
@ -323,13 +333,23 @@ public ZRTools_Action:DamageOnTakeDamage(client, inflictor, attacker, Float:dama
return ACTION_CONTINUE;
}
// Client is about to be infected, re-add HP so they aren't killed by knife.
// Check if immunity module blocked the damage.
if (ImmunityOnClientDamage(client, attacker, damage))
{
return ACTION_HANDLED;
}
// Client is about to be infected, re-add HP so they aren't killed by
// knife. But only do this when immunity mode is disabled.
if (ClassGetImmunityMode(client) == Immunity_None)
{
new health = GetClientHealth(client);
SetEntityHealth(client, health + RoundToNearest(damage));
// Allow damage.
return ACTION_CONTINUE;
}
}
// Client was damaged by explosion.
else if (damagetype & DMG_CSS_BLAST)
{

4
src/zr/event.inc
View File

@ -144,6 +144,7 @@ public Action:EventRoundEnd(Handle:event, const String:name[], bool:dontBroadcas
RespawnOnRoundEnd();
ZSpawnOnRoundEnd();
VolOnRoundEnd();
ImmunityOnRoundEnd();
}
/**
@ -162,6 +163,7 @@ public Action:EventPlayerTeam(Handle:event, const String:name[], bool:dontBroadc
// Forward event to modules.
InfectOnClientTeam(index, team);
ImmunityOnClientTeam(index);
return Plugin_Handled;
}
@ -190,6 +192,7 @@ public Action:EventPlayerSpawn(Handle:event, const String:name[], bool:dontBroad
ZTeleOnClientSpawn(index);
ZHPOnClientSpawn(index);
VolOnPlayerSpawn(index);
ImmunityClientSpawn(index);
// Fire post player_spawn event.
CreateTimer(0.1, EventPlayerSpawnPost, index);
@ -292,6 +295,7 @@ public Action:EventPlayerDeath(Handle:event, const String:name[], bool:dontBroad
ZHPOnClientDeath(index);
VolOnPlayerDeath(index);
RoundEndOnClientDeath();
ImmunityOnClientDeath(index);
}
/**

389
src/zr/immunityhandler.inc
View File

@ -36,23 +36,40 @@ new ImmunityMode:PlayerImmunityMode[MAXPLAYERS + 1] = {Immunity_None, ...};
new Handle:PlayerImmunityTimer[MAXPLAYERS + 1] = {INVALID_HANDLE, ...};
/**
* Last time a temporary immunity action was used (currently just shield mode).
* Used with cooldown of actions.
* Remaining time of timed immunity actions.
*/
new PlayerImmunityLastUse[MAXPLAYERS + 1] = {-1, ...};
new PlayerImmunityDuration[MAXPLAYERS + 1] = {-1, ...};
/**
* Cached attacker index for delayed infections, if available.
*/
new PlayerImmunityAttacker[MAXPLAYERS + 1] = {0, ...};
/**
* Timestamp of last action. Usage depends on mode (cooldown, etc).
*/
new PlayerImmunityLastUse[MAXPLAYERS + 1] = {0, ...};
/**
* Whether the player has passed a threshold (infect mode).
*/
new bool:PlayerImmunityThresholdPassed[MAXPLAYERS + 1] = {false, ...};
/**
* Handles immunity when a client is about to be infected. This function may
* delay or block infection according to the immunity mode class settings.
*
* @param client Client that's being infected.
* @param attacker Attacker client (zombie).
*
* @return True if infection will be handled by this module, false if
* infection can be applied instantly.
*/
bool:ImmunityOnClientInfect(client)
bool:ImmunityOnClientInfect(client, attacker)
{
// Get immunity data from client class.
PrintToChatAll("ImmunityOnClientInfect(client=%d, attacker=%d)", client, attacker);
// Get immunity mode from client class.
new ImmunityMode:mode = ClassGetImmunityMode(client);
// Check mode.
@ -68,35 +85,197 @@ bool:ImmunityOnClientInfect(client)
// Full immunity, do nothing.
return true;
}
case Immunity_Damage:
case Immunity_Infect:
{
return ImmunityDamageModeHandler(client);
return ImmunityInfectModeHandler(client, attacker);
}
case Immunity_Delay:
{
return ImmunityDelayModeHandler(client);
return ImmunityDelayModeHandler(client, attacker);
}
case Immunity_Shield:
{
return ImmunityShieldModeHandler(client);
}
default:
}
// Current mode doesn't apply to infection.
return false;
}
/**
* TraceAttack hook.
*
* Returns whether attacker damage should be blocked. If damage is blocked this
* module will handle it.
*
* @param client Client index.
* @param attacker Attacker client, if any.
* @param damage Damage received by client.
* @param hitgroup Hitgroup receiving damage.
*
* @return True if damage should be blocked, false otherwise.
*/
bool:ImmunityOnClientTraceAttack(client, attacker, Float:damage, hitgroup, damageType)
{
ThrowError("Invalid immunity mode. This is a bug in ZR.");
PrintToChatAll("ImmunityOnClientTraceAttack(client=%d, attacker=%d, damage=%f, hitgroup=%d, damageType=%d)", client, attacker, damage, hitgroup, damageType);
// Check if there is no attacker (world damage).
if (!ZRIsClientValid(attacker))
{
// Allow damage.
return false;
}
// Get immunity mode from client class.
new ImmunityMode:mode = ClassGetImmunityMode(client);
// Check mode.
switch(mode)
{
case Immunity_Full:
{
// Block damage.
return true;
}
case Immunity_Infect:
{
// Client must be human.
if (InfectIsClientInfected(client))
{
// Allow damage.
return false;
}
// Check if damage give HP below the infection threshold.
if (ImmunityBelowInfectThreshold(client, damage))
{
PrintToChatAll("ImmunityOnClientTraceAttack - Threshold passed");
PlayerImmunityThresholdPassed[client] = true;
}
else
{
PlayerImmunityThresholdPassed[client] = false;
}
/*new threshold = ClassGetImmunityAmount(client);
new clientHP = GetClientHealth(client);
new dmg = RoundToNearest(damage);
PrintToChatAll("threshold=%d, clientHp=%d", threshold, clientHP);
// Prevent humans with low HP from dying when a zombie is
// attacking, and stab to death is disabled (threshold above zero).
if (clientHP - dmg <= 0.0 && threshold > 0)
{
// Client is about to be infected. Remove damage, but don't
// block the damage event. The infect module need it to detect
// zombie attack.
damage = 0.0;
// Client is about to be infected, re-add HP so they aren't
// killed by knife. Don't block the damage, the infect
// module need the damage event.
//PrintToChatAll("Re-add HP.");
//SetEntityHealth(client, clientHP + dmg);
return false;
}*/
}
case Immunity_Damage:
{
// Client must be zombie.
if (!InfectIsClientInfected(client))
{
return false;
}
// Get attacker weapon.
decl String:weapon[32];
weapon[0] = 0;
if (damageType == DMG_BLAST)
{
// Most likely a HE grenade. GetClientWeapon can't be used if
// the attacker throw grenades. The attacker may switch weapon
// before the grenade explodes.
strcopy(weapon, sizeof(weapon), "hegrenade");
}
else
{
GetClientWeapon(attacker, weapon, sizeof(weapon));
}
// Since damage is blocked, trigger knock back hurt event manually.
KnockbackOnClientHurt(client, attacker, weapon, hitgroup, RoundToNearest(damage));
// Block damage from attacker.
return true;
}
case Immunity_Delay:
{
// Client must be human.
if (InfectIsClientInfected(client))
{
return false;
}
// Block damage if there's an infection in progress.
}
}
PrintToChatAll("Allow damage.");
return false;
}
/**
* TakeDamage hook.
*
* Blocks or modifies damage in certain situations.
*
* @param client Client index.
* @param attacker Attacker client, if any.
* @param damage Damage received by client.
*
* @return True if damage was blocked, false otherwise.
*/
bool:ImmunityOnClientDamage(client, attacker, &Float:damage)
{
PrintToChatAll("ImmunityOnClientDamage(client=%d, attacker=%d, damage=%f)", client, attacker, damage);
// Check if there is no attacker (world damage).
if (!ZRIsClientValid(attacker))
{
// Allow damage.
return false;
}
// Get immunity mode from client class.
new ImmunityMode:mode = ClassGetImmunityMode(client);
switch(mode)
{
case Immunity_Infect:
{
// Prevent humans with low HP from dying when a zombie is
// attacking, and stab to death is disabled (threshold above zero).
if (ImmunityBelowInfectThreshold(client, damage))
{
PrintToChatAll("ImmunityOnClientDamage - Below threshold, removing damage.");
// Client is about to be infected. Remove damage so the client
// won't die.
//damage = 0.0;
// Fake hurt event because it's not triggered when the damage
// was removed (because no one is actually hurt).
InfectOnClientHurt(client, attacker, "knife");
// Block damage to prevent player from dying.
return true;
}
}
}
/**
* Client is about to receive damage (zombie).
*
* @param Client that's receiving damage.
*
* @return True if damage should be blocked, false otherwise.
*/
bool:ImmunityOnClientHurt(client)
{
// Allow damage.
return false;
}
/**
@ -111,15 +290,53 @@ bool:ImmunityOnClientKnockBack(client)
}
/**
* Handles damage mode immunity.
* Handles infect mode immunity.
*
* Allow humans to receive damage from zombies until HP is below a certain
* threshold. If the threshold is zero, never infect.
*
* @param client Client that's being infected.
* @param attacker Attacker client (zombie).
*
* @return True if infection will be handled by this module, false if
* infection can be applied instantly.
*/
bool:ImmunityDamageModeHandler(client)
bool:ImmunityInfectModeHandler(client, attacker)
{
PrintToChatAll("ImmunityInfectModeHandler(client=%d, attacker=%d)", client, attacker);
// Note: ImmunityOnClientDamage and ImmunityOnClientTraceAttack hook into
// the damage module to prevent humans with low HP from dying when
// they're not supposed to.
new threshold = ClassGetImmunityAmount(client);
PrintToChatAll("threshold=%d", threshold);
// Check if infection is disabled.
if (threshold == 0)
{
// Infection is handled here: blocked.
PrintToChatAll("Infection disabled, block infection.");
return true;
}
if (PlayerImmunityThresholdPassed[client])
{
// Client HP below threshold, allow instant infection.
return false;
}
/*new clientHP = GetClientHealth(client);
PrintToChatAll("clientHP=%d", clientHP);
if (clientHP < threshold)
{
// Client HP below threshold, allow instant infection.
return false;
}*/
PrintToChatAll("Above threshold, block infection.");
return true;
}
/**
@ -130,55 +347,146 @@ bool:ImmunityDamageModeHandler(client)
* @return True if infection will be handled by this module, false if
* infection can be applied instantly.
*/
bool:ImmunityDelayModeHandler(client)
bool:ImmunityDelayModeHandler(client, attacker)
{
// Check if an infection is in progress
if (PlayerImmunityTimer[client] != INVALID_HANDLE)
{
// Additional attacks while a delayed infection is in progress will
// speedup the infection.
// Trigger timer event to reduce duration.
ImmunityDelayTimerHandler(PlayerImmunityTimer[client], client);
// Block infection.
return false;
}
// Start a delayed infection. Initialize duration and attacker.
PlayerImmunityDuration[client] = ClassGetImmunityAmount(client);
PlayerImmunityAttacker[client] = attacker;
// Create repated 1-second timer.
PlayerImmunityTimer[client] = CreateTimer(1.0, ImmunityDelayTimerHandler, client, TIMER_FLAG_NO_MAPCHANGE | TIMER_REPEAT);
// Block infection.
return false;
}
public Action:ImmunityDelayTimerHandler(Handle:timer, any:client)
{
// Verify that client is connected and alive.
if (!IsClientInGame(client) || !IsPlayerAlive(client))
{
// Client disconnected or died. Abort immunity action.
PlayerImmunityTimer[client] = INVALID_HANDLE;
ImmunityAbortHandler(client, false);
return Plugin_Stop;
}
// TODO: Read cvar for reduction amount.
new reduction = 2;
// Reduce duration.
PlayerImmunityDuration[client] -= reduction;
// Check if time is up.
if (PlayerImmunityDuration[client] <= 0)
{
// Time is up. Reset data.
PlayerImmunityDuration[client] = 0;
PlayerImmunityTimer[client] = INVALID_HANDLE;
ZREndTimer(PlayerImmunityTimer[client]);
// Infect client.
InfectHumanToZombie(client, PlayerImmunityAttacker[client]);
return Plugin_Stop;
}
return Plugin_Continue;
}
/**
* Handles shield mode immunity.
*
* @param client Client that's being infected.
* Zombies will get a shield against knock back, while humans become immune of
* infections.
*
* @param client Client deploying shield.
* @param asZombie Client is a zombie.
*
* @return True if infection will be handled by this module, false if
* infection can be applied instantly.
*/
bool:ImmunityShieldModeHandler(client)
bool:ImmunityShieldModeHandler(client, bool:asZombie = true)
{
return false;
}
/**
* Aborts any immunity mode in action (shields, delays, etc.).
* Aborts any immunity mode in action (shields, delays, etc.). Resets values.
*
* @param client Client that's aborting immunity mode actions.
* @param resetLastUse Reset timestamp of last use. This will reset cooldown.
*/
ImmunityAbortHandler(client)
ImmunityAbortHandler(client, bool:resetLastUse = true)
{
// TODO: Stop timers, disable shield.
// Stop timer, if running.
ZREndTimer(PlayerImmunityTimer[client]);
// Reset data.
PlayerImmunityDuration[client] = -1;
PlayerImmunityAttacker[client] = 0;
PlayerImmunityThresholdPassed[client] = false;
if (resetLastUse)
{
PlayerImmunityLastUse[client] = 0;
}
}
ImmunityAbortAll()
/**
* Aborts all immunity modes in action.
*
* @param resetLastUse Reset timestamp of last use. This will reset cooldown.
*/
ImmunityAbortAll(bool:resetLastUse = true)
{
for (new client = 0; client < MAXPLAYERS + 1; client++)
{
ImmunityAbortHandler(resetLastUse);
}
}
ImmunityOnClientHuman(client)
{
ImmunityAbortHandler(client);
}
ImmunityOnClientDeath(client, attacker)
ImmunityOnClientDeath(client)
{
ImmunityAbortHandler(client, false);
}
ImmunityClientInit(client)
{
// Abord old actions, initialize variables.
ImmunityAbortHandler(client);
}
ImmunityOnClientDisconnect(client, attacker)
ImmunityClientSpawn(client)
{
ImmunityAbortHandler(client, false);
}
ImmunityOnClientTeam(client, team)
ImmunityOnClientDisconnect(client)
{
// Loop through attacker cache and remove client (set to 0).
}
ImmunityOnClientTeam(client)
{
ImmunityAbortHandler(client);
}
ImmunityOnRoundEnd()
@ -191,6 +499,23 @@ ImmunityOnMapEnd()
ImmunityAbortAll();
}
bool:ImmunityBelowInfectThreshold(client, Float:damage)
{
new threshold = ClassGetImmunityAmount(client);
new clientHP = GetClientHealth(client);
new dmg = RoundToNearest(damage);
PrintToChatAll("threshold=%d, clientHp=%d", threshold, clientHP);
// Check if the damage go below the HP threshold.
if (clientHP - dmg <= 0.0 && threshold > 0)
{
return true;
}
return false;
}
/**
* Converts a string to an immunity mode.
*

10
src/zr/infect.inc
View File

@ -301,7 +301,8 @@ InfectOnClientDeath(client, attacker)
ToolsClientScore(attacker, true, true, score + bonus);
}
/** Client has been hurt.
/**
* Client has been hurt.
*
* @param client The client index.
* @param attacker The attacker index.
@ -339,6 +340,13 @@ InfectOnClientHurt(client, attacker, const String:weapon[])
return;
}
// Check if the immunity module is handling the infection.
if (ImmunityOnClientInfect(client, attacker))
{
PrintToChatAll("InfectOnClientHurt - Infect blocked.");
return;
}
// Infect client.
InfectHumanToZombie(client, attacker);
}