Restructured class system files. Added more functions for applying class attributes.

src/zombiereloaded.sp

@@ -26,7 +26,7 @@
 #include "zr/classes"
 #include "zr/models"
 #include "zr/overlays"
-#include "zr/playerclasses"
+#include "zr/playerclasses/playerclasses"
 #include "zr/antistick"
 #include "zr/anticamp"
 #include "zr/teleport"
@@ -136,6 +136,7 @@ public OnConfigsExecuted()
     FindMapSky();
     
     LoadClassData();
+    ClassLoad();
     LoadAmbienceData();
     
     decl String:mapconfig[PLATFORM_MAX_PATH];
@@ -244,4 +245,4 @@ ZREnd()
             }
         }
     }
-}
+}

src/zr/overlays.inc

@@ -44,4 +44,4 @@ public Action:KillOverlays(Handle:timer)
             ClientCommand(x, "r_screenoverlay \"\"");
         }
     }
-}
+}

src/zr/playerclasses/apply.inc

@@ -0,0 +1,147 @@
+/*
+ * ============================================================================
+ *
+ *   Zombie:Reloaded
+ *
+ *   File:        apply.inc
+ *   Description: Functions for applying attributes and effects on a client.
+ *   Author:      Richard Helgeby
+ *
+ * ============================================================================
+ */
+
+/**
+ * Applies all class attributes on a player. Changing model, hp, speed, health,
+ * effects etc. The players current team will be used to get the class index.
+ *
+ * @param client        The player to apply attributes on.
+ * @param improved      Optional. Gives advantages or improvements in some
+ *                      attributes. To be used on mother zombies. Default is
+ *                      false.
+ * @return  True if all success on applying all attributes, false otherwise.
+ */
+bool:ClassApplyAttributes(client, bool:improved = false)
+{
+    new classindex = ClassGetActiveIndex(client);
+    
+    if (classindex < 0)
+    {
+        return false;
+    }
+    
+    ClassApplyModel(client, classindex);
+    ClassApplyAlpha(client, classindex);
+    ClassApplyOverlay(client, classindex);
+}
+
+/**
+ * Changes the model on a player.
+ *
+ * @param client        The client index.
+ * @param classindex    The class to read from.
+ * @param cachetype     Optional. Specifies what class cache to read from.
+ *                      Options:
+ *                      ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                      ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                      ZR_CLASS_CACHE_PLAYER (default) - Player cache.
+ * @return  True on success, false otherwise.
+ */
+bool:ClassApplyModel(client, classindex, cachetpye = ZR_CLASS_CACHE_PLAYER)
+{
+    decl String:modelpath[256];
+    
+    // Get the model path from the specified cache.
+    if (cachetype == ZR_CLASS_CACHE_PLAYER)
+    {
+        ClassGetModelPath(client, modelpath, sizeof(modelpath), cachetype)
+    }
+    else
+    {
+        ClassGetModelPath(classindex, modelpath, sizeof(modelpath), cachetype)
+    }
+    
+    // Check if the user specified a random model.
+    if (strcmp(modelpath, "random", false) == 0)
+    {
+        // TODO: Make a function that gets a random model from the specified team.
+        new randmodel = GetRandomInt(0, GetArraySize(arrayModels) - 1);
+        GetArrayString(arrayModels, randmodel, modelpath, sizeof(modelpath));
+        Format(modelpath, sizeof(modelpath), "%s.mdl", modelpath);
+    }
+    
+    SetPlayerModel(client, modelpath);
+    return true;
+}
+
+/**
+ * Sets transparency on a player.
+ *
+ * @param client        The client index.
+ * @param classindex    The class to read from.
+ * @param cachetype     Optional. Specifies what class cache to read from.
+ *                      Options:
+ *                      ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                      ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                      ZR_CLASS_CACHE_PLAYER (default) - Player cache.
+ * @return  True on success, false otherwise.
+ */
+bool:ClassApplyAlpha(client, classindex, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+	new alpha;
+	
+	// Get the alpha value from the specified cache.
+    if (cachetype == ZR_CLASS_CACHE_PLAYER)
+    {
+        alpha = ClassGetAlphaSpawn(client, cachetype);
+    }
+    else
+    {
+        alpha = ClassGetAlphaSpawn(classindex, cachetype);
+    }
+    
+    if (alpha < 0)
+    {
+        return false;
+    }
+    
+	SetPlayerAlpha(client, alpha);
+	return true;
+}
+
+/**
+ * Apply the overlay on a player if not applied.
+ *
+ * @param client        The client index.
+ * @param classindex    The class to read from.
+ * @param cachetype     Optional. Specifies what class cache to read from.
+ *                      Options:
+ *                      ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                      ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                      ZR_CLASS_CACHE_PLAYER (default) - Player cache.
+ * @return  True on success, false otherwise.
+ */
+bool:ClassApplyOverlay(client, classindex, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    decl String:overlay[256];
+    
+    // Validate DirectX requirements.
+    if (dxLevel[client] < DXLEVEL_MIN)
+    {
+        // DirectX version is too old.
+        // TODO: Log warning?
+        return false;
+    }
+    
+    // Get the overlay path from the specified cache.
+    if (cachetype == ZR_CLASS_CACHE_PLAYER)
+    {
+        ClassGetOverlayPath(client, overlay, sizeof(overlay), cachetype);
+    }
+    else
+    {
+        ClassGetOverlayPath(classindex, overlay, sizeof(overlay), cachetype);
+    }
+    
+    ClassOverlayInitialize(client, overlay);
+    return true;
+}

src/zr/playerclasses/attributes.inc

@@ -0,0 +1,877 @@
+/*
+ * ============================================================================
+ *
+ *   Zombie:Reloaded
+ *
+ *   File:        attributes.inc
+ *   Description: Retrieving class attributes from certain caches.
+ *   Author:      Richard Helgeby
+ *
+ * ============================================================================
+ */
+
+/*
+ * ------------------------------------
+ *
+ *         GENERAL ATTRIBUTES
+ *
+ * ------------------------------------
+ */
+ 
+/**
+ * Checks if the specified class is enabled.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED (default) - Changed/newest class
+ *                  data.
+ *                  ZR_CLASS_CACHE_PLAYER - Player cache. If this one is used,
+ *                  index will be used as a client index.
+ * @return          True if it's enabled, false otherwise.
+ */
+bool:ClassIsEnabled(index, cachetype = ZR_CLASS_CACHE_MODIFIED)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return ClassData[index][class_enabled];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return ClassDataCache[index][class_enabled];
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return ClassPlayerCache[index][class_enabled];
+        }
+    }
+    return false;
+}
+
+/**
+ * Gets the team ID for the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return          The team ID if successful, -1 otherwise.
+ */
+ClassGetTeamID(index, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return ClassData[index][class_team];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return ClassDataCache[index][class_team];
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return ClassPlayerCache[index][class_team];
+        }
+    }
+    return -1;
+}
+
+/**
+ * Checks if the specified class is marked as the default class for its current
+ * team.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED (default) - Changed/newest class
+ *                  data.
+ *                  ZR_CLASS_CACHE_PLAYER - Player cache. If this one is used,
+ *                  index will be used as a client index.
+ * @return          True if it's default for its current team, false otherwise.
+ */
+bool:ClassGetTeamDefault(index, cachetype = ZR_CLASS_CACHE_MODIFIED)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return ClassData[index][class_team_default];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return ClassDataCached[index][class_team_default];
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return ClassPlayerCache[index][class_team_default];
+        }
+    }
+    return false;
+}
+
+/**
+ * Gets the class name to be displayed in the class menu.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param name      The destination string buffer.
+ * @param maxlen    The length of the destination string buffer.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return          Number of cells written. -1 on error.
+ */
+ClassGetName(index, String:name[], maxlen, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return strcopy(name, maxlen, ClassData[index][class_name]);
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return strcopy(name, maxlen, ClassDataCache[index][class_name]);
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return strcopy(name, maxlen, ClassPlayerCache[index][class_name]);
+        }
+    }
+    
+    return -1;
+}
+
+/**
+ * Gets the menu description string for the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param buffer    The destination string buffer.
+ * @param maxlen    The length of the destination string buffer.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return  Number of cells written. -1 on error.
+ */
+ClassGetDescription(index, String:buffer[], maxlen, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return strcopy(buffer, maxlen, ClassData[index][class_description]);
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return strcopy(buffer, maxlen, ClassDataCache[index][class_description]);
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return strcopy(buffer, maxlen, ClassPlayerCache[index][class_description]);
+        }
+    }
+    return -1;
+}
+
+
+
+/*
+ * ------------------------------------
+ *
+ *          MODEL ATTRIBUTES
+ *
+ * ------------------------------------
+ */
+
+/**
+ * Gets the model path string from the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param buffer    The destination string buffer.
+ * @param maxlen    The length of the destination string buffer.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return  Number of cells written. -1 on error.
+ */
+ClassGetModelPath(index, String:buffer[], maxlen, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return strcopy(buffer, maxlen, ClassData[index][class_model_path]);
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return strcopy(buffer, maxlen, ClassDataCache[index][class_model_path]);
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return strcopy(buffer, maxlen, ClassPlayerCache[index][class_model_path]);
+        }
+    }
+    return -1;
+}
+
+/**
+ * Gets the initial alpha value from the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return  The initial alpha value from the specified class. -1 on error.
+ */
+ClassGetAlphaInitial(index, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return ClassData[index][class_alpha_initial];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return ClassDataCache[index][class_alpha_initial];
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return ClassPlayerCache[index][class_alpha_initial];
+        }
+    }
+    return -1;
+}
+
+/**
+ * Gets the alpha value when damaged, from the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return  The alpha value when damaged, from the specified class. -1 on
+ *          error.
+ */
+ClassGetAlphaDamaged(index, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return ClassData[index][class_alpha_damaged];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return ClassDataCache[index][class_alpha_damaged];
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return ClassPlayerCache[index][class_alpha_damaged];
+        }
+    }
+    return -1;
+}
+
+/**
+ * Gets the damage amount needed to change alpha, from the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return  The damage amount needed to change alpha, from the specified class.
+ *          -1 on error.
+ */
+ClassGetAlphaDamage(index, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return ClassData[index][class_alpha_damage];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return ClassDataCache[index][class_alpha_damage];
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return ClassPlayerCache[index][class_alpha_damage];
+        }
+    }
+    return -1;
+}
+
+
+
+/*
+ * ------------------------------------
+ *
+ *           HUD ATTRIBUTES
+ *
+ * ------------------------------------
+ */
+
+/**
+ * Gets the overlay path from the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param buffer    The destination string buffer.
+ * @param maxlen    The length of the destination string buffer.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return  Number of cells written. -1 on error.
+ */
+ClassGetOverlayPath(index, String:buffer[], maxlen, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return strcopy(buffer, maxlen, ClassData[index][class_overlay_path]);
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return strcopy(buffer, maxlen, ClassDataCache[index][class_overlay_path]);
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return strcopy(buffer, maxlen, ClassPlayerCache[index][class_overlay_path]);
+        }
+    }
+    return -1;    
+}
+
+/**
+ * Gets the night vision setting from the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return  The night vision setting from the specified class. False on error.
+ */
+bool:ClassGetNVGs(index, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return ClassData[index][class_nvgs];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return ClassDataCache[index][class_nvgs];
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return ClassPlayerCache[index][class_nvgs];
+        }
+    }
+    return false;
+}
+
+/**
+ * Gets the field of view value from the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return  The field of view value from the specified class. -1 on error.
+ */
+ClassGetFOV(index, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return ClassData[index][class_fov];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return ClassDataCache[index][class_fov];
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return ClassPlayerCache[index][class_fov];
+        }
+    }
+    return -1;
+}
+
+
+
+/*
+ * ------------------------------------
+ *
+ *              EFFECTS
+ *
+ * ------------------------------------
+ */
+
+/**
+ * Gets the napalm grenades time from the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return  The napalm grenades time from the specified class. -1.0 on error.
+ */
+Float:ClassGetNapalmTime(index, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return ClassData[index][class_napalm_time];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return ClassDataCache[index][class_napalm_time];
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return ClassPlayerCache[index][class_napalm_time];
+        }
+    }
+    return -1.0;
+}
+
+
+
+/*
+ * ------------------------------------
+ *
+ *          PLAYER BEHAVIOUR
+ *
+ * ------------------------------------
+ */
+
+/**
+ * Gets the immunity mode to the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return  Current immunity mode to the specified class. -1 on error.
+ */
+ClassGetImmunityMode(index, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return ClassData[index][class_immunity_mode];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return ClassDataCache[index][class_immunity_mode];
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return ClassPlayerCache[index][class_immunity_mode];
+        }
+    }
+    return -1;
+}
+
+/**
+ * Gets the immunity amount to the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return  Current immunity amount to the specified class. -1.0 on error.
+ */
+Float:ClassGetImmunityAmount(index, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return ClassData[index][class_immunity_amount];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return ClassDataCache[index][class_immunity_amount];
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return ClassPlayerCache[index][class_immunity_amount];
+        }
+    }
+    return -1.0;
+}
+
+/**
+ * Gets the no fall damage setting from the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return  The no fall damage setting from the specified class. False on
+ * error.
+ */
+bool:ClassGetNoFallDamage(index, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return ClassData[index][class_no_fall_damage];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return ClassDataCache[index][class_no_fall_damage];
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return ClassPlayerCache[index][class_no_fall_damage];
+        }
+    }
+    return false;
+}
+
+/**
+ * Gets the health points from the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return  Health points from the specified class. -1 on error.
+ */
+ClassGetHealth(index, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return ClassData[index][class_health];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return ClassDataCache[index][class_health];
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return ClassPlayerCache[index][class_health];
+        }
+    }
+    return -1;
+}
+
+/**
+ * Gets the health regen interval time from the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return  The health regen interval time from the specified class. -1.0 on
+ *          error.
+ */
+Float:ClassGetHealthRegenInterval(index, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return ClassData[index][class_health_regen_interval];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return ClassDataCache[index][class_health_regen_interval];
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return ClassPlayerCache[index][class_health_regen_interval];
+        }
+    }
+    return -1.0;
+}
+
+/**
+ * Gets the health regen amount value from the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return  The health regen amount value from the specified class. -1 on
+ *          error.
+ */
+ClassGetHealthRegenAmount(index, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return ClassData[index][class_health_regen_amount];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return ClassDataCache[index][class_health_regen_amount];
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return ClassPlayerCache[index][class_health_regen_amount];
+        }
+    }
+    return -1;
+}
+
+/**
+ * Gets the health infect gain value from the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return  The health infect gain value from the specified class. -1 on
+ *          error.
+ */
+ClassGetHealthInfectGain(index, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return ClassData[index][class_health_infect_gain];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return ClassDataCache[index][class_health_infect_gain];
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return ClassPlayerCache[index][class_health_infect_gain];
+        }
+    }
+    return -1;
+}
+
+/**
+ * Gets the kill bonus points from the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return  The kill bonus points from the specified class.
+ */
+ClassGetKillBonus(index, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return ClassData[index][class_kill_bonus];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return ClassDataCache[index][class_kill_bonus];
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return ClassPlayerCache[index][class_kill_bonus];
+        }
+    }
+    return -1;
+}
+
+/**
+ * Gets the running speed value from the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return  The running speed value from the specified class. -1.0 on error.
+ */
+Float:ClassGetSpeed(index, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return ClassData[index][class_speed];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return ClassDataCache[index][class_speed];
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return ClassPlayerCache[index][class_speed];
+        }
+    }
+    return -1.0;
+}
+
+/**
+ * Gets the knock back boost from the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return  The knock back boost from the specified class. 0.0 on error.
+ */
+Float:ClassGetKnockback(index, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return ClassData[index][class_knockback];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return ClassDataCache[index][class_knockback];
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return ClassPlayerCache[index][class_knockback];
+        }
+    }
+    return 0.0;
+}
+
+/**
+ * Gets the jump height boost from the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return  The jump height boost from the specified class. -1.0 on error.
+ */
+Float:ClassGetJumpHeight(index, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return ClassData[index][class_jump_height];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return ClassDataCache[index][class_jump_height];
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return ClassPlayerCache[index][class_jump_height];
+        }
+    }
+    return -1.0;
+}
+
+/**
+ * Gets the jump distance boost from the specified class.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
+ *                  ZR_CLASS_CACHE_PLAYER (default) - Player cache. If this one
+ *                  is used, index will be used as a client index.
+ * @return  The jump distance boost from the specified class. -1.0 on error.
+ */
+Float:ClassGetJumpDistance(index, cachetype = ZR_CLASS_CACHE_PLAYER)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            return ClassData[index][class_jump_distance];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            return ClassDataCache[index][class_jump_distance];
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            return ClassPlayerCache[index][class_jump_distance];
+        }
+    }
+    return -1.0;
+}

src/zr/playerclasses/clientoverlays.inc

@@ -0,0 +1,98 @@
+/*
+ * ============================================================================
+ *
+ *   Zombie:Reloaded
+ *
+ *   File:        clientoverlays.inc
+ *   Description: Handles overlays on clients, as a part of class attributes.
+ *   Author:      Richard Helgeby
+ *
+ * ============================================================================
+ */
+
+/**
+ * Timer handles for redisplaying overlays on clients.
+ */
+new Handle:tOverlay[MAXPLAYERS + 1];
+
+/**
+ * Specifies if a client have a overlay.
+ */
+new bClientHasOverlay[MAXPLAYERS + 1];
+
+/**
+ * Tells wether the overlay is on or not.
+ */
+new bClientOverlayOn[MAXPLAYERS + 1];
+
+/**
+ * Path to the currently active overlay.
+ */
+new String:ActiveOverlay[MAXPLAYERS + 1][256];
+
+bool:ClientHasOverlay(client)
+{
+    return bClientHasOverlay[client];
+}
+
+ClassOverlayInitialize(client, const String:overlay)
+{
+    if (IsFakeClient(client))
+    {
+        return;
+    }
+    
+    if (strlen(overlay) == 0)
+    {
+        bClientHasOverlay[client] = false;
+    }
+    else
+    {
+        bClientHasOverlay[client] = true;
+        strcopy(ActiveOverlay[client], PLATFORM_MAX_PATH, overlay);
+        
+        ClassOverlayStart(client);
+    }
+}
+
+ClassOverlayStart(client)
+{
+    // Kill timer if it exist.
+    if (tOverlay[client] != INVALID_HANDLE)
+    {
+        KillTimer(tOverlay[client]);
+        tOverlay[client] = INVALID_HANDLE;
+    }
+    
+    ClientCommand(client, "r_screenoverlay \"%s\"", overlay);
+    bClientOverlayOn[client] = true;
+    
+    new Float:redisplay = GetConVarFloat(gCvars[CVAR_OVERLAY_REDISPLAY]);
+    tOverlay[client] = CreateTimer(redisplay, ClassOverlayTimer, client, TIMER_REPEAT);
+}
+
+ClassOverlayStop(client)
+{
+    // Kill timer if it exist.
+    if (tOverlay[client] != INVALID_HANDLE)
+    {
+        KillTimer(tOverlay[client]);
+        tOverlay[client] = INVALID_HANDLE;
+    }
+    
+    // Disable client overlay.
+    ClientCommand(client, "r_screenoverlay \"\"");
+    bClientOverlayOn[client] = false;
+}
+
+public Action:ClassOverlayTimer(Handle:timer, any:client)
+{
+    if (!IsClientInGame(client) || !IsPlayerZombie(client))
+    {
+        tOverlay[client] = INVALID_HANDLE;
+        return Plugin_Stop;
+    }
+    
+    ClientCommand(client, "r_screenoverlay \"%s\"", ActiveOverlay[client]);
+    return Plugin_Continue;
+}

src/zr/playerclasses/filtertools.inc

@@ -0,0 +1,473 @@
+/*
+ * ============================================================================
+ *
+ *   Zombie:Reloaded
+ *
+ *   File:        filtertools.inc
+ *   Description: Class system: Validating, getting indexes or lists
+ *   Author:      Richard Helgeby
+ *
+ * ============================================================================
+ */
+
+/**
+ * Validates the team requirements in a class cache and check that theres at
+ * least one class for each team. Minium team requirements are zombies and
+ * humans. The admin team is optinal.
+ *
+ * @param cachetype Optional. Specifies what class cache to validate. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL (default, unchanged class data),
+ *                  ZR_CLASS_CACHE_MODIFIED (modified class data).
+ * @return          True if validation was successful, false otherwise.
+ */
+bool:ClassValidateTeamRequirements(cachetype = ZR_CLASS_CACHE_ORIGINAL)
+{
+    new zombieindex;
+    new humanindex;
+    
+    // Check if there are no classes.
+    if (ClassCount == 0)
+    {
+        return false;
+    }
+    
+    // Test if a zombie and human class was found.
+    zombieindex = ClassGetFirstClass(ZR_CLASS_TEAM_ZOMBIES, _, cachetype);
+    humanindex = ClassGetFirstClass(ZR_CLASS_TEAM_HUMANS, _, cachetype);
+    
+    if (zombieindex > -1 && humanindex > -1)
+    {
+        return true;
+    }
+    
+    return false;
+}
+
+/**
+ * Validates all the class attributes in the original class data array, to
+ * check if they have invalid values.
+ *
+ * @param classindex    The index of the class to validate.
+ * @return              True if validation was successful, false otherwise.
+ */
+bool:ClassValidateAttributes(classindex)
+{
+    return true;
+    // TODO: Manually check each attribute (hard coded). Better solutions?
+}
+
+/**
+ * Checks if the specified class index points to a existing class in the
+ * ClassData array.
+ *
+ * @param classindex    The class index to validate.
+ * @return              True if the class exist, false otherwise.
+ */
+bool:ClassValidateIndex(classindex)
+{
+    if (ClassCount == 0)
+    {
+        return false;
+    }
+    
+    if (classindex >= 0 && classid < ClassCount)
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+/**
+ * Compares the class team ID with a team ID.
+ *
+ * @param index     Index of the class in a class cache or a client index,
+ *                  depending on the cache type specified.
+ * @param teamid    The team ID to compare with the class.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED (default) - Changed/newest class
+ *                  data.
+ *                  ZR_CLASS_CACHE_PLAYER - Player cache. If this one is used,
+ *                  index will be used as a client index.
+ * @return          True if equal, false otherwise.
+ */
+bool:ClassTeamCompare(index, teamid, cachetype = ZR_CLASS_CACHE_MODIFIED)
+{
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            if (ClassData[index][class_team] == teamid)
+            {
+                return true;
+            }
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            if (ClassDataCache[index][class_team] == teamid)
+            {
+                return true;
+            }
+        }
+        case ZR_CLASS_CACHE_PLAYER:
+        {
+            if (ClassPlayerCache[index][class_team] == teamid)
+            {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+/**
+ * Gets the first class index of a class with the specified name (not a case
+ * sensitive search).
+ *
+ * @param name      The name to search for.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED (default) - Changed/newest class
+ *                  data.
+ * @return          The class index if successful, -1 otherwise.
+ */
+ClassGetIndex(const String:name[], cachetype = ZR_CLASS_CACHE_MODIFIED)
+{
+    decl String:current_name[64];
+
+    // Check if there are no classes.
+    if (ClassCount == 0)
+    {
+        return false;
+    }
+    
+    // Loop through all classes.
+    for (new classindex = 0; classindex < ClassCount; classindex++)
+    {
+        // Get its name and compare it with the specified class name.
+        ClassesGetName(classindex, current_name, sizeof(current_name), cachetype);
+        if (strcmp(name, current_name, false) == 0)
+        {
+            return classindex;
+        }
+    }
+    
+    // The class index wasn't found.
+    return -1;
+}
+
+/**
+ * Gets the currently active class index that the player is using.
+ * Note: Does not check if the player is dead.
+ *
+ * @param client    The client index.
+ * @return  The active class index. -1 on error or if a spectactor.
+ */
+ClassGetActiveIndex(client)
+{
+    new teamid = GetClientTeam(client);
+    
+    if (teamid == CS_TEAM_SPECTACTOR || teamid == CS_TEAM_NONE)
+    {
+        // No active team.
+        return -1;
+    }
+    
+    if (IsPlayerHuman(client))
+    {
+        teamid = ZR_TEAM_HUMANS;
+    }
+    else
+    {
+        teamid = ZR_TEAM_ZOMBIES;
+    }
+    
+    // TODO: How to detect that virtual admin team?
+    
+    // Return the active class for the current team.
+    return ClassActive[client][teamid];
+}
+
+/**
+ * Gets all class indexes or from a specified team, and adds them to the
+ * specified array.
+ * 
+ * @param array         The destination array to add class indexes.
+ * @param teamfilter    Optional. The team ID to filter. A negative value for
+ *                      no filter (default).
+ * @param ignoreEnabled Optional. Ignore the class's enabled attribute. Default
+ *                      is false.
+ * @param cachetype     Optional. Specifies what class cache to read from.
+ *                      Options:
+ *                      ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                      ZR_CLASS_CACHE_MODIFIED (default) - Changed/newest
+ *                      class data.
+ * @return  True on success. False on error or if no classes were added or
+ *          found.
+ */
+bool:ClassAddToArray(Handle:array, teamfilter = -1, bool:ignoreEnabled = false, cachetype = ZR_CLASS_CACHE_MODIFIED)
+{
+    // Validate the array.
+    if (array == INVALID_HANDLE)
+    {
+        return false;
+    }
+    
+    // Check if there are no classes.
+    if (ClassCount == 0)
+    {
+        return false;
+    }
+    
+    // Store a local boolean that says if the user specified a team filter or not.
+    new bool:has_filter = bool:(teamfilter >= 0);
+    new classes_added;
+    
+    // Loop through all classes.
+    for (new classindex = 0; classindex < ClassCount; classindex++)
+    {
+        if (!ignoreEnabled && !ClassIsEnabled(classindex, cachetype))
+        {
+            // The class is disabled and the enabled attribute is NOT ignored.
+            // Skip to the next class.
+            continue;
+        }
+        
+        // Check team filtering.
+        if (has_filter)
+        {
+            // Only add classes with matching team ID.
+            if (ClassGetTeamID(classindex, cachetype) == teamfilter)
+            {
+                // Team ID match. Add class index to array.
+                PushArrayCell(array, classindex);
+                classes_added++;
+            }
+        }
+        else
+        {
+            // No filter. Add any class to the array.
+            PushArrayCell(array, classindex);
+            classes_added++;
+        }
+    }
+    
+    if (classes_added)
+    {
+        return true;
+    }
+    else
+    {
+        // No classes were found/added.
+        return false;
+    }
+}
+
+/**
+ * Gets a random class index from a specified team or from all classes.
+ *
+ * @param teamfilter    Optional. The team ID to filter. A negative value for
+ *                      no filter (default).
+ * @param ignoreEnabled Optional. Ignore the class's enabled attribute. Default
+ *                      is false.
+ * @param cachetype     Optional. Specifies what class cache to read from.
+ *                      Options:
+ *                      ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                      ZR_CLASS_CACHE_MODIFIED (default) - Changed/newest
+ *                      class data.
+ * @return  The class index if successful, or -1 on error.
+ */
+ClassGetRandomClass(teamfilter = -1, bool:ignoreEnabled = false, cachetype = ZR_CLASS_CACHE_MODIFIED)
+{
+    new Handle:classarray;
+    new arraycount;
+    new randnum;
+    
+    classarray = CreateArray();
+    
+    // Try to get a class list.
+    if (ClassAddToArray(classarray, teamfilter, ignoreEnabled, cachetype))
+    {
+        // Get a random index from the new class array.
+        arraycount = GetArraySize(classarray);
+        randnum = GetRandomInt(0, arraycount - 1);
+        
+        // Return the value at the random index.
+        return GetArrayCell(classarray, randnum);
+    }
+    else
+    {
+        // Failed to get a random class.
+        return -1;
+    }
+}
+
+/**
+ * Gets the first class index, or the first class index with the specified team
+ * ID.
+ *
+ * @param teamfilter    Optional. The team ID to filter. A negative value for
+ *                      no filter (default).
+ * @param ignoreEnabled Optional. Ignore the class's enabled attribute. Default
+ *                      is false.
+ * @param cachetype     Optional. Specifies what class cache to read from.
+ *                      Options:
+ *                      ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                      ZR_CLASS_CACHE_MODIFIED (default) - Changed/newest
+ *                      class data.
+ * @return  The first class index, or the first class index with the specified
+ *          team ID. -1 on error.
+ */
+ClassGetFirstClass(teamfilter = -1, bool:ignoreEnabled = false, cachetype = ZR_CLASS_CACHE_MODIFIED)
+{
+    // Check if there are no classes.
+    if (ClassCount == 0)
+    {
+        return false;
+    }
+    
+    new bool:has_filter = bool:(teamfilter >= 0);
+    
+    // Loop through all classes.
+    for (new classindex = 0; classindex < ClassCount; classindex++)
+    {
+        if (!ignoreEnabled && !ClassIsEnabled(classindex, cachetype))
+        {
+            continue;
+        }
+        
+        if (has_filter)
+        {
+            if (teamfilter == ClassGetTeamID(classindex, cachetype))
+            {
+                // Team ID match. Return the class index.
+                return classindex;
+            }
+        }
+        else
+        {
+            // No team filter. Return the class index.
+            return classindex;
+        }
+    }
+    
+    return -1;
+}
+
+/**
+ * Gets the default class index for the specified team configured to be used
+ * when players join the server.
+ *
+ * @param teamid    The team ID.
+ * @param cachetype Optional. Specifies what class cache to read from. Options:
+ *                  ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
+ *                  ZR_CLASS_CACHE_MODIFIED (default) - Changed/newest class
+ *                  data.
+ * @return  The class index of the default class for the specified team if
+ *          successful. -1 on critical errors. Otherwise it will try to fall
+ *          back on the first class in the specified team.
+ */
+ClassGetDefaultSpawnClass(teamid, cachetype = ZR_CLASS_CACHE_MODIFIED)
+{
+    decl String:classname[64];
+    new classindex;
+    new Handle:classarray;
+    new arraycount;
+    
+    // Get the default class name from the correct CVAR depending on teamid.
+    switch (teamid)
+    {
+        case ZR_CLASS_TEAM_ZOMBIES:
+        {
+            GetConVarString(gCvars[CVAR_CLASSES_DEFAULT_ZOMBIE], classname, sizeof(classname));
+        }
+        case ZR_CLASS_TEAM_HUMANS:
+        {
+            GetConVarString(gCvars[CVAR_CLASSES_DEFAULT_HUMAN], classname, sizeof(classname));
+        }
+        case ZR_CLASS_TEAM_ADMINS:
+        {
+            GetConVarString(gCvars[CVAR_CLASSES_DEFAULT_ADMIN], classname, sizeof(classname));
+        }
+        default:
+        {
+            // Invalid team ID.
+            return -1;
+        }
+    }
+    
+    // Check if the class name isn't empty.
+    if (strlen(class_name) > 0)
+    {
+        // Check if the user set "random" as default class.
+        if (strcmp(classname, "random", false) == 0)
+        {
+            // Get a list of all classes with the specified team ID.
+            classindex = ClassGetRandomClass(teamid, cachetype);
+            
+            // Validate the result, in case there were errors.
+            if (ClassValidateIndex(classindex))
+            {
+                return classindex;
+            }
+            else
+            {
+                // Invalid index. The ClassGetRandomClass function is pretty
+                // failsafe. So if we can't get a class index here, it's a
+                // critical error. No reason to fall back on other solutions.
+                return -1;
+            }
+        }
+        else
+        {
+            // The user set a spesific class.
+            
+            // Try to get the class index with the specified class name.
+            classindex = ClassGetClassIndex(classname, cachetype);
+            
+            // Validate the class index and check if the team IDs match.
+            if (ClassValidateIndex(classindex) && (teamid == ClassGetTeamID(classindex, cachetype)))
+            {
+                return classindex;
+            }
+            else
+            {
+                // The class index is invalid or the team IDs didn't match.
+                // Because it's user input, we'll fall back to the first class
+                // in the specified team, and log a warning.
+                classindex = ClassGetFirstClass(teamid, cachetype);
+                
+                if (LogFlagCheck(LOG_CORE_EVENTS, LOG_MODULE_CLASSES))
+                {
+                    ZR_LogMessageFormatted(-1, "classes", "default spawn class", "Warning: Failed to set \"%s\" as default spawn class for team %d. The class doesn't exist or the team IDs doesn't match. Falling back to the first class in the team.", _, classname, teamid);
+                }
+                
+                // Validate the new index.
+                if (ClassValidateIndex(classindex))
+                {
+                    // Log a warning.
+                    if (LogFlagCheck(LOG_CORE_EVENTS, LOG_MODULE_CLASSES))
+                    {
+                        ZR_LogMessageFormatted(-1, "classes", "default spawn class", "Warning: The default class name \"%s\" does not exist or matches the team ID.", _, classname);
+                    }
+                    
+                    return classindex;
+                }
+                else
+                {
+                    // Something went wrong. This is a critical error.
+                    return -1;
+                }
+            }
+        }
+    }
+    else
+    {
+        // Blank class name, return a error code.
+        return -1;
+    }
+}

src/zr/playerclasses/playerclasses.inc

@@ -0,0 +1,499 @@
+/*
+ * ============================================================================
+ *
+ *   Zombie:Reloaded
+ *
+ *   File:        playerclasses.inc
+ *   Description: Provides functions for managing classes.
+ *   Author:      Richard Helgeby, Greyscale
+ *
+ * ============================================================================
+ */
+
+/*
+    Ideas for immunity modes for humans:
+    - Zombies have to stab x times to infect.
+    - Zombies have to hurt humans so they loose hp. When the hp reach zero (or
+      below) they turn into zombies.
+    - Fully imune to all damage. Can't take or give damage. Sould only be used
+      on admin classes.
+
+    TODO: Admin command for overriding class values;
+          zr_class_ovverride <classname> <key> <value> [value_is_multiplier]
+          Either set absolute values or use it as a multiplier, if possible.
+          "classname" should support "all" to set a spesific value on all
+          classes.
+          
+          How overrides should work:
+          When a player select a class, its attributes are cached for each
+          player. On infection or spawn, the plugin will use the cached
+          values.
+          
+          When we override, the real class attributes are changed and then
+          copied to the player caches (with matching team IDs).
+          
+          There is one problem, the in-game knockback multiplier menu. It
+          depends on the original class knockback values. A solution might be
+          to have another array of class data, which is never canged.
+    
+    TODO: Make a solution with default valueas for each class team, without
+          using CVARs.
+          
+          SOLVED: Added boolean team_default class attribute. Default values
+          will be used from the first class with this value set.
+    
+    TODO: Make class attributes for for changing model render mode and colors.
+    
+    TODO: Make class attributes for fancy effects, like a glow (if possible).
+    
+    TODO: Make alpha settings also apply to weapons (we could use code from
+          zombie riot in this case).
+    
+    TODO: Make immunity settings suitable for both teams, or certain zombie-
+          only/human-only settings.
+*/
+
+/**
+ * Total number of classes that can be stored in each cache. A total of 32
+ * classes should be enough. Too many classes will comfuse players.
+ */
+#define ZR_CLASS_MAX 31
+
+/**
+ * @section Class cache types. Specifies what data array to use.
+ */
+#define ZR_CLASS_CACHE_ORIGINAL 0   /** Points ClassData array. A cache that is never changed after loading. */
+#define ZR_CLASS_CACHE_MODIFIED 1   /** Points to ClassDataCache array. Modified by admins or overrides. */
+#define ZR_CLASS_CACHE_PLAYER   2   /** Points to ClassPlayerCache array. Current player attributes. */
+/**
+ * @endsection
+ */
+
+/**
+ * Number of available class teams.
+ */
+#define ZR_CLASS_TEAMCOUNT      3
+
+/**
+ * @section Available class teams. The admin team is optional and not required
+ * in class configs.
+ */
+#define ZR_CLASS_TEAM_ZOMBIES   0
+#define ZR_CLASS_TEAM_HUMANS    1
+#define ZR_CLASS_TEAM_ADMINS    2   /** Note: Will set you in a special mode where you don't really participates in the game, but just walk around. */
+/**
+ * @endsection
+ */
+
+/**
+ * @section Damage immunity modes. The mode effects will vary depending on the
+ * class team.
+ */
+#define ZR_CLASS_IMMUNITY_DISABLED  0   /** No immunity. */
+#define ZR_CLASS_IMMUNITY_CONSTANT  1   /** Always imune. Should only be used in special cases like on admin classes. */
+#define ZR_CLASS_IMMUNITY_TIMED     2   /** Imune to damage for n seconds. The time is specified in a class as immunity amount. */
+/**
+ * @endsection
+ */
+
+/**
+ * @section Overall default class settings. Since this is a zombie plugin the
+ * default values represent a zombie.
+ */
+#define ZR_CLASS_DEFAULT_ENABLED                true
+#define ZR_CLASS_DEFAULT_TEAM                   ZR_CLASS_TEAM_ZOMBIES
+#define ZR_CLASS_DEFAULT_TEAM_DEFAULT           true
+#define ZR_CLASS_DEFAULT_NAME                   "classic"
+#define ZR_CLASS_DEFAULT_DESCRIPTION            "Need brains!!! Arrrrggghh!"
+#define ZR_CLASS_DEFAULT_MODEL_PATH             "models/player/zh/zh_zombie003.mdl"
+#define ZR_CLASS_DEFAULT_ALPHA_INITIAL          255
+#define ZR_CLASS_DEFAULT_ALPHA_DAMAGED          255
+#define ZR_CLASS_DEFAULT_ALPHA_DAMAGE           0
+#define ZR_CLASS_DEFAULT_OVERLAY_PATH           "overlays/zr/zvision"
+#define ZR_CLASS_DEFAULT_NVGS                   true
+#define ZR_CLASS_DEFAULT_FOV                    90
+#define ZR_CLASS_DEFAULT_NAPALM_TIME            10.0
+#define ZR_CLASS_DEFAULT_IMMUNITY_MODE          ZR_CLASS_IMMUNITY_DISABLED
+#define ZR_CLASS_DEFAULT_IMMUNITY_AMOUNT        0.0
+#define ZR_CLASS_DEFAULT_NO_FALL_DAMAGE         true
+#define ZR_CLASS_DEFAULT_HEALTH                 6000
+#define ZR_CLASS_DEFAULT_HEALTH_REGEN_INTERVAL  0.0
+#define ZR_CLASS_DEFAULT_HEALTH_REGEN_AMOUNT    2
+#define ZR_CLASS_DEFAULT_HEALTH_INFECT_GAIN     800
+#define ZR_CLASS_DEFAULT_KILL_BONUS             2
+#define ZR_CLASS_DEFAULT_SPEED                  360.0
+#define ZR_CLASS_DEFAULT_KNOCKBACK              2.0
+#define ZR_CLASS_DEFAULT_JUMP_HEIGHT            10.0
+#define ZR_CLASS_DEFAULT_JUMP_DISTANCE          0.2
+/**
+ * @endsection
+ */
+
+/**
+ * Generic player attributes.
+ */
+enum ClassAttributes
+{
+    /* General */
+    bool:class_enabled,
+    class_team,
+    bool:class_team_default,
+    
+    String:class_name[64],
+    String:class_description[256],
+    
+    /* Model */
+    String:class_model_path[256],
+    class_alpha_initial,
+    class_alpha_damaged,
+    class_alpha_damage,
+    
+    /* Hud */
+    String:class_overlay_path[256],
+    bool:class_nvgs,
+    class_fov,
+    
+    /* Effects */
+    Float:class_napalm_time,
+    
+    /* Player behaviour */
+    class_immunity_mode,
+    Float:class_immunity_amount,
+    bool:class_no_fall_damage,
+    
+    class_health,
+    Float:class_health_regen_interval,
+    class_health_regen_amount,
+    class_health_infect_gain,
+    class_kill_bonus,
+    
+    Float:class_speed,
+    Float:class_knockback,
+    Float:class_jump_height,
+    Float:class_jump_distance
+}
+
+new Handle:kvClassData;
+
+/**
+ * The original class data. This array only changed when class data is loaded.
+ * ZR_CLASS_CACHE_ORIGINAL is the cache type to this array.
+ */
+new ClassData[ZR_CLASS_MAX][ClassAttributes];
+
+/**
+ * The class thata cache that can be modified. ZR_CLASS_CACHE_MODIFIED is the
+ * cache type to this array.
+ */
+new ClassDataCache[ZR_CLASS_MAX][ClassAttributes];
+
+/**
+ * Cache for player attributes. Makes it possible for one or more players to
+ * have custom attributes. ZR_CLASS_CACHE_PLAYER is the cache type to this
+ * array.
+ */
+new ClassPlayerCache[MAXPLAYERS + 1][ClassAttributes];
+
+/**
+ * Number of classes successfully loaded.
+ */
+new ClassCount;
+
+/**
+ * Stores what class that the player have selected, for each team.
+ */
+new ClassActive[MAXPLAYERS + 1][ZR_CLASS_TEAMCOUNT - 1];
+
+#include "zr/playerclasses/filtertools"
+#include "zr/playerclasses/attributes"
+#include "zr/playerclasses/apply"
+#include "zr/playerclasses/clientoverlays"
+
+/**
+ * Loads class attributes from playerclasses.txt into the ClassData array. If
+ * any error occour, the plugin load will fail.
+ *
+ * @param classfile     Optional. Specifies what file to read from. Valves key/
+ *                      values format. The path is relative to the sourcemod
+ *                      folder.
+ */
+ClassLoad(const String:classfile[256] = "configs/zr/playerclasses.txt")
+{
+    // Make sure kvClassData is ready to use.
+    if (kvClassData != INVALID_HANDLE)
+    {
+        CloseHandle(kvClassData);
+    }
+    kvClassData = CreateKeyValues("classes");
+    
+    // Try to load the class configuration file.
+    decl String:path[PLATFORM_MAX_PATH];
+    BuildPath(Path_SM, path, sizeof(path), classfile);
+    
+    if (!FileToKeyValues(kvClassData, path))
+    {
+        SetFailState("Class data (\"%s\") missing from server.", path);
+    }
+    
+    // Try to find the first class.
+    KvRewind(kvClassData);
+    if (!KvGotoFirstSubKey(kvClassData))
+    {
+        SetFailState("Cannot find any classes in \"%s\".", path);
+    }
+    
+    decl String:name[64];
+    decl String:description[256];
+    decl String:model_path[256];
+    decl String:overlay_path[256];
+    
+    ClassCount = 0;
+    
+    // Loop through all classes and store attributes in the ClassData array.
+    do
+    {
+        if (ClassCount > ZR_CLASS_MAX)
+        {
+            // Maximum classes reached. Write a warning and exit the loop.
+            if (LogFlagCheck(LOG_CORE_EVENTS, LOG_MODULE_CLASSES))
+            {
+                ZR_LogMessageFormatted(-1, "classes", "loading classes", "Warning: Maximum classes reached (%d). The rest is skipped.", _, ZR_CLASS_MAX + 1);
+            }
+            
+            break;
+        }
+        
+        /* General */
+        ClassData[ClassCount][class_enabled] = bool:KvGetNum(kvClassData, "enabled", ZR_CLASS_DEFAULT_ENABLED);
+        ClassData[ClassCount][class_team] = KvGetNum(kvClassData, "team", ZR_CLASS_DEFAULT_TEAM);
+        
+        KvGetString(kvClassData, "name", name, sizeof(name), ZR_CLASS_DEFAULT_NAME);
+        strcopy(ClassData[ClassCount][class_name], 64, name);
+        
+        KvGetString(kvClassData, "description", description, sizeof(description), ZR_CLASS_DEFAULT_DESCRIPTION);
+        strcopy(ClassData[ClassCount][class_description], 256, description);
+        
+        
+        /* Model */
+        KvGetString(kvClassData, "model_path", model_path, sizeof(model_path), ZR_CLASS_DEFAULT_MODEL_PATH);
+        strcopy(ClassData[ClassCount][class_model_path], 256, model_path);
+        
+        ClassData[ClassCount][class_alpha_initial] = KvGetNum(kvClassData, "alpha_initial", ZR_CLASS_DEFAULT_ALPHA_INITIAL);
+        ClassData[ClassCount][class_alpha_damaged] = KvGetNum(kvClassData, "alpha_damaged", ZR_CLASS_DEFAULT_ALPHA_DAMAGED);
+        ClassData[ClassCount][class_alpha_damage] = KvGetNum(kvClassData, "alpha_damage", ZR_CLASS_DEFAULT_ALPHA_DAMAGE);
+        
+        
+        /* Hud */
+        KvGetString(kvClassData, "overlay_path", overlay_path, sizeof(overlay_path), ZR_CLASS_DEFAULT_OVERLAY_PATH);
+        strcopy(ClassData[ClassCount][class_overlay_path], 256, overlay_path);
+        
+        ClassData[ClassCount][class_nvgs] = bool:KvGetNum(kvClassData, "nvgs", ZR_CLASS_DEFAULT_NVGS);
+        ClassData[ClassCount][class_fov] = KvGetNum(kvClassData, "fov", ZR_CLASS_DEFAULT_FOV);
+        
+        
+        /* Effects */
+        ClassData[ClassCount][class_napalm_time] = KvGetFloat(kvClassData, "napalm_time", ZR_CLASS_DEFAULT_NAPALM_TIME);
+        
+        
+        /* Player behaviour */
+        ClassData[ClassCount][class_immunity_mode] = KvGetNum(kvClassData, "immunity_mode", ZR_CLASS_DEFAULT_IMMUNITY_MODE);
+        ClassData[ClassCount][class_immunity_amount] = KvGetFloat(kvClassData, "immunity_amount", ZR_CLASS_DEFAULT_IMMUNITY_AMOUNT);
+        ClassData[ClassCount][class_no_fall_damage] = bool:KvGetNum(kvClassData, "no_fall_damage", ZR_CLASS_DEFAULT_NO_FALL_DAMAGE);
+        
+        ClassData[ClassCount][class_health] = KvGetNum(kvClassData, "health", ZR_CLASS_DEFAULT_HEALTH);
+        ClassData[ClassCount][class_health_regen_interval] = KvGetFloat(kvClassData, "health_regen_interval", ZR_CLASS_DEFAULT_HEALTH_REGEN_INTERVAL);
+        ClassData[ClassCount][class_health_regen_amount] = KvGetNum(kvClassData, "health_regen_amount", ZR_CLASS_DEFAULT_HEALTH_REGEN_AMOUNT);
+        ClassData[ClassCount][class_health_infect_gain] = KvGetNum(kvClassData, "health_infect_bonus", ZR_CLASS_DEFAULT_HEALTH_INFECT_GAIN);
+        ClassData[ClassCount][class_kill_bonus] = KvGetNum(kvClassData, "kill_bonus", ZR_CLASS_DEFAULT_KILL_BONUS);
+        
+        ClassData[ClassCount][class_speed] = KvGetFloat(kvClassData, "speed", ZR_CLASS_DEFAULT_SPEED);
+        ClassData[ClassCount][class_knockback] = KvGetFloat(kvClassData, "knockback", ZR_CLASS_DEFAULT_KNOCKBACK);
+        ClassData[ClassCount][class_jump_height] = KvGetFloat(kvClassData, "jump_height", ZR_CLASS_DEFAULT_JUMP_HEIGHT);
+        ClassData[ClassCount][class_jump_distance] = KvGetFloat(kvClassData, "jump_distance", ZR_CLASS_DEFAULT_JUMP_DISTANCE);
+        
+        // Validate the class attributes.
+        if (!ClassValidateAttributes(ClassCount))
+        {
+            // TODO: There's an invalid class, what do we do?
+            // Skip it (clearing data too), disable it and give a log warning,
+            // or set the plugin in a failed state?
+        }
+        else
+        {
+            // The class is valid. Update the counter.
+            ClassCount++;
+        }
+    } while (KvGotoNextKey(kvClassData));
+    
+    // Validate team requirements.
+    if (!ClassValidateTeamRequirements())
+    {
+        SetFailState("The class configuration doesn't match the team requirements.");
+    }
+}
+
+/**
+ * Updates the class data cache. Original values are retrieved from ClassData.
+ *
+ * @return      True on success, false otherwise.
+ */
+bool:ClassReloadDataCache()
+{
+    /*
+     * TODO: This must be done in a safe way, because the plugin may read from
+     *       the cache at any time. The plugin might read attributes at the
+     *       same time when the cache is reloaded. There's a chance for
+     *       corrupted attributes at that exact moment.
+     */
+    
+    if (ClassCount == 0)
+    {
+        return false;
+    }
+    
+    for (new classindex = 0; classindex < ClassCount; clasindex++)
+    {
+        /* General */
+        ClassDataCache[classindex][class_enabled] = ClassData[classindex][class_enabled];
+        ClassDataCache[classindex][class_team] = ClassData[classindex][class_team];
+        ClassDataCache[classindex][class_team_default] = ClassData[classindex][class_team_default];
+        strcopy(ClassDataCache[classindex][class_name], 64, ClassData[classindex][class_name]);
+        strcopy(ClassDataCache[classindex][class_description], 256, ClassData[classindex][class_description]);
+        
+        /* Model */
+        strcopy(ClassDataCache[classindex][class_model_path], 256, ClassData[classindex][class_model_path]);
+        ClassDataCache[classindex][class_alpha_initial] = ClassData[classindex][class_alpha_initial];
+        ClassDataCache[classindex][class_alpha_damaged] = ClassData[classindex][class_alpha_damaged];
+        ClassDataCache[classindex][class_alpha_damage] = ClassData[classindex][class_alpha_damage];
+        
+        /* Hud */
+        strcopy(ClassDataCache[classindex][class_overlay_path], 256, ClassData[classindex][class_overlay_path]);
+        ClassDataCache[classindex][class_nvgs] = ClassData[classindex][class_nvgs];
+        ClassDataCache[classindex][class_fov] = ClassData[classindex][class_fov];
+        
+        /* Effects */
+        ClassDataCache[classindex][class_napalm_time] = ClassData[classindex][class_napalm_time];
+        
+        /* Player behaviour */
+        ClassDataCache[classindex][class_immunity_mode] = ClassData[classindex][class_immunity_mode];
+        ClassDataCache[classindex][class_immunity_amount] = ClassData[classindex][class_immunity_amount];
+        ClassDataCache[classindex][class_no_fall_damage] = ClassData[classindex][class_no_fall_damage];
+        ClassDataCache[classindex][class_health] = ClassData[classindex][class_health];
+        ClassDataCache[classindex][class_health_regen_interval] = ClassData[classindex][class_health_regen_interval];
+        ClassDataCache[classindex][class_health_regen_amount] = ClassData[classindex][class_health_regen_amount];
+        ClassDataCache[classindex][class_health_infect_gain] = ClassData[classindex][class_health_infect_gain];
+        ClassDataCache[classindex][class_kill_bonus] = ClassData[classindex][class_kill_bonus];
+        ClassDataCache[classindex][class_speed] = ClassData[classindex][class_speed];
+        ClassDataCache[classindex][class_knockback] = ClassData[classindex][class_knockback];
+        ClassDataCache[classindex][class_jump_height] = ClassData[classindex][class_jump_height];
+        ClassDataCache[classindex][class_jump_distance] = ClassData[classindex][class_jump_distance];
+    }
+    
+    return true;
+}
+
+/**
+ * Clears the players class data and copies data from the specified class data
+ * cache.
+ *
+ * @param client        The client index.
+ * @param classindex    The index of the class to read from.
+ * @param cachetype     Optional. Specifies what class cache to read from.
+ *                      Options: ZR_CLASS_CACHE_ORIGINAL (unchanged class
+ *                      data), ZR_CLASS_CACHE_MODIFIED (default, modified class
+ *                      data).
+ * @return      True if successful, false otherwise.
+ */
+bool:ClassReloadPlayerCache(client, classindex, cachetype = ZR_CLASS_CACHE_MODIFIED)
+{
+    // Validate indexes.
+    if (!ClassValidateIndex(classindex) || !IsClientPlayer(client))
+    {
+        return false;
+    }
+    
+    switch (cachetype)
+    {
+        case ZR_CLASS_CACHE_ORIGINAL:
+        {
+            /* General */
+            ClassPlayerCache[client][class_enabled] = ClassData[classindex][class_enabled];
+            ClassPlayerCache[client][class_team] = ClassData[classindex][class_team];
+            ClassPlayerCache[client][class_team_default] = ClassData[classindex][class_team_default];
+            strcopy(ClassPlayerCache[client][class_name], 64, ClassData[classindex][class_name]);
+            strcopy(ClassPlayerCache[client][class_description], 256, ClassData[classindex][class_description]);
+            
+            /* Model */
+            strcopy(ClassPlayerCache[client][class_model_path], 256, ClassData[classindex][class_model_path]);
+            ClassPlayerCache[client][class_alpha_initial] = ClassData[classindex][class_alpha_initial];
+            ClassPlayerCache[client][class_alpha_damaged] = ClassData[classindex][class_alpha_damaged];
+            ClassPlayerCache[client][class_alpha_damage] = ClassData[classindex][class_alpha_damage];
+            
+            /* Hud */
+            strcopy(ClassPlayerCache[client][class_overlay_path], 256, ClassData[classindex][class_overlay_path]);
+            ClassPlayerCache[client][class_nvgs] = ClassData[classindex][class_nvgs];
+            ClassPlayerCache[client][class_fov] = ClassData[classindex][class_fov];
+            
+            /* Effects */
+            ClassPlayerCache[client][class_napalm_time] = ClassData[classindex][class_napalm_time];
+            
+            /* Player behaviour */
+            ClassPlayerCache[client][class_immunity_mode] = ClassData[classindex][class_immunity_mode];
+            ClassPlayerCache[client][class_immunity_amount] = ClassData[classindex][class_immunity_amount];
+            ClassPlayerCache[client][class_no_fall_damage] = ClassData[classindex][class_no_fall_damage];
+            ClassPlayerCache[client][class_health] = ClassData[classindex][class_health];
+            ClassPlayerCache[client][class_health_regen_interval] = ClassData[classindex][class_health_regen_interval];
+            ClassPlayerCache[client][class_health_regen_amount] = ClassData[classindex][class_health_regen_amount];
+            ClassPlayerCache[client][class_health_infect_gain] = ClassData[classindex][class_health_infect_gain];
+            ClassPlayerCache[client][class_kill_bonus] = ClassData[classindex][class_kill_bonus];
+            ClassPlayerCache[client][class_speed] = ClassData[classindex][class_speed];
+            ClassPlayerCache[client][class_knockback] = ClassData[classindex][class_knockback];
+            ClassPlayerCache[client][class_jump_height] = ClassData[classindex][class_jump_height];
+            ClassPlayerCache[client][class_jump_distance] = ClassData[classindex][class_jump_distance];
+        }
+        case ZR_CLASS_CACHE_MODIFIED:
+        {
+            /* General */
+            ClassPlayerCache[client][class_enabled] = ClassDataCache[classindex][class_enabled];
+            ClassPlayerCache[client][class_team] = ClassDataCache[classindex][class_team];
+            ClassPlayerCache[client][class_team_default] = ClassDataCache[classindex][class_team_default];
+            strcopy(ClassPlayerCache[client][class_name], 64, ClassDataCache[classindex][class_name]);
+            strcopy(ClassPlayerCache[client][class_description], 256, ClassDataCache[classindex][class_description]);
+            
+            /* Model */
+            strcopy(ClassPlayerCache[client][class_model_path], 256, ClassDataCache[classindex][class_model_path]);
+            ClassPlayerCache[client][class_alpha_initial] = ClassDataCache[classindex][class_alpha_initial];
+            ClassPlayerCache[client][class_alpha_damaged] = ClassDataCache[classindex][class_alpha_damaged];
+            ClassPlayerCache[client][class_alpha_damage] = ClassDataCache[classindex][class_alpha_damage];
+            
+            /* Hud */
+            strcopy(ClassPlayerCache[client][class_overlay_path], 256, ClassDataCache[classindex][class_overlay_path]);
+            ClassPlayerCache[client][class_nvgs] = ClassDataCache[classindex][class_nvgs];
+            ClassPlayerCache[client][class_fov] = ClassDataCache[classindex][class_fov];
+            
+            /* Effects */
+            ClassPlayerCache[client][class_napalm_time] = ClassDataCache[classindex][class_napalm_time];
+            
+            /* Player behaviour */
+            ClassPlayerCache[client][class_immunity_mode] = ClassDataCache[classindex][class_immunity_mode];
+            ClassPlayerCache[client][class_immunity_amount] = ClassDataCache[classindex][class_immunity_amount];
+            ClassPlayerCache[client][class_no_fall_damage] = ClassDataCache[classindex][class_no_fall_damage];
+            ClassPlayerCache[client][class_health] = ClassDataCache[classindex][class_health];
+            ClassPlayerCache[client][class_health_regen_interval] = ClassDataCache[classindex][class_health_regen_interval];
+            ClassPlayerCache[client][class_health_regen_amount] = ClassDataCache[classindex][class_health_regen_amount];
+            ClassPlayerCache[client][class_health_infect_gain] = ClassDataCache[classindex][class_health_infect_gain];
+            ClassPlayerCache[client][class_kill_bonus] = ClassDataCache[classindex][class_kill_bonus];
+            ClassPlayerCache[client][class_speed] = ClassDataCache[classindex][class_speed];
+            ClassPlayerCache[client][class_knockback] = ClassDataCache[classindex][class_knockback];
+            ClassPlayerCache[client][class_jump_height] = ClassDataCache[classindex][class_jump_height];
+            ClassPlayerCache[client][class_jump_distance] = ClassDataCache[classindex][class_jump_distance];
+        }
+        default:
+        {
+            // Invalid cache specified.
+            return false;
+        }
+    }
+    
+    return true;
+}

src/zr/zombiereloaded.inc

@@ -48,7 +48,7 @@ enum ZTeam
 #define LOG_MODULE_OVERLAYS        4096          // overlays.inc
 #define LOG_MODULE_SAYTRIGGERS     8192          // sayhooks.inc
 #define LOG_MODULE_TELEPORT        16384         // teleport.inc
-#define LOG_MODULE_CLASSES         32768         // playerclasses.inc
+#define LOG_MODULE_CLASSES         32768         // playerclasses/*
 #define LOG_MODULE_WEAPONRESTICT   65536         // weaponrestrict.inc
 #define LOG_MODULE_COMMANDS        131072        // commands.inc
 #define LOG_MODULE_ANTICAMP        262144        // anticamp.inc