314 lines
8.3 KiB
SourcePawn
314 lines
8.3 KiB
SourcePawn
/*
|
|
* ============================================================================
|
|
*
|
|
* Zombie:Reloaded
|
|
*
|
|
* File: voltools.inc
|
|
* Type: Module
|
|
* Description: Provides functions for managing volumes.
|
|
*
|
|
* Copyright (C) 2009-2013 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/>.
|
|
*
|
|
* ============================================================================
|
|
*/
|
|
|
|
/**
|
|
* Returns wether a point is within a certain location.
|
|
*
|
|
* @param point The point 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:IsPointInLocation(Float:point[3], Float:min[3], Float:max[3])
|
|
{
|
|
// Cache to avoid re-indexing arrays.
|
|
new Float:posX = point[0];
|
|
new Float:posY = point[1];
|
|
new Float:posZ = point[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 point is within the location boundaries.
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// The point is outside the location boundaries.
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns wether a volume is marked as in use.
|
|
*
|
|
* Note: Does not validate index.
|
|
*
|
|
* @param volumeIndex The volume index.
|
|
* @return True if in use, false otherwise.
|
|
*/
|
|
bool:VolInUse(volumeIndex)
|
|
{
|
|
return Volumes[volumeIndex][Vol_InUse];
|
|
}
|
|
|
|
/**
|
|
* Returns wether a volume is enabled or not.
|
|
*
|
|
* Note: Does not validate index.
|
|
*
|
|
* @param volumeIndex The volume index.
|
|
* @return True if enabled, false otherwise.
|
|
*/
|
|
bool:VolIsEnabled(volumeIndex)
|
|
{
|
|
return Volumes[volumeIndex][Vol_Enabled];
|
|
}
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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 (!VolInUse(volumeIndex))
|
|
{
|
|
return volumeIndex;
|
|
}
|
|
}
|
|
|
|
// No free volumes found.
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Gets a free index in the data array for the specified volume type.
|
|
*
|
|
* @param volumeType Volumetric feature type.
|
|
* @return Data index, or -1 on error.
|
|
*/
|
|
VolGetFreeDataIndex(VolumeFeatureTypes:volumeType)
|
|
{
|
|
switch (volumeType)
|
|
{
|
|
case VolFeature_Anticamp:
|
|
{
|
|
return VolAnticampGetFreeIndex();
|
|
}
|
|
case VolFeature_ClassEdit:
|
|
{
|
|
return VolClassEditGetFreeIndex();
|
|
}
|
|
}
|
|
|
|
// No match.
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Checks if the specified client match the team filtering for the specified
|
|
* volume.
|
|
*
|
|
* @param client The client index.
|
|
* @param volumeIndex The volume to check team filtering on.
|
|
* @return True if client pass the team filtering, false otherwise.
|
|
*/
|
|
bool:VolTeamFilterMatch(client, volumeIndex)
|
|
{
|
|
new VolumeTeamFilters:filter;
|
|
|
|
// Chache filter value.
|
|
filter = Volumes[volumeIndex][Vol_TeamFilter];
|
|
|
|
switch (filter)
|
|
{
|
|
case VolTeam_All:
|
|
{
|
|
// All maches everyone.
|
|
return true;
|
|
}
|
|
case VolTeam_Humans:
|
|
{
|
|
// Check if client is a human.
|
|
return InfectIsClientHuman(client);
|
|
}
|
|
case VolTeam_Zombies:
|
|
{
|
|
// Check if client is a zombie.
|
|
return InfectIsClientInfected(client);
|
|
}
|
|
}
|
|
|
|
// Invalid filter value.
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Checs if a volume is a certain type.
|
|
*
|
|
* @param volumeIndex Volume to check.
|
|
* @param volType Type to match.
|
|
* @return True if the types match, false otherwise.
|
|
*/
|
|
bool:VolIsType(volumeIndex, VolumeFeatureTypes:volType)
|
|
{
|
|
return Volumes[volumeIndex][Vol_Type] == volType;
|
|
}
|
|
|
|
/**
|
|
* 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 < ZR_VOLUMES_MAX && volumeIndex < maxlen; volumeIndex++)
|
|
{
|
|
if (VolInUse(volumeIndex))
|
|
{
|
|
// Chache volume to avoid re-indexing.
|
|
volumeBuffer = Volumes[volumeIndex];
|
|
|
|
// Get min positions.
|
|
volMinBuffer[0] = volumeBuffer[Vol_xMin];
|
|
volMinBuffer[1] = volumeBuffer[Vol_yMin];
|
|
volMinBuffer[2] = volumeBuffer[Vol_zMin];
|
|
|
|
// Get max positions.
|
|
volMaxBuffer[0] = volumeBuffer[Vol_xMax];
|
|
volMaxBuffer[1] = volumeBuffer[Vol_yMax];
|
|
volMaxBuffer[2] = volumeBuffer[Vol_zMax];
|
|
|
|
// Check the cached player location.
|
|
if (IsPointInLocation(VolPlayerLoc[client], volMinBuffer, volMaxBuffer))
|
|
{
|
|
// Mark player as in volume.
|
|
buffer[volumeIndex] = true;
|
|
volCount++;
|
|
}
|
|
else
|
|
{
|
|
// Do explicit reset.
|
|
buffer[volumeIndex] = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return volCount;
|
|
}
|
|
|
|
/**
|
|
* Converts a string into a volumetric feature type.
|
|
*
|
|
* @param volType String to convert. Name of type.
|
|
* @return Volumetric feature type or VolFeature_Invalid on error.
|
|
*/
|
|
VolumeFeatureTypes:VolGetTypeFromString(const String:volType[])
|
|
{
|
|
// Check if empty.
|
|
if (strlen(volType) == 0)
|
|
{
|
|
return VolFeature_Invalid;
|
|
}
|
|
|
|
// Match types.
|
|
if (StrEqual(volType, "anticamp", false))
|
|
{
|
|
return VolFeature_Anticamp;
|
|
}
|
|
else if (StrEqual(volType, "classedit", false))
|
|
{
|
|
return VolFeature_ClassEdit;
|
|
}
|
|
|
|
// No match.
|
|
return VolFeature_Invalid;
|
|
}
|
|
|
|
/**
|
|
* Converts a volume type to a string.
|
|
*
|
|
* @param volType Volume type to convert.
|
|
* @param buffer Destination string buffer.
|
|
* @param maxlen Size of destination buffer.
|
|
* @param shortName Optional. Write short name or human readable name.
|
|
* Default is human readable (false).
|
|
* @return Number of cells written.
|
|
*/
|
|
VolTypeToString(VolumeFeatureTypes:volType, String:buffer[], maxlen, bool:shortName = false)
|
|
{
|
|
switch (volType)
|
|
{
|
|
case VolFeature_Invalid:
|
|
{
|
|
return shortName ? strcopy(buffer, maxlen, "") : strcopy(buffer, maxlen, "(none)");
|
|
}
|
|
case VolFeature_Anticamp:
|
|
{
|
|
return shortName ? strcopy(buffer, maxlen, "anticamp") : strcopy(buffer, maxlen, "Anti-Camp");
|
|
}
|
|
case VolFeature_ClassEdit:
|
|
{
|
|
return shortName ? strcopy(buffer, maxlen, "classedit") : strcopy(buffer, maxlen, "Class Editor");
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|