251cced1f8
Various minor things done to project files Updated sample extension project file and updated makefile to the new unified version (more changes likely on the way) Updated regex project file and makefile --HG-- extra : convert_revision : svn%3A39bc706e-5318-0410-9160-8a85361fbb7c/trunk%401971
476 lines
12 KiB
C++
476 lines
12 KiB
C++
/**
|
|
* vim: set ts=4 :
|
|
* =============================================================================
|
|
* SourceMod
|
|
* Copyright (C) 2004-2008 AlliedModders LLC. All rights reserved.
|
|
* =============================================================================
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it under
|
|
* the terms of the GNU General Public License, version 3.0, as published by the
|
|
* Free Software Foundation.
|
|
*
|
|
* 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/>.
|
|
*
|
|
* As a special exception, AlliedModders LLC gives you permission to link the
|
|
* code of this program (as well as its derivative works) to "Half-Life 2," the
|
|
* "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
|
|
* by the Valve Corporation. You must obey the GNU General Public License in
|
|
* all respects for all other code used. Additionally, AlliedModders LLC grants
|
|
* this exception to all derivative works. AlliedModders LLC defines further
|
|
* exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
|
|
* or <http://www.sourcemod.net/license.php>.
|
|
*
|
|
* Version: $Id$
|
|
*/
|
|
|
|
#include "sm_globals.h"
|
|
#include "GameConfigs.h"
|
|
#include "UserMessages.h"
|
|
#include "TimerSys.h"
|
|
#include "PlayerManager.h"
|
|
#include "HandleSys.h"
|
|
|
|
#define MAX_HUD_CHANNELS 6
|
|
|
|
int g_HudMsgNum = -1;
|
|
|
|
struct hud_syncobj_t
|
|
{
|
|
int *player_channels;
|
|
};
|
|
|
|
struct player_chaninfo_t
|
|
{
|
|
double chan_times[MAX_HUD_CHANNELS];
|
|
hud_syncobj_t *chan_syncobjs[MAX_HUD_CHANNELS];
|
|
};
|
|
|
|
struct hud_text_parms
|
|
{
|
|
float x;
|
|
float y;
|
|
int effect;
|
|
byte r1, g1, b1, a1;
|
|
byte r2, g2, b2, a2;
|
|
float fadeinTime;
|
|
float fadeoutTime;
|
|
float holdTime;
|
|
float fxTime;
|
|
int channel;
|
|
};
|
|
|
|
class HudMsgHelpers :
|
|
public SMGlobalClass,
|
|
public IHandleTypeDispatch,
|
|
public IClientListener
|
|
{
|
|
public:
|
|
bool IsSupported()
|
|
{
|
|
return (g_HudMsgNum != -1);
|
|
}
|
|
|
|
virtual void OnSourceModAllInitialized_Post()
|
|
{
|
|
const char *key;
|
|
|
|
key = g_pGameConf->GetKeyValue("HudTextMsg");
|
|
if (key != NULL)
|
|
{
|
|
g_HudMsgNum = g_UserMsgs.GetMessageIndex(key);
|
|
}
|
|
|
|
if (!IsSupported())
|
|
{
|
|
m_hHudSyncObj = 0;
|
|
m_PlayerHuds = NULL;
|
|
return;
|
|
}
|
|
|
|
m_PlayerHuds = new player_chaninfo_t[256+1];
|
|
m_hHudSyncObj = g_HandleSys.CreateType("HudSyncObj", this, 0, NULL, NULL, g_pCoreIdent, NULL);
|
|
|
|
g_Players.AddClientListener(this);
|
|
}
|
|
|
|
virtual void OnSourceModShutdown()
|
|
{
|
|
if (!IsSupported())
|
|
{
|
|
return;
|
|
}
|
|
|
|
delete [] m_PlayerHuds;
|
|
g_HandleSys.RemoveType(m_hHudSyncObj, g_pCoreIdent);
|
|
|
|
g_Players.RemoveClientListener(this);
|
|
}
|
|
|
|
virtual void OnHandleDestroy(HandleType_t type, void *object)
|
|
{
|
|
hud_syncobj_t *obj = (hud_syncobj_t *)object;
|
|
|
|
delete [] obj->player_channels;
|
|
delete obj;
|
|
}
|
|
|
|
virtual bool GetHandleApproxSize(HandleType_t type, void *object, unsigned int *pSize)
|
|
{
|
|
*pSize = sizeof(unsigned int) * g_Players.GetMaxClients();
|
|
return true;
|
|
}
|
|
|
|
virtual void OnClientConnected(int client)
|
|
{
|
|
player_chaninfo_t *player;
|
|
|
|
player = &m_PlayerHuds[client];
|
|
memset(player->chan_syncobjs, 0, sizeof(player->chan_syncobjs));
|
|
memset(player->chan_times, 0, sizeof(player->chan_times));
|
|
}
|
|
|
|
Handle_t CreateHudSyncObj(IdentityToken_t *pIdent)
|
|
{
|
|
Handle_t hndl;
|
|
int max_clients;
|
|
HandleError err;
|
|
hud_syncobj_t *obj;
|
|
HandleSecurity sec;
|
|
|
|
if ((max_clients = g_Players.MaxClients()) == 0)
|
|
{
|
|
max_clients = 256+1;
|
|
}
|
|
|
|
obj = new hud_syncobj_t;
|
|
obj->player_channels = new int[max_clients];
|
|
|
|
memset(obj->player_channels, 0, sizeof(int) * max_clients);
|
|
|
|
sec = HandleSecurity(pIdent, g_pCoreIdent);
|
|
|
|
if ((hndl = g_HandleSys.CreateHandleEx(m_hHudSyncObj, obj, &sec, NULL, &err))
|
|
== BAD_HANDLE)
|
|
{
|
|
delete [] obj->player_channels;
|
|
delete obj;
|
|
}
|
|
|
|
return hndl;
|
|
}
|
|
|
|
HandleError ReadHudSyncObj(Handle_t hndl,
|
|
IdentityToken_t *pOwner,
|
|
hud_syncobj_t **pObj)
|
|
{
|
|
HandleSecurity sec(pOwner, g_pCoreIdent);
|
|
return g_HandleSys.ReadHandle(hndl, m_hHudSyncObj, &sec, (void **)pObj);
|
|
}
|
|
|
|
unsigned int AutoSelectChannel(unsigned int client)
|
|
{
|
|
int last_channel;
|
|
player_chaninfo_t *player;
|
|
|
|
player = &m_PlayerHuds[client];
|
|
|
|
last_channel = 0;
|
|
for (unsigned int i = 1; i < MAX_HUD_CHANNELS; i++)
|
|
{
|
|
if (player->chan_times[i] < player->chan_times[last_channel])
|
|
{
|
|
last_channel = i;
|
|
}
|
|
}
|
|
|
|
ManualSelectChannel(client, last_channel);
|
|
|
|
return last_channel;
|
|
}
|
|
|
|
int TryReuseLastChannel(unsigned int client, hud_syncobj_t *obj)
|
|
{
|
|
int last_channel;
|
|
player_chaninfo_t *player;
|
|
|
|
player = &m_PlayerHuds[client];
|
|
|
|
/* First, see if we can re-use the previous channel. */
|
|
last_channel = obj->player_channels[client];
|
|
|
|
if (player->chan_syncobjs[last_channel] == obj)
|
|
{
|
|
player->chan_times[last_channel] = *g_pUniversalTime;
|
|
return last_channel;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
int AutoSelectChannel(unsigned int client, hud_syncobj_t *obj)
|
|
{
|
|
int last_channel;
|
|
player_chaninfo_t *player;
|
|
|
|
player = &m_PlayerHuds[client];
|
|
|
|
/* First, see if we can re-use the previous channel. */
|
|
last_channel = obj->player_channels[client];
|
|
|
|
if (player->chan_syncobjs[last_channel] == obj)
|
|
{
|
|
player->chan_times[last_channel] = *g_pUniversalTime;
|
|
return last_channel;
|
|
}
|
|
|
|
last_channel = 0;
|
|
for (unsigned int i = 1; i < MAX_HUD_CHANNELS; i++)
|
|
{
|
|
if (player->chan_times[i] < player->chan_times[last_channel])
|
|
{
|
|
last_channel = i;
|
|
}
|
|
}
|
|
|
|
obj->player_channels[client] = last_channel;
|
|
player->chan_syncobjs[last_channel] = obj;
|
|
player->chan_times[last_channel] = *g_pUniversalTime;
|
|
|
|
return last_channel;
|
|
}
|
|
|
|
int ManualSelectChannel(unsigned int client, int channel)
|
|
{
|
|
player_chaninfo_t *player;
|
|
|
|
player = &m_PlayerHuds[client];
|
|
player->chan_times[channel] = *g_pUniversalTime;
|
|
player->chan_syncobjs[channel] = NULL;
|
|
|
|
return channel;
|
|
}
|
|
private:
|
|
HandleType_t m_hHudSyncObj;
|
|
player_chaninfo_t *m_PlayerHuds;
|
|
} s_HudMsgHelpers;
|
|
|
|
hud_text_parms g_hud_params;
|
|
|
|
static cell_t CreateHudSynchronizer(IPluginContext *pContext, const cell_t *params)
|
|
{
|
|
return s_HudMsgHelpers.CreateHudSyncObj(pContext->GetIdentity());
|
|
}
|
|
|
|
static cell_t SetHudTextParams(IPluginContext *pContext, const cell_t *params)
|
|
{
|
|
g_hud_params.x = sp_ctof(params[1]);
|
|
g_hud_params.y = sp_ctof(params[2]);
|
|
g_hud_params.holdTime = sp_ctof(params[3]);
|
|
g_hud_params.r1 = static_cast<byte>(params[4]);
|
|
g_hud_params.g1 = static_cast<byte>(params[5]);
|
|
g_hud_params.b1 = static_cast<byte>(params[6]);
|
|
g_hud_params.a1 = static_cast<byte>(params[7]);
|
|
g_hud_params.effect = params[8];
|
|
g_hud_params.fxTime = sp_ctof(params[9]);
|
|
g_hud_params.fadeinTime = sp_ctof(params[10]);
|
|
g_hud_params.fadeoutTime = sp_ctof(params[11]);
|
|
g_hud_params.r2 = 255;
|
|
g_hud_params.g2 = 255;
|
|
g_hud_params.b2 = 250;
|
|
g_hud_params.a2 = 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static cell_t SetHudTextParamsEx(IPluginContext *pContext, const cell_t *params)
|
|
{
|
|
cell_t *color1, *color2;
|
|
|
|
pContext->LocalToPhysAddr(params[4], &color1);
|
|
pContext->LocalToPhysAddr(params[5], &color2);
|
|
|
|
g_hud_params.x = sp_ctof(params[1]);
|
|
g_hud_params.y = sp_ctof(params[2]);
|
|
g_hud_params.holdTime = sp_ctof(params[3]);
|
|
g_hud_params.r1 = static_cast<byte>(color1[0]);
|
|
g_hud_params.g1 = static_cast<byte>(color1[1]);
|
|
g_hud_params.b1 = static_cast<byte>(color1[2]);
|
|
g_hud_params.a1 = static_cast<byte>(color1[3]);
|
|
g_hud_params.effect = params[6];
|
|
g_hud_params.fxTime = sp_ctof(params[7]);
|
|
g_hud_params.fadeinTime = sp_ctof(params[8]);
|
|
g_hud_params.fadeoutTime = sp_ctof(params[9]);
|
|
g_hud_params.r2 = static_cast<byte>(color2[0]);
|
|
g_hud_params.g2 = static_cast<byte>(color2[1]);
|
|
g_hud_params.b2 = static_cast<byte>(color2[2]);
|
|
g_hud_params.a2 = static_cast<byte>(color2[3]);
|
|
|
|
return 1;
|
|
}
|
|
|
|
void UTIL_SendHudText(int client, const hud_text_parms &textparms, const char *pMessage)
|
|
{
|
|
bf_write *bf;
|
|
cell_t players[1];
|
|
|
|
players[0] = client;
|
|
|
|
bf = g_UserMsgs.StartMessage(g_HudMsgNum, players, 1, 0);
|
|
bf->WriteByte(textparms.channel & 0xFF );
|
|
bf->WriteFloat(textparms.x);
|
|
bf->WriteFloat(textparms.y);
|
|
bf->WriteByte(textparms.r1);
|
|
bf->WriteByte(textparms.g1);
|
|
bf->WriteByte(textparms.b1);
|
|
bf->WriteByte(textparms.a1);
|
|
bf->WriteByte(textparms.r2);
|
|
bf->WriteByte(textparms.g2);
|
|
bf->WriteByte(textparms.b2);
|
|
bf->WriteByte(textparms.a2);
|
|
bf->WriteByte(textparms.effect);
|
|
bf->WriteFloat(textparms.fadeinTime);
|
|
bf->WriteFloat(textparms.fadeoutTime);
|
|
bf->WriteFloat(textparms.holdTime);
|
|
bf->WriteFloat(textparms.fxTime);
|
|
bf->WriteString(pMessage);
|
|
g_UserMsgs.EndMessage();
|
|
}
|
|
|
|
static cell_t ShowSyncHudText(IPluginContext *pContext, const cell_t *params)
|
|
{
|
|
int client;
|
|
Handle_t err;
|
|
CPlayer *pPlayer;
|
|
hud_syncobj_t *obj;
|
|
char message_buffer[255-36];
|
|
|
|
if (!s_HudMsgHelpers.IsSupported())
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if ((err = s_HudMsgHelpers.ReadHudSyncObj(params[2], pContext->GetIdentity(), &obj)) != HandleError_None)
|
|
{
|
|
return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[2], err);
|
|
}
|
|
|
|
client = params[1];
|
|
if ((pPlayer = g_Players.GetPlayerByIndex(client)) == NULL)
|
|
{
|
|
return pContext->ThrowNativeError("Invalid client index %d", client);
|
|
}
|
|
else if (!pPlayer->IsInGame())
|
|
{
|
|
return pContext->ThrowNativeError("Client %d is not in-game", client);
|
|
}
|
|
|
|
g_SourceMod.FormatString(message_buffer, sizeof(message_buffer), pContext, params, 3);
|
|
if (pContext->GetContext()->n_err != SP_ERROR_NONE)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
g_hud_params.channel = s_HudMsgHelpers.AutoSelectChannel(client, obj);
|
|
UTIL_SendHudText(client, g_hud_params, message_buffer);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static cell_t ClearSyncHud(IPluginContext *pContext, const cell_t *params)
|
|
{
|
|
int client;
|
|
int channel;
|
|
Handle_t err;
|
|
CPlayer *pPlayer;
|
|
hud_syncobj_t *obj;
|
|
|
|
if (!s_HudMsgHelpers.IsSupported())
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if ((err = s_HudMsgHelpers.ReadHudSyncObj(params[2], pContext->GetIdentity(), &obj)) != HandleError_None)
|
|
{
|
|
return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[2], err);
|
|
}
|
|
|
|
client = params[1];
|
|
if ((pPlayer = g_Players.GetPlayerByIndex(client)) == NULL)
|
|
{
|
|
return pContext->ThrowNativeError("Invalid client index %d", client);
|
|
}
|
|
else if (!pPlayer->IsInGame())
|
|
{
|
|
return pContext->ThrowNativeError("Client %d is not in-game", client);
|
|
}
|
|
|
|
if ((channel = s_HudMsgHelpers.TryReuseLastChannel(client, obj)) == -1)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
g_hud_params.channel = channel;
|
|
UTIL_SendHudText(client, g_hud_params, "");
|
|
|
|
return g_hud_params.channel;
|
|
}
|
|
|
|
static cell_t ShowHudText(IPluginContext *pContext, const cell_t *params)
|
|
{
|
|
int client;
|
|
CPlayer *pPlayer;
|
|
char message_buffer[255-36];
|
|
|
|
if (!s_HudMsgHelpers.IsSupported())
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
client = params[1];
|
|
if ((pPlayer = g_Players.GetPlayerByIndex(client)) == NULL)
|
|
{
|
|
return pContext->ThrowNativeError("Invalid client index %d", client);
|
|
}
|
|
else if (!pPlayer->IsInGame())
|
|
{
|
|
return pContext->ThrowNativeError("Client %d is not in-game", client);
|
|
}
|
|
|
|
g_SourceMod.FormatString(message_buffer, sizeof(message_buffer), pContext, params, 3);
|
|
if (pContext->GetContext()->n_err != SP_ERROR_NONE)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (params[2] == -1)
|
|
{
|
|
g_hud_params.channel = s_HudMsgHelpers.AutoSelectChannel(client);
|
|
}
|
|
else
|
|
{
|
|
g_hud_params.channel = params[2] % MAX_HUD_CHANNELS;
|
|
s_HudMsgHelpers.ManualSelectChannel(client, g_hud_params.channel);
|
|
}
|
|
|
|
UTIL_SendHudText(client, g_hud_params, message_buffer);
|
|
|
|
return g_hud_params.channel;
|
|
}
|
|
|
|
REGISTER_NATIVES(hudNatives)
|
|
{
|
|
{"ClearSyncHud", ClearSyncHud},
|
|
{"CreateHudSynchronizer", CreateHudSynchronizer},
|
|
{"SetHudTextParams", SetHudTextParams},
|
|
{"SetHudTextParamsEx", SetHudTextParamsEx},
|
|
{"ShowHudText", ShowHudText},
|
|
{"ShowSyncHudText", ShowSyncHudText},
|
|
{NULL, NULL},
|
|
};
|