diff --git a/docs/zr_manual.txt b/docs/zr_manual.txt index 51c928a..3ac1f1c 100644 --- a/docs/zr_manual.txt +++ b/docs/zr_manual.txt @@ -651,8 +651,13 @@ The list below explains all available class attributes in detail: setting must be set to "motherzombies" for this flag to take effect. - Remember that these flags can be used in a combination (1 + 2), so - it's a mother zombie class for admins only. + These flags can be used in a combination (1 + 2), so it could be a + mother zombie class for admins only. + + group text Name of a valid SourceMod group. + --------------------------------------------------------------------------- + Rescrict class to members of this SourceMod group. Useful for making + VIP-only classes. Leave blank to allow everyone to use this class. name text Unique, not empty, max 64 charact. --------------------------------------------------------------------------- @@ -750,8 +755,8 @@ The list below explains all available class attributes in detail: kill_bonus number 0 - 16 --------------------------------------------------------------------------- - Zombie classes only. How many EXTRA points to give the killer of a - zombie. If this is 0, the default value of 1 point will be given. + Zombie classes only. How many extra points to give the killer of this + zombie. If this is 0, the default value of 1 point will be given. speed decimal 10.0 - 2000.0 --------------------------------------------------------------------------- @@ -798,29 +803,30 @@ Attribute flags: team 2 2 team_default 3 4 flags 4 8 - name 5 16 - description 6 32 - model_path 7 64 - alpha_initial 8 128 - alpha_damaged 9 256 - alpha_damage 10 512 - overlay_path 11 1024 - nvgs 12 2048 - fov 13 4096 - has_napalm 14 8192 - napalm_time 15 16384 - immunity_mode 16 32768 - immunity_amount 17 65536 - no_fall_damage 18 131072 - health 19 262144 - health_regen_interval 20 524288 - health_regen_amount 21 1048576 - infect_gain 22 2097152 - kill_bonus 23 4194304 - speed 24 8388608 - knockback 25 16777216 - jump_height 26 33554432 - jump_distance 27 67108864 + group 5 16 + name 6 32 + description 7 64 + model_path 8 128 + alpha_initial 9 256 + alpha_damaged 10 512 + alpha_damage 11 1024 + overlay_path 12 2048 + nvgs 13 4096 + fov 14 8192 + has_napalm 15 16384 + napalm_time 16 32768 + immunity_mode 17 65536 + immunity_amount 18 131072 + no_fall_damage 19 262144 + health 20 524288 + health_regen_interval 21 1048576 + health_regen_amount 22 2097152 + infect_gain 23 4194304 + kill_bonus 24 8388608 + speed 25 16777216 + knockback 26 33554432 + jump_height 27 67108864 + jump_distance 28 134217728 The error flags are stored in a bit field (explained in the log configuration in section 3.2). diff --git a/src/zr/playerclasses/attributes.inc b/src/zr/playerclasses/attributes.inc index 960c60b..274e263 100644 --- a/src/zr/playerclasses/attributes.inc +++ b/src/zr/playerclasses/attributes.inc @@ -52,15 +52,15 @@ stock bool:ClassIsEnabled(index, cachetype = ZR_CLASS_CACHE_MODIFIED) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_enabled]; + return ClassData[index][Class_Enabled]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_enabled]; + return ClassDataCache[index][Class_Enabled]; } case ZR_CLASS_CACHE_PLAYER: { - return ClassPlayerCache[index][class_enabled]; + return ClassPlayerCache[index][Class_Enabled]; } } return false; @@ -84,15 +84,15 @@ stock ClassGetTeamID(index, cachetype = ZR_CLASS_CACHE_PLAYER) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_team]; + return ClassData[index][Class_Team]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_team]; + return ClassDataCache[index][Class_Team]; } case ZR_CLASS_CACHE_PLAYER: { - return ClassPlayerCache[index][class_team]; + return ClassPlayerCache[index][Class_Team]; } } return -1; @@ -118,15 +118,15 @@ stock bool:ClassGetTeamDefault(index, cachetype = ZR_CLASS_CACHE_MODIFIED) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_team_default]; + return ClassData[index][Class_TeamDefault]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_team_default]; + return ClassDataCache[index][Class_TeamDefault]; } case ZR_CLASS_CACHE_PLAYER: { - return ClassPlayerCache[index][class_team_default]; + return ClassPlayerCache[index][Class_TeamDefault]; } } return false; @@ -151,15 +151,15 @@ stock ClassGetFlags(index, cachetype = ZR_CLASS_CACHE_MODIFIED) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_flags]; + return ClassData[index][Class_Flags]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_flags]; + return ClassDataCache[index][Class_Flags]; } case ZR_CLASS_CACHE_PLAYER: { - return ClassPlayerCache[index][class_flags]; + return ClassPlayerCache[index][Class_Flags]; } } return -1; @@ -185,20 +185,55 @@ stock bool:ClassHasFlags(index, flags, cachetype = ZR_CLASS_CACHE_MODIFIED) { case ZR_CLASS_CACHE_ORIGINAL: { - return bool:(ClassData[index][class_flags] & flags); + return bool:(ClassData[index][Class_Flags] & flags); } case ZR_CLASS_CACHE_MODIFIED: { - return bool:(ClassDataCache[index][class_flags] & flags); + return bool:(ClassDataCache[index][Class_Flags] & flags); } case ZR_CLASS_CACHE_PLAYER: { - return bool:(ClassPlayerCache[index][class_flags] & flags); + return bool:(ClassPlayerCache[index][Class_Flags] & flags); } } return false; } +/** + * Gets the class group required to be a member of to use the 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. + */ +stock ClassGetGroup(index, String:buffer[], maxlen, cachetype = ZR_CLASS_CACHE_PLAYER) +{ + switch (cachetype) + { + case ZR_CLASS_CACHE_ORIGINAL: + { + return strcopy(buffer, maxlen, ClassData[index][Class_Group]); + } + case ZR_CLASS_CACHE_MODIFIED: + { + return strcopy(buffer, maxlen, ClassDataCache[index][Class_Group]); + } + case ZR_CLASS_CACHE_PLAYER: + { + return strcopy(buffer, maxlen, ClassPlayerCache[index][Class_Group]); + } + } + + return -1; +} + /** * Gets the class name to be displayed in the class menu. * @@ -219,15 +254,15 @@ stock ClassGetName(index, String:buffer[], maxlen, cachetype = ZR_CLASS_CACHE_PL { case ZR_CLASS_CACHE_ORIGINAL: { - return strcopy(buffer, maxlen, ClassData[index][class_name]); + return strcopy(buffer, maxlen, ClassData[index][Class_Name]); } case ZR_CLASS_CACHE_MODIFIED: { - return strcopy(buffer, maxlen, ClassDataCache[index][class_name]); + return strcopy(buffer, maxlen, ClassDataCache[index][Class_Name]); } case ZR_CLASS_CACHE_PLAYER: { - return strcopy(buffer, maxlen, ClassPlayerCache[index][class_name]); + return strcopy(buffer, maxlen, ClassPlayerCache[index][Class_Name]); } } @@ -254,15 +289,15 @@ stock ClassGetDescription(index, String:buffer[], maxlen, cachetype = ZR_CLASS_C { case ZR_CLASS_CACHE_ORIGINAL: { - return strcopy(buffer, maxlen, ClassData[index][class_description]); + return strcopy(buffer, maxlen, ClassData[index][Class_Description]); } case ZR_CLASS_CACHE_MODIFIED: { - return strcopy(buffer, maxlen, ClassDataCache[index][class_description]); + return strcopy(buffer, maxlen, ClassDataCache[index][Class_Description]); } case ZR_CLASS_CACHE_PLAYER: { - return strcopy(buffer, maxlen, ClassPlayerCache[index][class_description]); + return strcopy(buffer, maxlen, ClassPlayerCache[index][Class_Description]); } } return -1; @@ -298,15 +333,15 @@ stock ClassGetModelPath(index, String:buffer[], maxlen, cachetype = ZR_CLASS_CAC { case ZR_CLASS_CACHE_ORIGINAL: { - return strcopy(buffer, maxlen, ClassData[index][class_model_path]); + return strcopy(buffer, maxlen, ClassData[index][Class_ModelPath]); } case ZR_CLASS_CACHE_MODIFIED: { - return strcopy(buffer, maxlen, ClassDataCache[index][class_model_path]); + return strcopy(buffer, maxlen, ClassDataCache[index][Class_ModelPath]); } case ZR_CLASS_CACHE_PLAYER: { - return strcopy(buffer, maxlen, ClassPlayerCache[index][class_model_path]); + return strcopy(buffer, maxlen, ClassPlayerCache[index][Class_ModelPath]); } } return -1; @@ -330,15 +365,15 @@ stock ClassGetAlphaInitial(index, cachetype = ZR_CLASS_CACHE_PLAYER) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_alpha_initial]; + return ClassData[index][Class_AlphaInitial]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_alpha_initial]; + return ClassDataCache[index][Class_AlphaInitial]; } case ZR_CLASS_CACHE_PLAYER: { - return ClassPlayerCache[index][class_alpha_initial]; + return ClassPlayerCache[index][Class_AlphaInitial]; } } return -1; @@ -363,15 +398,15 @@ stock ClassGetAlphaDamaged(index, cachetype = ZR_CLASS_CACHE_PLAYER) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_alpha_damaged]; + return ClassData[index][Class_AlphaDamaged]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_alpha_damaged]; + return ClassDataCache[index][Class_AlphaDamaged]; } case ZR_CLASS_CACHE_PLAYER: { - return ClassPlayerCache[index][class_alpha_damaged]; + return ClassPlayerCache[index][Class_AlphaDamaged]; } } return -1; @@ -396,15 +431,15 @@ stock ClassGetAlphaDamage(index, cachetype = ZR_CLASS_CACHE_PLAYER) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_alpha_damage]; + return ClassData[index][Class_AlphaDamage]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_alpha_damage]; + return ClassDataCache[index][Class_AlphaDamage]; } case ZR_CLASS_CACHE_PLAYER: { - return ClassPlayerCache[index][class_alpha_damage]; + return ClassPlayerCache[index][Class_AlphaDamage]; } } return -1; @@ -440,15 +475,15 @@ stock ClassGetOverlayPath(index, String:buffer[], maxlen, cachetype = ZR_CLASS_C { case ZR_CLASS_CACHE_ORIGINAL: { - return strcopy(buffer, maxlen, ClassData[index][class_overlay_path]); + return strcopy(buffer, maxlen, ClassData[index][Class_OverlayPath]); } case ZR_CLASS_CACHE_MODIFIED: { - return strcopy(buffer, maxlen, ClassDataCache[index][class_overlay_path]); + return strcopy(buffer, maxlen, ClassDataCache[index][Class_OverlayPath]); } case ZR_CLASS_CACHE_PLAYER: { - return strcopy(buffer, maxlen, ClassPlayerCache[index][class_overlay_path]); + return strcopy(buffer, maxlen, ClassPlayerCache[index][Class_OverlayPath]); } } return -1; @@ -472,15 +507,15 @@ stock bool:ClassGetNvgs(index, cachetype = ZR_CLASS_CACHE_PLAYER) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_nvgs]; + return ClassData[index][Class_Nvgs]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_nvgs]; + return ClassDataCache[index][Class_Nvgs]; } case ZR_CLASS_CACHE_PLAYER: { - return ClassPlayerCache[index][class_nvgs]; + return ClassPlayerCache[index][Class_Nvgs]; } } return false; @@ -504,15 +539,15 @@ stock ClassGetFOV(index, cachetype = ZR_CLASS_CACHE_PLAYER) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_fov]; + return ClassData[index][Class_Fov]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_fov]; + return ClassDataCache[index][Class_Fov]; } case ZR_CLASS_CACHE_PLAYER: { - return ClassPlayerCache[index][class_fov]; + return ClassPlayerCache[index][Class_Fov]; } } return -1; @@ -546,15 +581,15 @@ stock bool:ClassGetHasNapalm(index, cachetype = ZR_CLASS_CACHE_PLAYER) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_has_napalm]; + return ClassData[index][Class_HasNapalm]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_has_napalm]; + return ClassDataCache[index][Class_HasNapalm]; } case ZR_CLASS_CACHE_PLAYER: { - return ClassPlayerCache[index][class_has_napalm]; + return ClassPlayerCache[index][Class_HasNapalm]; } } return false; @@ -580,15 +615,15 @@ stock Float:ClassGetNapalmTime(index, cachetype = ZR_CLASS_CACHE_PLAYER) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_napalm_time]; + return ClassData[index][Class_NapalmTime]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_napalm_time]; + return ClassDataCache[index][Class_NapalmTime]; } case ZR_CLASS_CACHE_PLAYER: { - return ClassPlayerCache[index][class_napalm_time] * ClassGetAttributeMultiplier(index, ClassM_NapalmTime); + return ClassPlayerCache[index][Class_NapalmTime] * ClassGetAttributeMultiplier(index, ClassM_NapalmTime); } } return -1.0; @@ -622,15 +657,15 @@ stock ClassGetImmunityMode(index, cachetype = ZR_CLASS_CACHE_PLAYER) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_immunity_mode]; + return ClassData[index][Class_ImmunityMode]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_immunity_mode]; + return ClassDataCache[index][Class_ImmunityMode]; } case ZR_CLASS_CACHE_PLAYER: { - return ClassPlayerCache[index][class_immunity_mode]; + return ClassPlayerCache[index][Class_ImmunityMode]; } } return -1; @@ -654,15 +689,15 @@ stock Float:ClassGetImmunityAmount(index, cachetype = ZR_CLASS_CACHE_PLAYER) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_immunity_amount]; + return ClassData[index][Class_ImmunityAmount]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_immunity_amount]; + return ClassDataCache[index][Class_ImmunityAmount]; } case ZR_CLASS_CACHE_PLAYER: { - return ClassPlayerCache[index][class_immunity_amount]; + return ClassPlayerCache[index][Class_ImmunityAmount]; } } return -1.0; @@ -687,15 +722,15 @@ stock bool:ClassGetNoFallDamage(index, cachetype = ZR_CLASS_CACHE_PLAYER) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_no_fall_damage]; + return ClassData[index][Class_NoFallDamage]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_no_fall_damage]; + return ClassDataCache[index][Class_NoFallDamage]; } case ZR_CLASS_CACHE_PLAYER: { - return ClassPlayerCache[index][class_no_fall_damage]; + return ClassPlayerCache[index][Class_NoFallDamage]; } } return false; @@ -721,15 +756,15 @@ stock ClassGetHealth(index, cachetype = ZR_CLASS_CACHE_PLAYER) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_health]; + return ClassData[index][Class_Health]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_health]; + return ClassDataCache[index][Class_Health]; } case ZR_CLASS_CACHE_PLAYER: { - return RoundToCeil(ClassPlayerCache[index][class_health] * ClassGetAttributeMultiplier(index, ClassM_Health)); + return RoundToCeil(ClassPlayerCache[index][Class_Health] * ClassGetAttributeMultiplier(index, ClassM_Health)); } } return -1; @@ -756,15 +791,15 @@ stock Float:ClassGetHealthRegenInterval(index, cachetype = ZR_CLASS_CACHE_PLAYER { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_health_regen_interval]; + return ClassData[index][Class_HealthRegenInterval]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_health_regen_interval]; + return ClassDataCache[index][Class_HealthRegenInterval]; } case ZR_CLASS_CACHE_PLAYER: { - return ClassPlayerCache[index][class_health_regen_interval] * ClassGetAttributeMultiplier(index, ClassM_HealthRegenInterval); + return ClassPlayerCache[index][Class_HealthRegenInterval] * ClassGetAttributeMultiplier(index, ClassM_HealthRegenInterval); } } return -1.0; @@ -791,15 +826,15 @@ stock ClassGetHealthRegenAmount(index, cachetype = ZR_CLASS_CACHE_PLAYER) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_health_regen_amount]; + return ClassData[index][Class_HealthRegenAmount]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_health_regen_amount]; + return ClassDataCache[index][Class_HealthRegenAmount]; } case ZR_CLASS_CACHE_PLAYER: { - return RoundToCeil(ClassPlayerCache[index][class_health_regen_amount] * ClassGetAttributeMultiplier(index, ClassM_HealthRegenAmount)); + return RoundToCeil(ClassPlayerCache[index][Class_HealthRegenAmount] * ClassGetAttributeMultiplier(index, ClassM_HealthRegenAmount)); } } return -1; @@ -826,15 +861,15 @@ stock ClassGetHealthInfectGain(index, cachetype = ZR_CLASS_CACHE_PLAYER) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_health_infect_gain]; + return ClassData[index][Class_HealthInfectGain]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_health_infect_gain]; + return ClassDataCache[index][Class_HealthInfectGain]; } case ZR_CLASS_CACHE_PLAYER: { - return RoundToCeil(ClassPlayerCache[index][class_health_infect_gain] * ClassGetAttributeMultiplier(index, ClassM_HealthInfectGain)); + return RoundToCeil(ClassPlayerCache[index][Class_HealthInfectGain] * ClassGetAttributeMultiplier(index, ClassM_HealthInfectGain)); } } return -1; @@ -858,15 +893,15 @@ stock ClassGetKillBonus(index, cachetype = ZR_CLASS_CACHE_PLAYER) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_kill_bonus]; + return ClassData[index][Class_KillBonus]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_kill_bonus]; + return ClassDataCache[index][Class_KillBonus]; } case ZR_CLASS_CACHE_PLAYER: { - return ClassPlayerCache[index][class_kill_bonus]; + return ClassPlayerCache[index][Class_KillBonus]; } } return -1; @@ -892,15 +927,15 @@ stock Float:ClassGetSpeed(index, cachetype = ZR_CLASS_CACHE_PLAYER) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_speed]; + return ClassData[index][Class_Speed]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_speed]; + return ClassDataCache[index][Class_Speed]; } case ZR_CLASS_CACHE_PLAYER: { - return ClassPlayerCache[index][class_speed] * ClassGetAttributeMultiplier(index, ClassM_Speed); + return ClassPlayerCache[index][Class_Speed] * ClassGetAttributeMultiplier(index, ClassM_Speed); } } return -1.0; @@ -926,15 +961,15 @@ stock Float:ClassGetKnockback(index, cachetype = ZR_CLASS_CACHE_PLAYER) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_knockback]; + return ClassData[index][Class_KnockBack]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_knockback]; + return ClassDataCache[index][Class_KnockBack]; } case ZR_CLASS_CACHE_PLAYER: { - return ClassPlayerCache[index][class_knockback] * ClassGetAttributeMultiplier(index, ClassM_Knockback); + return ClassPlayerCache[index][Class_KnockBack] * ClassGetAttributeMultiplier(index, ClassM_Knockback); } } return 0.0; @@ -960,15 +995,15 @@ stock Float:ClassGetJumpHeight(index, cachetype = ZR_CLASS_CACHE_PLAYER) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_jump_height]; + return ClassData[index][Class_JumpHeight]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_jump_height]; + return ClassDataCache[index][Class_JumpHeight]; } case ZR_CLASS_CACHE_PLAYER: { - return ClassPlayerCache[index][class_jump_height] * ClassGetAttributeMultiplier(index, ClassM_JumpHeight); + return ClassPlayerCache[index][Class_JumpHeight] * ClassGetAttributeMultiplier(index, ClassM_JumpHeight); } } return -1.0; @@ -994,15 +1029,15 @@ stock Float:ClassGetJumpDistance(index, cachetype = ZR_CLASS_CACHE_PLAYER) { case ZR_CLASS_CACHE_ORIGINAL: { - return ClassData[index][class_jump_distance]; + return ClassData[index][Class_JumpDistance]; } case ZR_CLASS_CACHE_MODIFIED: { - return ClassDataCache[index][class_jump_distance]; + return ClassDataCache[index][Class_JumpDistance]; } case ZR_CLASS_CACHE_PLAYER: { - return ClassPlayerCache[index][class_jump_distance] * ClassGetAttributeMultiplier(index, ClassM_JumpDistance); + return ClassPlayerCache[index][Class_JumpDistance] * ClassGetAttributeMultiplier(index, ClassM_JumpDistance); } } return -1.0; @@ -1034,6 +1069,10 @@ stock ClassAttributeNameToFlag(const String:attributename[]) { return ZR_CLASS_FLAGS; } + else if (StrEqual(attributename, "group", false)) + { + return ZR_CLASS_GROUP; + } else if (StrEqual(attributename, "name", false)) { return ZR_CLASS_NAME; @@ -1230,7 +1269,8 @@ stock ClassDataTypes:ClassGetAttributeType(attributeflag) } // String. - case ZR_CLASS_NAME, + case ZR_CLASS_GROUP, + ZR_CLASS_NAME, ZR_CLASS_DESCRIPTION, ZR_CLASS_MODEL_PATH, ZR_CLASS_OVERLAY_PATH: diff --git a/src/zr/playerclasses/classcommands.inc b/src/zr/playerclasses/classcommands.inc index 22286fe..0405bce 100644 --- a/src/zr/playerclasses/classcommands.inc +++ b/src/zr/playerclasses/classcommands.inc @@ -619,22 +619,22 @@ stock bool:ClassModifyBoolean(classindex, attributeflag, bool:value) { case ZR_CLASS_ENABLED: { - ClassDataCache[classindex][class_enabled] = bool:value; + ClassDataCache[classindex][Class_Enabled] = bool:value; return true; } case ZR_CLASS_NVGS: { - ClassDataCache[classindex][class_nvgs] = bool:value; + ClassDataCache[classindex][Class_Nvgs] = bool:value; return true; } case ZR_CLASS_NO_FALL_DAMAGE: { - ClassDataCache[classindex][class_no_fall_damage] = bool:value; + ClassDataCache[classindex][Class_NoFallDamage] = bool:value; return true; } case ZR_CLASS_HAS_NAPALM: { - ClassDataCache[classindex][class_has_napalm] = bool:value; + ClassDataCache[classindex][Class_HasNapalm] = bool:value; return true; } } @@ -670,80 +670,80 @@ stock ClassModifyInteger(classindex, attributeflag, value, Float:multiplier = 0. { case ZR_CLASS_FLAGS: { - ClassDataCache[classindex][class_flags] = value; + ClassDataCache[classindex][Class_Flags] = value; return true; } case ZR_CLASS_ALPHA_INITIAL: { if (ismultiplier) { - value = RoundToNearest(float(ClassData[classindex][class_alpha_initial]) * multiplier); + value = RoundToNearest(float(ClassData[classindex][Class_AlphaInitial]) * multiplier); } - ClassDataCache[classindex][class_alpha_initial] = value; + ClassDataCache[classindex][Class_AlphaInitial] = value; return true; } case ZR_CLASS_ALPHA_DAMAGED: { if (ismultiplier) { - value = RoundToNearest(float(ClassData[classindex][class_alpha_damaged]) * multiplier); + value = RoundToNearest(float(ClassData[classindex][Class_AlphaDamaged]) * multiplier); } - ClassDataCache[classindex][class_alpha_damaged] = value; + ClassDataCache[classindex][Class_AlphaDamaged] = value; return true; } case ZR_CLASS_ALPHA_DAMAGE: { if (ismultiplier) { - value = RoundToNearest(float(ClassData[classindex][class_alpha_damage]) * multiplier); + value = RoundToNearest(float(ClassData[classindex][Class_AlphaDamage]) * multiplier); } - ClassDataCache[classindex][class_alpha_damage] = value; + ClassDataCache[classindex][Class_AlphaDamage] = value; return true; } case ZR_CLASS_FOV: { - ClassDataCache[classindex][class_fov] = value; + ClassDataCache[classindex][Class_Fov] = value; return true; } case ZR_CLASS_IMMUNITY_MODE: { - ClassDataCache[classindex][class_fov] = value; + ClassDataCache[classindex][Class_ImmunityMode] = value; return true; } case ZR_CLASS_HEALTH: { if (ismultiplier) { - value = RoundToNearest(float(ClassData[classindex][class_health]) * multiplier); + value = RoundToNearest(float(ClassData[classindex][Class_Health]) * multiplier); } - ClassDataCache[classindex][class_health] = value; + ClassDataCache[classindex][Class_Health] = value; return true; } case ZR_CLASS_HEALTH_REGEN_AMOUNT: { if (ismultiplier) { - value = RoundToNearest(float(ClassData[classindex][class_health_regen_amount]) * multiplier); + value = RoundToNearest(float(ClassData[classindex][Class_HealthRegenAmount]) * multiplier); } - ClassDataCache[classindex][class_health_regen_amount] = value; + ClassDataCache[classindex][Class_HealthRegenAmount] = value; return true; } case ZR_CLASS_HEALTH_INFECT_GAIN: { if (ismultiplier) { - value = RoundToNearest(float(ClassData[classindex][class_health_infect_gain]) * multiplier); + value = RoundToNearest(float(ClassData[classindex][Class_HealthInfectGain]) * multiplier); } - ClassDataCache[classindex][class_health_infect_gain] = value; + ClassDataCache[classindex][Class_HealthInfectGain] = value; return true; } case ZR_CLASS_KILL_BONUS: { if (ismultiplier) { - value = RoundToNearest(float(ClassData[classindex][class_kill_bonus]) * multiplier); + value = RoundToNearest(float(ClassData[classindex][Class_KillBonus]) * multiplier); } - ClassDataCache[classindex][class_kill_bonus] = value; + ClassDataCache[classindex][Class_KillBonus] = value; return true; } } @@ -777,63 +777,63 @@ stock ClassModifyFloat(classindex, attributeflag, Float:value, bool:ismultiplier { if (ismultiplier) { - value = ClassData[classindex][class_napalm_time] * value; + value = ClassData[classindex][Class_NapalmTime] * value; } - ClassDataCache[classindex][class_napalm_time] = value; + ClassDataCache[classindex][Class_NapalmTime] = value; return true; } case ZR_CLASS_IMMUNITY_AMOUNT: { if (ismultiplier) { - value = ClassData[classindex][class_immunity_amount] * value; + value = ClassData[classindex][Class_ImmunityAmount] * value; } - ClassDataCache[classindex][class_immunity_amount] = value; + ClassDataCache[classindex][Class_ImmunityAmount] = value; return true; } case ZR_CLASS_HEALTH_REGEN_INTERVAL: { if (ismultiplier) { - value = ClassData[classindex][class_health_regen_interval] * value; + value = ClassData[classindex][Class_HealthRegenInterval] * value; } - ClassDataCache[classindex][class_health_regen_interval] = value; + ClassDataCache[classindex][Class_HealthRegenInterval] = value; return true; } case ZR_CLASS_SPEED: { if (ismultiplier) { - value = ClassData[classindex][class_speed] * value; + value = ClassData[classindex][Class_Speed] * value; } - ClassDataCache[classindex][class_speed] = value; + ClassDataCache[classindex][Class_Speed] = value; return true; } case ZR_CLASS_KNOCKBACK: { if (ismultiplier) { - value = ClassData[classindex][class_knockback] * value; + value = ClassData[classindex][Class_KnockBack] * value; } - ClassDataCache[classindex][class_knockback] = value; + ClassDataCache[classindex][Class_KnockBack] = value; return true; } case ZR_CLASS_JUMP_HEIGHT: { if (ismultiplier) { - value = ClassData[classindex][class_jump_height] * value; + value = ClassData[classindex][Class_JumpHeight] * value; } - ClassDataCache[classindex][class_jump_height] = value; + ClassDataCache[classindex][Class_JumpHeight] = value; return true; } case ZR_CLASS_JUMP_DISTANCE: { if (ismultiplier) { - value = ClassData[classindex][class_jump_distance] * value; + value = ClassData[classindex][Class_JumpDistance] * value; } - ClassDataCache[classindex][class_jump_distance] = value; + ClassDataCache[classindex][Class_JumpDistance] = value; return true; } } @@ -860,24 +860,29 @@ stock ClassModifyString(classindex, attributeflag, const String:value[]) switch (attributeflag) { + case ZR_CLASS_GROUP: + { + strcopy(ClassDataCache[classindex][Class_Group], 64, value); + return true; + } case ZR_CLASS_NAME: { - strcopy(ClassDataCache[classindex][class_name], 64, value); + strcopy(ClassDataCache[classindex][Class_Name], 64, value); return true; } case ZR_CLASS_DESCRIPTION: { - strcopy(ClassDataCache[classindex][class_description], 256, value); + strcopy(ClassDataCache[classindex][Class_Description], 256, value); return true; } case ZR_CLASS_MODEL_PATH: { - strcopy(ClassDataCache[classindex][class_model_path], PLATFORM_MAX_PATH, value); + strcopy(ClassDataCache[classindex][Class_ModelPath], PLATFORM_MAX_PATH, value); return true; } case ZR_CLASS_OVERLAY_PATH: { - strcopy(ClassDataCache[classindex][class_overlay_path], PLATFORM_MAX_PATH, value); + strcopy(ClassDataCache[classindex][Class_OverlayPath], PLATFORM_MAX_PATH, value); return true; } } diff --git a/src/zr/playerclasses/filtertools.inc b/src/zr/playerclasses/filtertools.inc index 4c53ae6..ecfbfe9 100644 --- a/src/zr/playerclasses/filtertools.inc +++ b/src/zr/playerclasses/filtertools.inc @@ -107,26 +107,29 @@ stock ClassValidateAttributes(classindex) new flags; // Team. - if (ClassData[classindex][class_team] < ZR_CLASS_TEAM_MIN || ClassData[classindex][class_team] > ZR_CLASS_TEAM_MAX) + if (ClassData[classindex][Class_Team] < ZR_CLASS_TEAM_MIN || ClassData[classindex][Class_Team] > ZR_CLASS_TEAM_MAX) { flags += ZR_CLASS_TEAM; } // Class flags. - if (ClassData[classindex][class_flags] < ZR_CLASS_FLAGS_MIN || ClassData[classindex][class_flags] > ZR_CLASS_FLAGS_MAX) + if (ClassData[classindex][Class_Flags] < ZR_CLASS_FLAGS_MIN || ClassData[classindex][Class_Flags] > ZR_CLASS_FLAGS_MAX) { flags += ZR_CLASS_FLAGS; } + // Group. + + // Name. - if (strlen(ClassData[classindex][class_name]) < ZR_CLASS_NAME_MIN) + if (strlen(ClassData[classindex][Class_Name]) < ZR_CLASS_NAME_MIN) { flags += ZR_CLASS_NAME; } else { decl String:name[64]; - strcopy(name, sizeof(name), ClassData[classindex][class_name]); + strcopy(name, sizeof(name), ClassData[classindex][Class_Name]); // Check for reserved name keyworks. These aren't allowed as names. if (StrEqual(name, "all", false) || @@ -139,14 +142,14 @@ stock ClassValidateAttributes(classindex) } // Description. - if (strlen(ClassData[classindex][class_description]) < ZR_CLASS_DESCRIPTION_MIN) + if (strlen(ClassData[classindex][Class_Description]) < ZR_CLASS_DESCRIPTION_MIN) { flags += ZR_CLASS_DESCRIPTION; } // Model path. decl String:model_path[PLATFORM_MAX_PATH]; - if (strcopy(model_path, sizeof(model_path), ClassData[classindex][class_model_path]) == 0) + if (strcopy(model_path, sizeof(model_path), ClassData[classindex][Class_ModelPath]) == 0) { flags += ZR_CLASS_MODEL_PATH; } @@ -164,21 +167,21 @@ stock ClassValidateAttributes(classindex) } // Alpha, initial. - new alpha_initial = ClassData[classindex][class_alpha_initial]; + new alpha_initial = ClassData[classindex][Class_AlphaInitial]; if (!(alpha_initial >= ZR_CLASS_ALPHA_INITIAL_MIN && alpha_initial <= ZR_CLASS_ALPHA_INITIAL_MAX)) { flags += ZR_CLASS_ALPHA_INITIAL; } // Alpha, damaged. - new alpha_damaged = ClassData[classindex][class_alpha_damaged]; + new alpha_damaged = ClassData[classindex][Class_AlphaDamaged]; if (!(alpha_damaged >= ZR_CLASS_ALPHA_DAMAGED_MIN && alpha_damaged <= ZR_CLASS_ALPHA_DAMAGED_MAX)) { flags += ZR_CLASS_ALPHA_DAMAGED; } // Alpha, damage. - new alpha_damage = ClassData[classindex][class_alpha_damage]; + new alpha_damage = ClassData[classindex][Class_AlphaDamage]; if (!(alpha_damage >= ZR_CLASS_ALPHA_DAMAGE_MIN && alpha_damage <= ZR_CLASS_ALPHA_DAMAGE_MAX)) { flags += ZR_CLASS_ALPHA_DAMAGE; @@ -187,7 +190,7 @@ stock ClassValidateAttributes(classindex) // Overlay path. decl String:overlay_path[PLATFORM_MAX_PATH]; decl String:overlay[PLATFORM_MAX_PATH]; - if (strcopy(overlay_path, sizeof(overlay_path), ClassData[classindex][class_overlay_path]) > 0) + if (strcopy(overlay_path, sizeof(overlay_path), ClassData[classindex][Class_OverlayPath]) > 0) { // Check if the file exists. Format(overlay, sizeof(overlay), "materials/%s.vmt", overlay_path); @@ -198,77 +201,80 @@ stock ClassValidateAttributes(classindex) } // Field of view. - new fov = ClassData[classindex][class_fov]; + new fov = ClassData[classindex][Class_Fov]; if (!(fov >= ZR_CLASS_FOV_MIN && fov <= ZR_CLASS_FOV_MAX)) { flags += ZR_CLASS_FOV; } // Napalm time. - new Float:napalm_time = ClassData[classindex][class_napalm_time]; + new Float:napalm_time = ClassData[classindex][Class_NapalmTime]; if (!(napalm_time >= ZR_CLASS_NAPALM_TIME_MIN && napalm_time <= ZR_CLASS_NAPALM_TIME_MAX)) { flags += ZR_CLASS_NAPALM_TIME; } + // Immunity mode (not implemented). + + // Health. - new health = ClassData[classindex][class_health]; + new health = ClassData[classindex][Class_Health]; if (!(health >= ZR_CLASS_HEALTH_MIN && health <= ZR_CLASS_HEALTH_MAX)) { flags += ZR_CLASS_HEALTH; } // Health regen interval. - new Float:regen_interval = ClassData[classindex][class_health_regen_interval]; + new Float:regen_interval = ClassData[classindex][Class_HealthRegenInterval]; if (!(regen_interval >= ZR_CLASS_REGEN_INTERVAL_MIN && regen_interval <= ZR_CLASS_REGEN_INTERVAL_MAX)) { flags += ZR_CLASS_HEALTH_REGEN_INTERVAL; } // Health regen amount. - new regen_amount = ClassData[classindex][class_health_regen_amount]; + new regen_amount = ClassData[classindex][Class_HealthRegenAmount]; if (!(regen_amount >= ZR_CLASS_REGEN_AMOUNT_MIN && regen_amount <= ZR_CLASS_REGEN_AMOUNT_MAX)) { flags += ZR_CLASS_HEALTH_REGEN_AMOUNT; } // Health infect gain. - new infect_gain = ClassData[classindex][class_health_infect_gain]; + new infect_gain = ClassData[classindex][Class_HealthInfectGain]; if (!(infect_gain >= ZR_CLASS_HEALTH_INFECT_GAIN_MIN && infect_gain <= ZR_CLASS_HEALTH_INFECT_GAIN_MAX)) { flags += ZR_CLASS_HEALTH_INFECT_GAIN; } // Kill bonus. - new kill_bonus = ClassData[classindex][class_kill_bonus]; + new kill_bonus = ClassData[classindex][Class_KillBonus]; if (!(kill_bonus >= ZR_CLASS_KILL_BONUS_MIN && kill_bonus <= ZR_CLASS_KILL_BONUS_MAX)) { flags += ZR_CLASS_KILL_BONUS; } // Speed. - new Float:speed = ClassData[classindex][class_speed]; + new Float:speed = ClassData[classindex][Class_Speed]; if (!(speed >= ZR_CLASS_SPEED_MIN && speed <= ZR_CLASS_SPEED_MAX)) { flags += ZR_CLASS_SPEED; } // Knockback. - new Float:knockback = ClassData[classindex][class_knockback]; + new Float:knockback = ClassData[classindex][Class_KnockBack]; if (!(knockback >= ZR_CLASS_KNOCKBACK_MIN && knockback <= ZR_CLASS_KNOCKBACK_MAX)) { flags += ZR_CLASS_KNOCKBACK; } // Jump height. - new Float:jump_height = ClassData[classindex][class_jump_height]; + new Float:jump_height = ClassData[classindex][Class_JumpHeight]; if (!(jump_height >= ZR_CLASS_JUMP_HEIGHT_MIN && jump_height <= ZR_CLASS_JUMP_HEIGHT_MAX)) { flags += ZR_CLASS_JUMP_HEIGHT; } // Jump distance. - new Float:jump_distance = ClassData[classindex][class_jump_distance]; + new Float:jump_distance = ClassData[classindex][Class_JumpDistance]; if (!(jump_distance >= ZR_CLASS_JUMP_DISTANCE_MIN && jump_distance <= ZR_CLASS_JUMP_DISTANCE_MAX)) { flags += ZR_CLASS_JUMP_DISTANCE; @@ -315,21 +321,21 @@ stock bool:ClassTeamCompare(index, teamid, cachetype = ZR_CLASS_CACHE_MODIFIED) { case ZR_CLASS_CACHE_ORIGINAL: { - if (ClassData[index][class_team] == teamid) + if (ClassData[index][Class_Team] == teamid) { return true; } } case ZR_CLASS_CACHE_MODIFIED: { - if (ClassDataCache[index][class_team] == teamid) + if (ClassDataCache[index][Class_Team] == teamid) { return true; } } case ZR_CLASS_CACHE_PLAYER: { - if (ClassPlayerCache[index][class_team] == teamid) + if (ClassPlayerCache[index][Class_Team] == teamid) { return true; } diff --git a/src/zr/playerclasses/playerclasses.inc b/src/zr/playerclasses/playerclasses.inc index 05ddf75..4137d3e 100644 --- a/src/zr/playerclasses/playerclasses.inc +++ b/src/zr/playerclasses/playerclasses.inc @@ -31,7 +31,7 @@ - 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. + on admin mode classes. TODO: Make class attributes for for changing model render mode and colors. @@ -104,6 +104,7 @@ #define ZR_CLASS_DEFAULT_TEAM ZR_CLASS_TEAM_ZOMBIES #define ZR_CLASS_DEFAULT_TEAM_DEFAULT true #define ZR_CLASS_DEFAULT_FLAGS 0 +#define ZR_CLASS_DEFAULT_GROUP "" #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" @@ -181,77 +182,94 @@ #define ZR_CLASS_TEAM (1<<1) #define ZR_CLASS_TEAM_DEFAULT (1<<2) #define ZR_CLASS_FLAGS (1<<3) -#define ZR_CLASS_NAME (1<<4) -#define ZR_CLASS_DESCRIPTION (1<<5) -#define ZR_CLASS_MODEL_PATH (1<<6) -#define ZR_CLASS_ALPHA_INITIAL (1<<7) -#define ZR_CLASS_ALPHA_DAMAGED (1<<8) -#define ZR_CLASS_ALPHA_DAMAGE (1<<9) -#define ZR_CLASS_OVERLAY_PATH (1<<10) -#define ZR_CLASS_NVGS (1<<11) -#define ZR_CLASS_FOV (1<<12) -#define ZR_CLASS_HAS_NAPALM (1<<13) -#define ZR_CLASS_NAPALM_TIME (1<<14) -#define ZR_CLASS_IMMUNITY_MODE (1<<15) -#define ZR_CLASS_IMMUNITY_AMOUNT (1<<16) -#define ZR_CLASS_NO_FALL_DAMAGE (1<<17) -#define ZR_CLASS_HEALTH (1<<18) -#define ZR_CLASS_HEALTH_REGEN_INTERVAL (1<<19) -#define ZR_CLASS_HEALTH_REGEN_AMOUNT (1<<20) -#define ZR_CLASS_HEALTH_INFECT_GAIN (1<<21) -#define ZR_CLASS_KILL_BONUS (1<<22) -#define ZR_CLASS_SPEED (1<<23) -#define ZR_CLASS_KNOCKBACK (1<<24) -#define ZR_CLASS_JUMP_HEIGHT (1<<25) -#define ZR_CLASS_JUMP_DISTANCE (1<<26) +#define ZR_CLASS_GROUP (1<<4) +#define ZR_CLASS_NAME (1<<5) +#define ZR_CLASS_DESCRIPTION (1<<6) +#define ZR_CLASS_MODEL_PATH (1<<7) +#define ZR_CLASS_ALPHA_INITIAL (1<<8) +#define ZR_CLASS_ALPHA_DAMAGED (1<<9) +#define ZR_CLASS_ALPHA_DAMAGE (1<<10) +#define ZR_CLASS_OVERLAY_PATH (1<<11) +#define ZR_CLASS_NVGS (1<<12) +#define ZR_CLASS_FOV (1<<13) +#define ZR_CLASS_HAS_NAPALM (1<<14) +#define ZR_CLASS_NAPALM_TIME (1<<15) +#define ZR_CLASS_IMMUNITY_MODE (1<<16) +#define ZR_CLASS_IMMUNITY_AMOUNT (1<<17) +#define ZR_CLASS_NO_FALL_DAMAGE (1<<18) +#define ZR_CLASS_HEALTH (1<<19) +#define ZR_CLASS_HEALTH_REGEN_INTERVAL (1<<20) +#define ZR_CLASS_HEALTH_REGEN_AMOUNT (1<<21) +#define ZR_CLASS_HEALTH_INFECT_GAIN (1<<22) +#define ZR_CLASS_KILL_BONUS (1<<23) +#define ZR_CLASS_SPEED (1<<24) +#define ZR_CLASS_KNOCKBACK (1<<25) +#define ZR_CLASS_JUMP_HEIGHT (1<<26) +#define ZR_CLASS_JUMP_DISTANCE (1<<27) /** * @endsection */ /** * Generic player attributes. + * + * Stuff that must be updated when new attributes are added: + * ZR_CLASS_DEFAULT_... define + * ZR_CLASS_..._MAX/MIN defines + * ZR_CLASS_... define (place in same order as listed in ClassAttributes, bump bit numbers + update numbers in docs) + * ClassLoad + * ClassReloadDataCache + * ClassReloadPlayerCache + * ClassDumpData + * attributes.inc - Add new Get-function + * ClassAttributeNameToFlag + * ClassGetAttributeType + * ClassValidateAttributes + * ClassModify* in classcommands.inc + * Update docs with detailed attribute description */ enum ClassAttributes { /* General */ - bool:class_enabled, - class_team, - bool:class_team_default, - class_flags, + bool:Class_Enabled, + Class_Team, + bool:Class_TeamDefault, + Class_Flags, + String:Class_Group[64], - String:class_name[64], - String:class_description[256], + String:Class_Name[64], + String:Class_Description[256], /* Model */ - String:class_model_path[PLATFORM_MAX_PATH], - class_alpha_initial, - class_alpha_damaged, - class_alpha_damage, + String:Class_ModelPath[PLATFORM_MAX_PATH], + Class_AlphaInitial, + Class_AlphaDamaged, + Class_AlphaDamage, /* Hud */ - String:class_overlay_path[PLATFORM_MAX_PATH], - bool:class_nvgs, - class_fov, + String:Class_OverlayPath[PLATFORM_MAX_PATH], + bool:Class_Nvgs, + Class_Fov, /* Effects */ - bool:class_has_napalm, - Float:class_napalm_time, + bool:Class_HasNapalm, + Float:Class_NapalmTime, /* Player behaviour */ - class_immunity_mode, - Float:class_immunity_amount, - bool:class_no_fall_damage, + Class_ImmunityMode, + Float:Class_ImmunityAmount, + bool:Class_NoFallDamage, - class_health, - Float:class_health_regen_interval, - class_health_regen_amount, - class_health_infect_gain, - class_kill_bonus, + Class_Health, + Float:Class_HealthRegenInterval, + Class_HealthRegenAmount, + Class_HealthInfectGain, + Class_KillBonus, - Float:class_speed, - Float:class_knockback, - Float:class_jump_height, - Float:class_jump_distance + Float:Class_Speed, + Float:Class_KnockBack, + Float:Class_JumpHeight, + Float:Class_JumpDistance } /** @@ -435,6 +453,7 @@ ClassLoad(bool:keepMultipliers = false) } decl String:name[64]; + decl String:group[64]; decl String:description[256]; decl String:model_path[PLATFORM_MAX_PATH]; decl String:overlay_path[PLATFORM_MAX_PATH]; @@ -455,55 +474,58 @@ ClassLoad(bool:keepMultipliers = false) } /* General */ - ClassData[ClassCount][class_enabled] = bool:KvGetNum(kvClassData, "enabled", ZR_CLASS_DEFAULT_ENABLED); - ClassData[ClassCount][class_team] = KvGetNum(kvClassData, "team", ZR_CLASS_DEFAULT_TEAM); - ClassData[ClassCount][class_team_default] = bool:KvGetNum(kvClassData, "team_default", ZR_CLASS_DEFAULT_TEAM_DEFAULT); - ClassData[ClassCount][class_flags] = KvGetNum(kvClassData, "flags", ZR_CLASS_DEFAULT_FLAGS); + ClassData[ClassCount][Class_Enabled] = bool:KvGetNum(kvClassData, "enabled", ZR_CLASS_DEFAULT_ENABLED); + ClassData[ClassCount][Class_Team] = KvGetNum(kvClassData, "team", ZR_CLASS_DEFAULT_TEAM); + ClassData[ClassCount][Class_TeamDefault] = bool:KvGetNum(kvClassData, "team_default", ZR_CLASS_DEFAULT_TEAM_DEFAULT); + ClassData[ClassCount][Class_Flags] = KvGetNum(kvClassData, "flags", ZR_CLASS_DEFAULT_FLAGS); + + KvGetString(kvClassData, "group", group, sizeof(group), ZR_CLASS_DEFAULT_GROUP); + strcopy(ClassData[ClassCount][Class_Group], 64, group); KvGetString(kvClassData, "name", name, sizeof(name), ZR_CLASS_DEFAULT_NAME); - strcopy(ClassData[ClassCount][class_name], 64, 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); + 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], PLATFORM_MAX_PATH, model_path); + strcopy(ClassData[ClassCount][Class_ModelPath], PLATFORM_MAX_PATH, 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); + ClassData[ClassCount][Class_AlphaInitial] = KvGetNum(kvClassData, "alpha_initial", ZR_CLASS_DEFAULT_ALPHA_INITIAL); + ClassData[ClassCount][Class_AlphaDamaged] = KvGetNum(kvClassData, "alpha_damaged", ZR_CLASS_DEFAULT_ALPHA_DAMAGED); + ClassData[ClassCount][Class_AlphaDamage] = 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], PLATFORM_MAX_PATH, overlay_path); + strcopy(ClassData[ClassCount][Class_OverlayPath], PLATFORM_MAX_PATH, 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); + 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_has_napalm] = bool:KvGetNum(kvClassData, "have_napalm", ZR_CLASS_DEFAULT_HAS_NAPALM); - ClassData[ClassCount][class_napalm_time] = KvGetFloat(kvClassData, "napalm_time", ZR_CLASS_DEFAULT_NAPALM_TIME); + ClassData[ClassCount][Class_HasNapalm] = bool:KvGetNum(kvClassData, "have_napalm", ZR_CLASS_DEFAULT_HAS_NAPALM); + ClassData[ClassCount][Class_NapalmTime] = 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_ImmunityMode] = KvGetNum(kvClassData, "immunity_mode", ZR_CLASS_DEFAULT_IMMUNITY_MODE); + ClassData[ClassCount][Class_ImmunityAmount] = KvGetFloat(kvClassData, "immunity_amount", ZR_CLASS_DEFAULT_IMMUNITY_AMOUNT); + ClassData[ClassCount][Class_NoFallDamage] = 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_gain", ZR_CLASS_DEFAULT_HEALTH_INFECT_GAIN); - ClassData[ClassCount][class_kill_bonus] = KvGetNum(kvClassData, "kill_bonus", ZR_CLASS_DEFAULT_KILL_BONUS); + ClassData[ClassCount][Class_Health] = KvGetNum(kvClassData, "health", ZR_CLASS_DEFAULT_HEALTH); + ClassData[ClassCount][Class_HealthRegenInterval] = KvGetFloat(kvClassData, "health_regen_interval", ZR_CLASS_DEFAULT_HEALTH_REGEN_INTERVAL); + ClassData[ClassCount][Class_HealthRegenAmount] = KvGetNum(kvClassData, "health_regen_amount", ZR_CLASS_DEFAULT_HEALTH_REGEN_AMOUNT); + ClassData[ClassCount][Class_HealthInfectGain] = KvGetNum(kvClassData, "health_infect_gain", ZR_CLASS_DEFAULT_HEALTH_INFECT_GAIN); + ClassData[ClassCount][Class_KillBonus] = 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); + 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_JumpHeight] = KvGetFloat(kvClassData, "jump_height", ZR_CLASS_DEFAULT_JUMP_HEIGHT); + ClassData[ClassCount][Class_JumpDistance] = KvGetFloat(kvClassData, "jump_distance", ZR_CLASS_DEFAULT_JUMP_DISTANCE); // Validate the class attributes. ClassErrorFlags = ClassValidateAttributes(ClassCount); @@ -511,7 +533,7 @@ ClassLoad(bool:keepMultipliers = false) { // There's one or more invalid class attributes. Disable the class // and log an error message. - ClassData[ClassCount][class_enabled] = false; + ClassData[ClassCount][Class_Enabled] = false; LogEvent(false, LogType_Error, LOG_CORE_EVENTS, LogModule_Playerclasses, "Config Validation", "Warning: Invalid class at index %d, disabled class. Class error flags: %d.", ClassCount, ClassErrorFlags); failedcount++; @@ -589,41 +611,42 @@ bool:ClassReloadDataCache() for (new classindex = 0; classindex < ClassCount; classindex++) { /* 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]; - ClassDataCache[classindex][class_flags] = ClassData[classindex][class_flags]; - strcopy(ClassDataCache[classindex][class_name], 64, ClassData[classindex][class_name]); - strcopy(ClassDataCache[classindex][class_description], 256, ClassData[classindex][class_description]); + ClassDataCache[classindex][Class_Enabled] = ClassData[classindex][Class_Enabled]; + ClassDataCache[classindex][Class_Team] = ClassData[classindex][Class_Team]; + ClassDataCache[classindex][Class_TeamDefault] = ClassData[classindex][Class_TeamDefault]; + ClassDataCache[classindex][Class_Flags] = ClassData[classindex][Class_Flags]; + strcopy(ClassDataCache[classindex][Class_Group], 64, ClassData[classindex][Class_Group]); + 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], PLATFORM_MAX_PATH, 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]; + strcopy(ClassDataCache[classindex][Class_ModelPath], PLATFORM_MAX_PATH, ClassData[classindex][Class_ModelPath]); + ClassDataCache[classindex][Class_AlphaInitial] = ClassData[classindex][Class_AlphaInitial]; + ClassDataCache[classindex][Class_AlphaDamaged] = ClassData[classindex][Class_AlphaDamaged]; + ClassDataCache[classindex][Class_AlphaDamage] = ClassData[classindex][Class_AlphaDamage]; /* Hud */ - strcopy(ClassDataCache[classindex][class_overlay_path], PLATFORM_MAX_PATH, ClassData[classindex][class_overlay_path]); - ClassDataCache[classindex][class_nvgs] = ClassData[classindex][class_nvgs]; - ClassDataCache[classindex][class_fov] = ClassData[classindex][class_fov]; + strcopy(ClassDataCache[classindex][Class_OverlayPath], PLATFORM_MAX_PATH, ClassData[classindex][Class_OverlayPath]); + ClassDataCache[classindex][Class_Nvgs] = ClassData[classindex][Class_Nvgs]; + ClassDataCache[classindex][Class_Fov] = ClassData[classindex][Class_Fov]; /* Effects */ - ClassDataCache[classindex][class_has_napalm] = ClassData[classindex][class_has_napalm]; - ClassDataCache[classindex][class_napalm_time] = ClassData[classindex][class_napalm_time]; + ClassDataCache[classindex][Class_HasNapalm] = ClassData[classindex][Class_HasNapalm]; + ClassDataCache[classindex][Class_NapalmTime] = ClassData[classindex][Class_NapalmTime]; /* 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]; + ClassDataCache[classindex][Class_ImmunityMode] = ClassData[classindex][Class_ImmunityMode]; + ClassDataCache[classindex][Class_ImmunityAmount] = ClassData[classindex][Class_ImmunityAmount]; + ClassDataCache[classindex][Class_NoFallDamage] = ClassData[classindex][Class_NoFallDamage]; + ClassDataCache[classindex][Class_Health] = ClassData[classindex][Class_Health]; + ClassDataCache[classindex][Class_HealthRegenInterval] = ClassData[classindex][Class_HealthRegenInterval]; + ClassDataCache[classindex][Class_HealthRegenAmount] = ClassData[classindex][Class_HealthRegenAmount]; + ClassDataCache[classindex][Class_HealthInfectGain] = ClassData[classindex][Class_HealthInfectGain]; + ClassDataCache[classindex][Class_KillBonus] = ClassData[classindex][Class_KillBonus]; + ClassDataCache[classindex][Class_Speed] = ClassData[classindex][Class_Speed]; + ClassDataCache[classindex][Class_KnockBack] = ClassData[classindex][Class_KnockBack]; + ClassDataCache[classindex][Class_JumpHeight] = ClassData[classindex][Class_JumpHeight]; + ClassDataCache[classindex][Class_JumpDistance] = ClassData[classindex][Class_JumpDistance]; } return true; @@ -653,80 +676,82 @@ bool:ClassReloadPlayerCache(client, classindex, cachetype = ZR_CLASS_CACHE_MODIF 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]; - ClassPlayerCache[client][class_flags] = ClassData[classindex][class_flags]; - strcopy(ClassPlayerCache[client][class_name], 64, ClassData[classindex][class_name]); - strcopy(ClassPlayerCache[client][class_description], 256, ClassData[classindex][class_description]); + ClassPlayerCache[client][Class_Enabled] = ClassData[classindex][Class_Enabled]; + ClassPlayerCache[client][Class_Team] = ClassData[classindex][Class_Team]; + ClassPlayerCache[client][Class_TeamDefault] = ClassData[classindex][Class_TeamDefault]; + ClassPlayerCache[client][Class_Flags] = ClassData[classindex][Class_Flags]; + strcopy(ClassPlayerCache[client][Class_Group], 64, ClassData[classindex][Class_Group]); + 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], PLATFORM_MAX_PATH, 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]; + strcopy(ClassPlayerCache[client][Class_ModelPath], PLATFORM_MAX_PATH, ClassData[classindex][Class_ModelPath]); + ClassPlayerCache[client][Class_AlphaInitial] = ClassData[classindex][Class_AlphaInitial]; + ClassPlayerCache[client][Class_AlphaDamaged] = ClassData[classindex][Class_AlphaDamaged]; + ClassPlayerCache[client][Class_AlphaDamage] = ClassData[classindex][Class_AlphaDamage]; /* Hud */ - strcopy(ClassPlayerCache[client][class_overlay_path], PLATFORM_MAX_PATH, ClassData[classindex][class_overlay_path]); - ClassPlayerCache[client][class_nvgs] = ClassData[classindex][class_nvgs]; - ClassPlayerCache[client][class_fov] = ClassData[classindex][class_fov]; + strcopy(ClassPlayerCache[client][Class_OverlayPath], PLATFORM_MAX_PATH, ClassData[classindex][Class_OverlayPath]); + ClassPlayerCache[client][Class_Nvgs] = ClassData[classindex][Class_Nvgs]; + ClassPlayerCache[client][Class_Fov] = ClassData[classindex][Class_Fov]; /* Effects */ - ClassPlayerCache[client][class_has_napalm] = ClassData[classindex][class_has_napalm]; - ClassPlayerCache[client][class_napalm_time] = ClassData[classindex][class_napalm_time]; + ClassPlayerCache[client][Class_HasNapalm] = ClassData[classindex][Class_HasNapalm]; + ClassPlayerCache[client][Class_NapalmTime] = ClassData[classindex][Class_NapalmTime]; /* 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]; + ClassPlayerCache[client][Class_ImmunityMode] = ClassData[classindex][Class_ImmunityMode]; + ClassPlayerCache[client][Class_ImmunityAmount] = ClassData[classindex][Class_ImmunityAmount]; + ClassPlayerCache[client][Class_NoFallDamage] = ClassData[classindex][Class_NoFallDamage]; + ClassPlayerCache[client][Class_Health] = ClassData[classindex][Class_Health]; + ClassPlayerCache[client][Class_HealthRegenInterval] = ClassData[classindex][Class_HealthRegenInterval]; + ClassPlayerCache[client][Class_HealthRegenAmount] = ClassData[classindex][Class_HealthRegenAmount]; + ClassPlayerCache[client][Class_HealthInfectGain] = ClassData[classindex][Class_HealthInfectGain]; + ClassPlayerCache[client][Class_KillBonus] = ClassData[classindex][Class_KillBonus]; + ClassPlayerCache[client][Class_Speed] = ClassData[classindex][Class_Speed]; + ClassPlayerCache[client][Class_KnockBack] = ClassData[classindex][Class_KnockBack]; + ClassPlayerCache[client][Class_JumpHeight] = ClassData[classindex][Class_JumpHeight]; + ClassPlayerCache[client][Class_JumpDistance] = ClassData[classindex][Class_JumpDistance]; } 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]; - ClassPlayerCache[client][class_flags] = ClassDataCache[classindex][class_flags]; - strcopy(ClassPlayerCache[client][class_name], 64, ClassDataCache[classindex][class_name]); - strcopy(ClassPlayerCache[client][class_description], 256, ClassDataCache[classindex][class_description]); + ClassPlayerCache[client][Class_Enabled] = ClassDataCache[classindex][Class_Enabled]; + ClassPlayerCache[client][Class_Team] = ClassDataCache[classindex][Class_Team]; + ClassPlayerCache[client][Class_TeamDefault] = ClassDataCache[classindex][Class_TeamDefault]; + ClassPlayerCache[client][Class_Flags] = ClassDataCache[classindex][Class_Flags]; + strcopy(ClassPlayerCache[client][Class_Group], 64, ClassDataCache[classindex][Class_Group]); + 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], PLATFORM_MAX_PATH, 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]; + strcopy(ClassPlayerCache[client][Class_ModelPath], PLATFORM_MAX_PATH, ClassDataCache[classindex][Class_ModelPath]); + ClassPlayerCache[client][Class_AlphaInitial] = ClassDataCache[classindex][Class_AlphaInitial]; + ClassPlayerCache[client][Class_AlphaDamaged] = ClassDataCache[classindex][Class_AlphaDamaged]; + ClassPlayerCache[client][Class_AlphaDamage] = ClassDataCache[classindex][Class_AlphaDamage]; /* Hud */ - strcopy(ClassPlayerCache[client][class_overlay_path], PLATFORM_MAX_PATH, ClassDataCache[classindex][class_overlay_path]); - ClassPlayerCache[client][class_nvgs] = ClassDataCache[classindex][class_nvgs]; - ClassPlayerCache[client][class_fov] = ClassDataCache[classindex][class_fov]; + strcopy(ClassPlayerCache[client][Class_OverlayPath], PLATFORM_MAX_PATH, ClassDataCache[classindex][Class_OverlayPath]); + ClassPlayerCache[client][Class_Nvgs] = ClassDataCache[classindex][Class_Nvgs]; + ClassPlayerCache[client][Class_Fov] = ClassDataCache[classindex][Class_Fov]; /* Effects */ - ClassPlayerCache[client][class_has_napalm] = ClassDataCache[classindex][class_has_napalm]; - ClassPlayerCache[client][class_napalm_time] = ClassDataCache[classindex][class_napalm_time]; + ClassPlayerCache[client][Class_HasNapalm] = ClassDataCache[classindex][Class_HasNapalm]; + ClassPlayerCache[client][Class_NapalmTime] = ClassDataCache[classindex][Class_NapalmTime]; /* 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]; + ClassPlayerCache[client][Class_ImmunityMode] = ClassDataCache[classindex][Class_ImmunityMode]; + ClassPlayerCache[client][Class_ImmunityAmount] = ClassDataCache[classindex][Class_ImmunityAmount]; + ClassPlayerCache[client][Class_NoFallDamage] = ClassDataCache[classindex][Class_NoFallDamage]; + ClassPlayerCache[client][Class_Health] = ClassDataCache[classindex][Class_Health]; + ClassPlayerCache[client][Class_HealthRegenInterval] = ClassDataCache[classindex][Class_HealthRegenInterval]; + ClassPlayerCache[client][Class_HealthRegenAmount] = ClassDataCache[classindex][Class_HealthRegenAmount]; + ClassPlayerCache[client][Class_HealthInfectGain] = ClassDataCache[classindex][Class_HealthInfectGain]; + ClassPlayerCache[client][Class_KillBonus] = ClassDataCache[classindex][Class_KillBonus]; + ClassPlayerCache[client][Class_Speed] = ClassDataCache[classindex][Class_Speed]; + ClassPlayerCache[client][Class_KnockBack] = ClassDataCache[classindex][Class_KnockBack]; + ClassPlayerCache[client][Class_JumpHeight] = ClassDataCache[classindex][Class_JumpHeight]; + ClassPlayerCache[client][Class_JumpDistance] = ClassDataCache[classindex][Class_JumpDistance]; } default: { @@ -786,7 +811,7 @@ ClassResetMultiplierCache() } /** - * Resets the selected class indexes for next span on one or all clients. + * Resets the selected class indexes for next spawn on one or all clients. * * @param client Optional. Specify client to reset. Default is all. */ @@ -818,7 +843,7 @@ ClassResetNextIndexes(client = -1) * Note: Does not apply attributes. The classes are only marked as selected. * * @param client The client index. - * @param excludeTeam Do not restore the specified team. + * @param excludeTeam Optional. Do not restore the specified team. */ ClassRestoreNextIndexes(client, excludeTeam = -1) { @@ -980,6 +1005,10 @@ ClassDumpData(index, cachetype, String:buffer[], maxlen) Format(attribute, sizeof(attribute), "flags: \"%d\"\n", ClassGetFlags(index, cachetype)); cellcount += StrCat(buffer, maxlen, attribute); + ClassGetGroup(index, format_buffer, sizeof(format_buffer), cachetype); + Format(attribute, sizeof(attribute), "group: \"%d\"\n", format_buffer); + cellcount += StrCat(buffer, maxlen, attribute); + ClassGetName(index, format_buffer, sizeof(format_buffer), cachetype); Format(attribute, sizeof(attribute), "name: \"%s\"\n", format_buffer); cellcount += StrCat(buffer, maxlen, attribute);