2009-05-16 01:37:23 +02:00
|
|
|
/*
|
|
|
|
* ============================================================================
|
|
|
|
*
|
2009-05-30 04:17:01 +02:00
|
|
|
* Zombie:Reloaded
|
2009-05-16 01:37:23 +02:00
|
|
|
*
|
2009-05-30 04:17:01 +02:00
|
|
|
* File: volfeatures.inc
|
|
|
|
* Type: Module
|
|
|
|
* Description: Provides functions for managing volumetric features.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2009 Greyscale, Richard Helgeby
|
|
|
|
*
|
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
2009-05-16 01:37:23 +02:00
|
|
|
*
|
|
|
|
* ============================================================================
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Total volumes that can be created in a map.
|
|
|
|
*/
|
|
|
|
#define ZR_VOLUMES_MAX 64
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Represent a rectangular volume.
|
|
|
|
*/
|
|
|
|
enum VolumeAttributes
|
|
|
|
{
|
|
|
|
/* General */
|
2009-05-30 04:17:01 +02:00
|
|
|
bool:vol_enabled, /** Volume state. */
|
|
|
|
bool:vol_in_use, /** Marks if the volume is used. */
|
2009-05-16 01:37:23 +02:00
|
|
|
|
|
|
|
/* Location */
|
2009-05-30 04:17:01 +02:00
|
|
|
Float:vol_x_min, /** Minimum x position. */
|
|
|
|
Float:vol_x_max, /** Maximum x position. */
|
2009-05-16 01:37:23 +02:00
|
|
|
|
2009-05-30 04:17:01 +02:00
|
|
|
Float:vol_y_min, /** Minimum y position. */
|
|
|
|
Float:vol_y_max, /** Maximum y position. */
|
2009-05-16 01:37:23 +02:00
|
|
|
|
2009-05-30 04:17:01 +02:00
|
|
|
Float:vol_z_min, /** Minimum z position. */
|
|
|
|
Float:vol_z_max, /** Maximum z position. */
|
|
|
|
|
|
|
|
/* Style */
|
|
|
|
VolumeEffects:vol_effect, /** Visual effect to apply on the volume. */
|
|
|
|
vol_effect_color[3], /** Render color of the effect. RGB colors. */
|
2009-05-16 01:37:23 +02:00
|
|
|
|
|
|
|
/* Data */
|
2009-05-30 04:17:01 +02:00
|
|
|
VolumeFeatureTypes:vol_type, /** The volumetric feature type. */
|
|
|
|
vol_data_index, /** Index in remote feature array. */
|
|
|
|
|
|
|
|
/* Behaviour */
|
|
|
|
VolumeTeamFilters:vol_team_filter, /** Team filtering. Trigger by certain teams, or all. */
|
|
|
|
Float:vol_trigger_delay /** Trigger delay. How many seconds players have to stay to trigger volume events. */
|
2009-05-16 01:37:23 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Available volumetric feature types.
|
|
|
|
*/
|
|
|
|
enum VolumeFeatureTypes
|
|
|
|
{
|
|
|
|
VolFeature_Anticamp = 0,
|
|
|
|
VolFeature_Knockback
|
|
|
|
}
|
|
|
|
|
2009-05-30 04:17:01 +02:00
|
|
|
/**
|
|
|
|
* Effects that can be applied on a volume. (Currently no effects.)
|
|
|
|
*/
|
2009-05-16 01:37:23 +02:00
|
|
|
enum VolumeEffects
|
|
|
|
{
|
|
|
|
VolEffect_None = 0,
|
|
|
|
VolEffect_Wireframe,
|
|
|
|
VolEffect_Smoke
|
|
|
|
}
|
|
|
|
|
2009-05-30 04:17:01 +02:00
|
|
|
/**
|
|
|
|
* Available team filter settings.
|
|
|
|
*/
|
|
|
|
enum VolumeTeamFilters
|
|
|
|
{
|
|
|
|
VolTeam_All = 0,
|
|
|
|
VolTeam_Humans,
|
|
|
|
VolTeam_Zombies
|
|
|
|
}
|
|
|
|
|
2009-05-16 01:37:23 +02:00
|
|
|
/**
|
|
|
|
* Volumes.
|
|
|
|
*/
|
|
|
|
new Volumes[ZR_VOLUMES_MAX][VolumeAttributes];
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Total number of volumes.
|
|
|
|
*/
|
|
|
|
new VolumeCount;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* List of player locations. Updated by a timer.
|
|
|
|
*/
|
|
|
|
new Float:VolPlayerLoc[MAXPLAYERS + 1][3];
|
|
|
|
|
|
|
|
/**
|
2009-05-30 04:17:01 +02:00
|
|
|
* Specifies whether the volumetric features module is enabled or not. Synced
|
|
|
|
* with zr_vol CVAR.
|
2009-05-16 01:37:23 +02:00
|
|
|
*/
|
|
|
|
new bool:VolEnabled;
|
|
|
|
|
|
|
|
/**
|
2009-05-30 04:17:01 +02:00
|
|
|
* Counter for trigger delay.
|
|
|
|
*/
|
|
|
|
new Float:VolPlayerCountDown[MAXPLAYERS + 1][ZR_VOLUMES_MAX];
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The handle for a timer that updates player locations. This is the main timer
|
2009-05-16 01:37:23 +02:00
|
|
|
* and any feature events can't be updated faster than this interval.
|
|
|
|
*
|
|
|
|
* Note: Some features may have its own timer.
|
|
|
|
*/
|
|
|
|
new Handle:hVolUpdateTimer;
|
|
|
|
|
2009-05-30 04:17:01 +02:00
|
|
|
/**
|
|
|
|
* The handle for a timer that do count down on trigger delays.
|
|
|
|
*/
|
|
|
|
new Handle:hVolTriggerTimer;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Cached interval value for trigger timer.
|
|
|
|
*/
|
|
|
|
new Float:VolTriggerInterval;
|
|
|
|
|
2009-05-16 01:37:23 +02:00
|
|
|
#include "zr/volfeatures/volevents"
|
2009-05-30 04:17:01 +02:00
|
|
|
#include "zr/volfeatures/volgenericattributes"
|
|
|
|
#include "zr/volfeatures/volcommands"
|
2009-05-16 01:37:23 +02:00
|
|
|
#include "zr/volfeatures/volanticamp"
|
|
|
|
|
2009-05-30 04:17:01 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Initialize volumetric features.
|
|
|
|
*/
|
|
|
|
VolLoad()
|
|
|
|
{
|
|
|
|
// Cache CVAR value.
|
|
|
|
VolEnabled = GetConVarBool(g_hCvarsList[CVAR_VOL]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function alias for fully stopping volumetric features.
|
|
|
|
*/
|
|
|
|
VolDisable()
|
|
|
|
{
|
|
|
|
VolEnabled = false;
|
|
|
|
VolStopUpdateTimer();
|
|
|
|
|
|
|
|
// TODO: Send disable/stop event to volumes with their own timers.
|
|
|
|
}
|
|
|
|
|
2009-05-16 01:37:23 +02:00
|
|
|
/**
|
|
|
|
* Starts the update timer.
|
2009-05-30 04:17:01 +02:00
|
|
|
*
|
|
|
|
* @return True if timer is started, false otherwise.
|
2009-05-16 01:37:23 +02:00
|
|
|
*/
|
|
|
|
bool:VolStartUpdateTimer()
|
|
|
|
{
|
2009-05-30 04:17:01 +02:00
|
|
|
// Check if volumetric features is enabled.
|
2009-05-16 01:37:23 +02:00
|
|
|
if (!VolEnabled)
|
|
|
|
{
|
|
|
|
// Volumetric features disabled.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-05-30 04:17:01 +02:00
|
|
|
// Stop timer if it exist.
|
|
|
|
VolStopUpdateTimer();
|
|
|
|
|
|
|
|
// Get update interval.
|
|
|
|
new Float:interval = GetConVarFloat(g_hCvarsList[CVAR_VOL_UPDATE_INTERVAL]);
|
2009-05-16 01:37:23 +02:00
|
|
|
|
|
|
|
// Validate interval.
|
|
|
|
if (interval > 0.0)
|
|
|
|
{
|
|
|
|
// Create a new timer.
|
|
|
|
hVolUpdateTimer = CreateTimer(interval, Event_VolUpdateTimer, _, TIMER_REPEAT);
|
|
|
|
|
2009-05-30 04:17:01 +02:00
|
|
|
// Also start the trigger delay timer.
|
|
|
|
VolStartTriggerTimer();
|
|
|
|
|
2009-05-16 01:37:23 +02:00
|
|
|
// Volumetric features started.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2009-05-30 04:17:01 +02:00
|
|
|
// Volumetric features disabled.
|
2009-05-16 01:37:23 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Kills the update timer if it exists.
|
|
|
|
*/
|
|
|
|
VolStopUpdateTimer()
|
|
|
|
{
|
|
|
|
// Kill the timer if it's running.
|
|
|
|
if (hVolUpdateTimer != INVALID_HANDLE)
|
|
|
|
{
|
|
|
|
KillTimer(hVolUpdateTimer);
|
|
|
|
hVolUpdateTimer = INVALID_HANDLE;
|
|
|
|
}
|
2009-05-30 04:17:01 +02:00
|
|
|
|
|
|
|
// Also stop trigger delay timer.
|
|
|
|
VolStopTriggerTimer();
|
|
|
|
|
|
|
|
// Reset all trigger delay counters.
|
|
|
|
VolResetCountDown();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Starts the update timer if it exists.
|
|
|
|
*
|
|
|
|
* @return True if timer is started, false otherwise.
|
|
|
|
*/
|
|
|
|
bool:VolStartTriggerTimer()
|
|
|
|
{
|
|
|
|
// Make sure existing timer is killed.
|
|
|
|
VolStopTriggerTimer();
|
|
|
|
|
|
|
|
// Get trigger interval and cache it.
|
|
|
|
VolTriggerInterval = GetConVarFloat(g_hCvarsList[CVAR_VOL_TRIGGER_INTERVAL]);
|
|
|
|
|
|
|
|
// Validate interval.
|
|
|
|
if (VolTriggerInterval > 0.0)
|
|
|
|
{
|
|
|
|
// Start the timer.
|
|
|
|
hVolTriggerTimer = CreateTimer(VolTriggerInterval, Event_VolUpdateTimer, _, TIMER_REPEAT);
|
|
|
|
|
|
|
|
// Trigger timer started.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Trigger timer not running. Either disabled or invalid interval.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Kills the trigger delay timer if it exists.
|
|
|
|
*/
|
|
|
|
VolStopTriggerTimer()
|
|
|
|
{
|
|
|
|
// Kill the timer if it's running.
|
|
|
|
if (hVolTriggerTimer != INVALID_HANDLE)
|
|
|
|
{
|
|
|
|
KillTimer(hVolTriggerTimer);
|
|
|
|
hVolTriggerTimer = INVALID_HANDLE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Resets volume trigger delay counters on one or more players.
|
|
|
|
*
|
|
|
|
* @param client Optional. Specifies a single player to reset. Default is
|
|
|
|
* -1, all players.
|
|
|
|
*/
|
|
|
|
VolResetCountDown(client = -1)
|
|
|
|
{
|
|
|
|
// Check if a client is specified.
|
|
|
|
if (client > -1)
|
|
|
|
{
|
|
|
|
// Reset volume counters.
|
|
|
|
for (new volumeIndex = 0; volumeIndex < ZR_VOLUMES_MAX; volumeIndex++)
|
|
|
|
{
|
|
|
|
VolPlayerCountDown[client][volumeIndex] = -1.0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Reset all volume counters.
|
2009-06-03 01:37:37 +02:00
|
|
|
for (new clientIndex = 0; clientIndex < MAXPLAYERS + 1; clientIndex++)
|
2009-05-30 04:17:01 +02:00
|
|
|
{
|
|
|
|
for (new volumeIndex = 0; volumeIndex < ZR_VOLUMES_MAX; volumeIndex++)
|
|
|
|
{
|
|
|
|
VolPlayerCountDown[clientIndex][volumeIndex] = -1.0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-05-16 01:37:23 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Updates all player locations. Used for initialization.
|
|
|
|
*
|
|
|
|
* Note: If a client is specified, it's NOT validated. This function assumes
|
|
|
|
* the specified client is in game and alive.
|
|
|
|
*
|
|
|
|
* @param client Optional. Specify single client to be updated. Default is
|
|
|
|
* -1.
|
|
|
|
*/
|
|
|
|
VolUpdatePlayerLocation(client = -1)
|
|
|
|
{
|
|
|
|
if (client <= 0)
|
|
|
|
{
|
|
|
|
// Assume the client is valid and save location in array.
|
|
|
|
GetClientAbsOrigin(client, VolPlayerLoc[client]);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2009-05-30 04:17:01 +02:00
|
|
|
for (client = 1; client <= MaxClients; client++)
|
2009-05-16 01:37:23 +02:00
|
|
|
{
|
|
|
|
// Check if client is in game and alive.
|
|
|
|
if (!IsClientConnected(client) || !IsClientInGame(client) || !IsPlayerAlive(client))
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Save location in array.
|
|
|
|
GetClientAbsOrigin(client, VolPlayerLoc[client]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Updates player locations and trigger events for each player that enter or
|
|
|
|
* leave a volume.
|
|
|
|
*/
|
|
|
|
VolUpdatePlayerChanges()
|
|
|
|
{
|
|
|
|
new bool:volumeStates[ZR_VOLUMES_MAX];
|
|
|
|
new bool:volumeNewStates[ZR_VOLUMES_MAX];
|
|
|
|
|
|
|
|
new bool:newState;
|
|
|
|
new bool:oldState;
|
|
|
|
|
2009-05-30 04:17:01 +02:00
|
|
|
new Float:trigger_delay;
|
|
|
|
|
|
|
|
// Loop through all players.
|
2009-05-16 01:37:23 +02:00
|
|
|
for (new client = 1; client <= MaxClients; client++)
|
|
|
|
{
|
|
|
|
// Check if client is in game and alive.
|
|
|
|
if (!IsClientConnected(client) || !IsClientInGame(client) || !IsPlayerAlive(client))
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get the current volume states.
|
|
|
|
VolGetPlayerStates(client, volumeStates, sizeof(volumeStates));
|
|
|
|
|
|
|
|
// Update player location cache.
|
|
|
|
GetClientAbsOrigin(client, VolPlayerLoc[client]);
|
|
|
|
|
|
|
|
// Get new volume states.
|
|
|
|
VolGetPlayerStates(client, volumeNewStates, sizeof(volumeNewStates));
|
|
|
|
|
|
|
|
// Loop through each volume and compare states.
|
|
|
|
for (new volumeIndex = 0; volumeIndex < VolumeCount; volumeIndex++)
|
|
|
|
{
|
|
|
|
newState = volumeNewStates[volumeIndex];
|
|
|
|
oldState = volumeStates[volumeIndex];
|
|
|
|
|
|
|
|
// Compare new states with old states.
|
|
|
|
if (newState == oldState)
|
|
|
|
{
|
|
|
|
// No change. Skip to next volume.
|
|
|
|
break;
|
|
|
|
}
|
2009-05-30 04:17:01 +02:00
|
|
|
|
|
|
|
// Check if client entered the volume.
|
2009-05-16 01:37:23 +02:00
|
|
|
else if (!newState && oldState)
|
|
|
|
{
|
2009-05-30 04:17:01 +02:00
|
|
|
// Get trigger delay value.
|
|
|
|
trigger_delay = Volumes[volumeIndex][vol_trigger_delay];
|
|
|
|
|
|
|
|
// Check if the volume has a trigger delay.
|
|
|
|
if (trigger_delay > 0.0)
|
|
|
|
{
|
|
|
|
// Set count down value.
|
|
|
|
VolPlayerCountDown[client][volumeIndex] = trigger_delay;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// No trigger delay, trigger event instantly.
|
|
|
|
VolOnPlayerEnter(client, volumeIndex);
|
|
|
|
}
|
2009-05-16 01:37:23 +02:00
|
|
|
}
|
2009-05-30 04:17:01 +02:00
|
|
|
|
|
|
|
// Check if client left the volume.
|
2009-05-16 01:37:23 +02:00
|
|
|
else if (newState && !oldState)
|
|
|
|
{
|
2009-05-30 04:17:01 +02:00
|
|
|
// Make sure count down value is reset.
|
|
|
|
VolPlayerCountDown[client][volumeIndex] = -1.0;
|
|
|
|
|
|
|
|
// Trigger event.
|
2009-05-16 01:37:23 +02:00
|
|
|
VolOnPlayerLeave(client, volumeIndex);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns wether a position is within a certain location.
|
|
|
|
*
|
|
|
|
* @param loc The position to check.
|
|
|
|
* @param min Minimum x, y and z values of the location.
|
|
|
|
* @param max Maximum x, y and z values of the location.
|
|
|
|
* @return True if the position is within min and max values. False
|
|
|
|
* otherwise.
|
|
|
|
*/
|
|
|
|
bool:IsPositionInLocation(Float:pos[3], Float:min[3], Float:max[3])
|
|
|
|
{
|
|
|
|
// Cache location to avoid re-indexing arrays.
|
|
|
|
new Float:posX = pos[0];
|
|
|
|
new Float:posY = pos[1];
|
|
|
|
new Float:posZ = pos[2];
|
|
|
|
|
|
|
|
// Check if within x boundaries.
|
|
|
|
if ((posX >= min[0]) && (posX <= max[0]))
|
|
|
|
{
|
|
|
|
// Check if within y boundaries.
|
|
|
|
if ((posY >= min[1]) && (posY <= max[1]))
|
|
|
|
{
|
|
|
|
// Check if within x boundaries.
|
|
|
|
if ((posZ >= min[2]) && (posZ <= max[2]))
|
|
|
|
{
|
|
|
|
// The player is within the location boundaries.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// The player is outside the location boundaries.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns wether a volume is marked as in use.
|
|
|
|
*
|
2009-05-30 04:17:01 +02:00
|
|
|
* Note: Does not validate index.
|
|
|
|
*
|
2009-05-16 01:37:23 +02:00
|
|
|
* @param volumeIndex The volume index.
|
|
|
|
* @return True if in use, false otherwise.
|
|
|
|
*/
|
|
|
|
bool:VolIsInUse(volumeIndex)
|
|
|
|
{
|
|
|
|
return Volumes[volumeIndex][vol_in_use];
|
|
|
|
}
|
|
|
|
|
2009-05-30 04:17:01 +02:00
|
|
|
/**
|
|
|
|
* Validates a volume index.
|
|
|
|
*
|
|
|
|
* @param volumeIndex The volume index.
|
|
|
|
* @return True if valid, false otherwise.
|
|
|
|
*/
|
|
|
|
bool:VolIsValidIndex(volumeIndex)
|
|
|
|
{
|
|
|
|
if (volumeIndex >= 0 && volumeIndex < ZR_VOLUMES_MAX)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-05-16 01:37:23 +02:00
|
|
|
/**
|
|
|
|
* Gets the first free volume index.
|
|
|
|
*
|
|
|
|
* @return The first free volume index if successful, or -1 if there are
|
|
|
|
* no free volumes.
|
|
|
|
*/
|
|
|
|
VolGetFreeVolume()
|
|
|
|
{
|
|
|
|
// Loop through all volumes.
|
|
|
|
for (new volumeIndex = 0; volumeIndex < ZR_VOLUMES_MAX; volumeIndex++)
|
|
|
|
{
|
|
|
|
// Check if it's free.
|
|
|
|
if (!VolIsInUse(volumeIndex))
|
|
|
|
{
|
|
|
|
return volumeIndex;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// No free volumes found.
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Gets wether a client is within volumes or not. Result is stored in a boolean
|
|
|
|
* array.
|
|
|
|
*
|
|
|
|
* @param client The client index.
|
|
|
|
* @param buffer Destination buffer.
|
|
|
|
* @param maxlen Size of destination buffer.
|
|
|
|
* @return Number of volumes the client is within.
|
|
|
|
*/
|
|
|
|
VolGetPlayerStates(client, bool:buffer[], maxlen)
|
|
|
|
{
|
|
|
|
new volumeBuffer[VolumeAttributes];
|
|
|
|
new volCount;
|
|
|
|
|
|
|
|
new Float:volMinBuffer[3];
|
|
|
|
new Float:volMaxBuffer[3];
|
|
|
|
|
|
|
|
// Loop through all available volumes.
|
|
|
|
for (new volumeIndex = 0; volumeIndex < VolumeCount && volumeIndex < maxlen; volumeIndex++)
|
|
|
|
{
|
|
|
|
if (VolIsInUse(volumeIndex))
|
|
|
|
{
|
|
|
|
// Chache volume to avoid re-indexing.
|
|
|
|
volumeBuffer = Volumes[volumeIndex];
|
|
|
|
|
|
|
|
// Get min positions.
|
|
|
|
volMinBuffer[0] = volumeBuffer[vol_x_min];
|
|
|
|
volMinBuffer[1] = volumeBuffer[vol_y_min];
|
|
|
|
volMinBuffer[2] = volumeBuffer[vol_z_min];
|
|
|
|
|
|
|
|
// Get max positions.
|
|
|
|
volMaxBuffer[0] = volumeBuffer[vol_x_min];
|
|
|
|
volMaxBuffer[1] = volumeBuffer[vol_y_min];
|
|
|
|
volMaxBuffer[2] = volumeBuffer[vol_z_min];
|
|
|
|
|
|
|
|
// Check the cached player location.
|
|
|
|
if (IsPositionInLocation(VolPlayerLoc[client], volMinBuffer, volMaxBuffer))
|
|
|
|
{
|
|
|
|
// Mark player as in volume.
|
|
|
|
buffer[volumeIndex] = true;
|
|
|
|
volCount++;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Do explicit reset.
|
|
|
|
buffer[volumeIndex] = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return volCount;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Callback for update timer. This is the main timer in volumetric features.
|
|
|
|
*/
|
|
|
|
public Action:Event_VolUpdateTimer(Handle:timer)
|
|
|
|
{
|
|
|
|
VolUpdatePlayerChanges();
|
|
|
|
}
|
2009-05-30 04:17:01 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Callback for trigger delay timer.
|
|
|
|
*/
|
|
|
|
public Action:Event_VolTriggerTimer(Handle:timer)
|
|
|
|
{
|
|
|
|
new Float:countDown;
|
|
|
|
|
|
|
|
// Loop through all players.
|
|
|
|
for (new client = 1; client <= MaxClients; client++)
|
|
|
|
{
|
|
|
|
// Loop through all volumes.
|
|
|
|
for (new volumeIndex = 0; volumeIndex < ZR_VOLUMES_MAX; volumeIndex++)
|
|
|
|
{
|
|
|
|
// Get count down value.
|
|
|
|
countDown = VolPlayerCountDown[client][volumeIndex];
|
|
|
|
|
|
|
|
// Check if volume trigger delay is enabled.
|
|
|
|
if (countDown > 0.0)
|
|
|
|
{
|
|
|
|
// Substract by trigger interval.
|
|
|
|
countDown -= VolTriggerInterval;
|
|
|
|
|
|
|
|
// Check if zero or below.
|
|
|
|
if (countDown <= 0.0)
|
|
|
|
{
|
|
|
|
// Trigger volume enter event.
|
|
|
|
VolOnPlayerEnter(client, volumeIndex);
|
|
|
|
|
|
|
|
// Reset count down value.
|
|
|
|
VolPlayerCountDown[client][volumeIndex] = -1.0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Called when zr_vol CVAR is changed.
|
|
|
|
*/
|
|
|
|
public VolEnabledChanged(Handle:cvar, const String:oldvalue[], const String:newvalue[])
|
|
|
|
{
|
|
|
|
new bool:isEnabled = bool:StringToInt(newvalue);
|
|
|
|
|
|
|
|
if (isEnabled)
|
|
|
|
{
|
|
|
|
// Volumetric features is enabled.
|
|
|
|
VolEnabled = true;
|
|
|
|
|
|
|
|
// Start timers.
|
|
|
|
VolStartUpdateTimer();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Volumetric features is disabled.
|
|
|
|
VolDisable();
|
|
|
|
}
|
|
|
|
}
|