api.h

/*
 * Copyright (c) 2016-2025 Vera Visions LLC.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
 
#define bool float
#define true 1
#define false 0
typedef float musictrack_t;
 
typedef struct
{
    string NameForNum(int ammoID);
    int NumForName(string ammoName);
    int MaxForName(string ammoName);
    int MaxForNum(int ammoID);
    
    int Count();
} ammoAPI_t;
 
ammoAPI_t ammo; 
typedef struct
{
    string GetString(string cvarName);
    int GetInteger(string cvarName);
    float GetFloat(string cvarName);
    bool GetBool(string cvarName);
    vector GetVector(string cvarName);
    void SetString(string cvarName, string setValue);
    void SetInteger(string cvarName, int setValue);
    void SetBool(string cvarName, bool setValue);
    void SetFloat(string cvarName, float setValue);
    void SetVector(string cvarName, vector setValue);
} cvarAPI_t;
 
cvarAPI_t cvars; 
typedef struct
{
    string GetString(string serverKey);
    int GetInteger(string serverKey);
    float GetFloat(string serverKey);
    bool GetBool(string serverKey);
    vector GetVector(string serverKey);
    void SetString(string serverKey, string setValue);
    void SetInteger(string serverKey, int setValue);
    void SetBool(string serverKey, bool setValue);
    void SetFloat(string serverKey, float setValue);
    void SetVector(string serverKey, vector setValue);
} serverinfoAPI_t;
 
serverinfoAPI_t serverinfo; 
typedef struct
{
    string GetString(entity clientEnt, string userKey);
    int GetInteger(entity clientEnt, string userKey);
    float GetFloat(entity clientEnt, string userKey);
    bool GetBool(entity clientEnt, string userKey);
    vector GetVector(entity clientEnt, string userKey);
    void SetString(entity clientEnt, string userKey, string setValue);
    void SetInteger(entity clientEnt, string userKey, int setValue);
    void SetBool(entity clientEnt, string userKey, bool setValue);
    void SetFloat(entity clientEnt, string userKey, float setValue);
    void SetVector(entity clientEnt, string userKey, vector setValue);
} userinfoAPI_t;
 
userinfoAPI_t userinfo; 
typedef struct
{
    string Type(string weaponDef);
    int StartAmmo(string weaponDef);
    int MaxAmmo(string weaponDef);
    bool IsSemiAuto(string weaponDef);
 
    string AmmoTypes(string weaponDef);
 
    string InventoryType(string weaponDef);
    float FireTime(string weaponDef);
    int ClipSize(string weaponDef);
    string Class(string weaponDef);
    bool IsClipOnly(string weaponDef);
    bool IsDetonationTimed(string weaponDef);
} weaponInfo_t;
 
weaponInfo_t weaponInfo; 
typedef struct
{
    int BestAutoJoinTeam(void);
    int TeamCount(void);
    int OpenTeamCount(void);
    vector Color(int teamID);
    string Name(int teamID);
    int Score(int teamID);
    string SpawnPoint(int teamID);
    int NumPlayers(int teamID);
    int NumAlivePlayers(int teamID);
    int NumDeadPlayers(int teamID);
    int TotalDeaths(int teamID);
    int TotalFrags(int teamID);
    bool Valid(int teamID);
    int Flags(int teamID);
 
    void AddScore(int teamID, int addedScore);
    void SetScore(int teamID, int scoreValue);
    void SetFlags(int teamID, int flagsField);
    entity RandomPlayer(int teamID);
 
 
    void SetUp(int teamID, string teamTitle, vector teamColor, bool openTeam);
 
 
    void AddClass(int teamID, string classType);
 
 
    int TotalClasses(int teamID);
 
    string ClassForIndex(int teamID, int classIndex);
 
    void SetSpawnPoint(int teamID, string spawnPointEntityClassname);
} teamAPI_t;
 
teamAPI_t teams; 
typedef struct
{
    string GetString(string defName, string keyName);
    int GetInteger(string defName, string keyName);
    float GetFloat(string defName, string keyName);
    bool GetBool(string defName, string keyName);
    vector GetVector(string defName, string keyName);
} entityDefAPI_t;
entityDefAPI_t entityDef; 
typedef struct
{
    float Model(string pathToModel);
 
    float Sound(string soundDef);
 
    musictrack_t Music(string musicTrack);
 
    float Particle(string particleEffect);
 
    bool Entity(string className);
 
    string SpriteFrame(string spritePath, float frameNum, float timeIntoFrame);
 
    string Material(string materialName);
} precacheAPI_t;
precacheAPI_t precache; 
typedef struct
{
    void Play(string soundDef, float level = 75, float pitch = 100, float volume = 100, float channel = CHAN_AUTO);
} soundAPI_t;
soundAPI_t soundKit; 
typedef struct
{
    bool AI(entity entityToCheck);
    bool Alive(entity entityToCheck);
    bool GodMode(entity entityToCheck);
    bool Client(entity entityToCheck);
    bool Player(entity entityToCheck);
    bool Sentient(entity entityToCheck);
    bool Bot(entity entityToCheck);
    bool Item(entity entityToCheck);
    bool Weapon(entity entityToCheck);
} isAPI_t;
isAPI_t is; 
typedef struct
{
    entity Item(entity lastItem);
 
 
    entity Weapon(entity lastWeapon);
 
 
    entity Actor(entity lastActor);
 
 
    entity Player(entity lastPlayer);
 
 
    entity NPC(entity lastNPC);
} nextAPI_t;
nextAPI_t next; 
typedef string decl; 
typedef struct
{
    decl New(void);
 
    string GetString(decl declHandle, string keyName);
    int GetInteger(decl declHandle, string keyName);
    float GetFloat(decl declHandle, string keyName);
    bool GetBool(decl declHandle, string keyName);
    vector GetVector(decl declHandle, string keyName);
 
    void AddKey(decl declHandle, string keyName, string setValue);
 
    void RemoveKey(decl declHandle, string keyName);
 
    void Delete(decl declHandle);
} declAPI_t;
 
declAPI_t declManager;  // end of shared
 
void
setorigin_safe(entity target, vector testorg)
{
    for (int i = 0; i < 16; i++) {
        tracebox(testorg, target.mins, target.maxs, testorg, MOVE_NORMAL, target);
 
        if (!trace_startsolid) {
            break;
        }
 
        testorg[2] += 1.0;
    }
 
    setorigin(target, testorg);
}
 
__variant
linkToSharedProgs(string funcName)
{
    static void empty(void)
    {
        print("Called unimplemented shared API call.\n");
        breakpoint();
    }
 
    float func = externvalue( 0, funcName);
 
    if (func) {
        return ((__variant)func);
    } else {
        return (empty);
    }
}
 
void
_shared_main(void)
{
    ammo.NameForNum = linkToSharedProgs("SHPF_ammo_NameForNum");
    ammo.NumForName = linkToSharedProgs("SHPF_ammo_NumForName");
    ammo.MaxForName = linkToSharedProgs("SHPF_ammo_MaxForName");
    ammo.MaxForNum = linkToSharedProgs("SHPF_ammo_MaxForNum");
    ammo.Count = linkToSharedProgs("SHPF_ammo_Count");
 
    cvars.SetString = linkToSharedProgs("SHPF_cvars_SetString");
    cvars.SetBool = linkToSharedProgs("SHPF_cvars_SetBool");
    cvars.SetInteger = linkToSharedProgs("SHPF_cvars_SetInteger");
    cvars.SetFloat = linkToSharedProgs("SHPF_cvars_SetFloat");
    cvars.SetVector = linkToSharedProgs("SHPF_cvars_SetVector");
    cvars.GetString = linkToSharedProgs("SHPF_cvars_GetString");
    cvars.GetInteger = linkToSharedProgs("SHPF_cvars_GetInteger");
    cvars.GetBool = linkToSharedProgs("SHPF_cvars_GetBool");
    cvars.GetFloat = linkToSharedProgs("SHPF_cvars_GetFloat");
    cvars.GetVector = linkToSharedProgs("SHPF_cvars_GetVector");
 
    declManager.New = linkToSharedProgs("SHPF_declManager_New");
    declManager.GetFloat = linkToSharedProgs("SHPF_declManager_GetFloat");
    declManager.GetString = linkToSharedProgs("SHPF_declManager_GetString");
    declManager.GetVector = linkToSharedProgs("SHPF_declManager_GetVector");
    declManager.GetBool = linkToSharedProgs("SHPF_declManager_GetBool");
    declManager.AddKey = linkToSharedProgs("SHPF_declManager_AddKey");
    declManager.RemoveKey = linkToSharedProgs("SHPF_declManager_RemoveKey");
    declManager.Delete = linkToSharedProgs("SHPF_declManager_Delete");
 
    userinfo.SetString = linkToSharedProgs("SHPF_userinfo_SetString");
    userinfo.SetBool = linkToSharedProgs("SHPF_userinfo_SetBool");
    userinfo.SetInteger = linkToSharedProgs("SHPF_userinfo_SetInteger");
    userinfo.SetFloat = linkToSharedProgs("SHPF_userinfo_SetFloat");
    userinfo.SetVector = linkToSharedProgs("SHPF_userinfo_SetVector");
    userinfo.GetString = linkToSharedProgs("SHPF_userinfo_GetString");
    userinfo.GetInteger = linkToSharedProgs("SHPF_userinfo_GetInteger");
    userinfo.GetBool = linkToSharedProgs("SHPF_userinfo_GetBool");
    userinfo.GetFloat = linkToSharedProgs("SHPF_userinfo_GetFloat");
    userinfo.GetVector = linkToSharedProgs("SHPF_userinfo_GetVector");
 
    serverinfo.SetString = linkToSharedProgs("SHPF_serverinfo_SetString");
    serverinfo.SetBool = linkToSharedProgs("SHPF_serverinfo_SetBool");
    serverinfo.SetInteger = linkToSharedProgs("SHPF_serverinfo_SetInteger");
    serverinfo.SetFloat = linkToSharedProgs("SHPF_serverinfo_SetFloat");
    serverinfo.SetVector = linkToSharedProgs("SHPF_serverinfo_SetVector");
    serverinfo.GetString = linkToSharedProgs("SHPF_serverinfo_GetString");
    serverinfo.GetInteger = linkToSharedProgs("SHPF_serverinfo_GetInteger");
    serverinfo.GetBool = linkToSharedProgs("SHPF_serverinfo_GetBool");
    serverinfo.GetFloat = linkToSharedProgs("SHPF_serverinfo_GetFloat");
    serverinfo.GetVector = linkToSharedProgs("SHPF_serverinfo_GetVector");
 
    teams.BestAutoJoinTeam = linkToSharedProgs("SHPF_teams_BestAutoJoinTeam");
    teams.TeamCount = linkToSharedProgs("SHPF_teams_TeamCount");
    teams.OpenTeamCount = linkToSharedProgs("SHPF_teams_OpenTeamCount");
    teams.Color = linkToSharedProgs("SHPF_teams_Color");
    teams.Name = linkToSharedProgs("SHPF_teams_Name");
    teams.Score = linkToSharedProgs("SHPF_teams_Score");
    teams.SpawnPoint = linkToSharedProgs("SHPF_teams_SpawnPoint");
    teams.NumPlayers = linkToSharedProgs("SHPF_teams_NumPlayers");
    teams.NumAlivePlayers = linkToSharedProgs("SHPF_teams_NumAlivePlayers");
    teams.NumDeadPlayers = linkToSharedProgs("SHPF_teams_NumDeadPlayers");
    teams.TotalDeaths = linkToSharedProgs("SHPF_teams_TotalDeaths");
    teams.TotalFrags = linkToSharedProgs("SHPF_teams_TotalFrags");
    teams.Valid = linkToSharedProgs("SHPF_teams_Valid");
    teams.RandomPlayer = linkToSharedProgs("SHPF_teams_RandomPlayer");
    teams.TotalClasses = linkToSharedProgs("SHPF_teams_TotalClasses");
    teams.ClassForIndex = linkToSharedProgs("SHPF_teams_ClassForIndex");
    teams.Flags = linkToSharedProgs("SHPF_teams_Flags");
 
    /* server */
    teams.AddScore = linkToSharedProgs("SHPF_teams_AddScore");
    teams.SetScore = linkToSharedProgs("SHPF_teams_SetScore");
    teams.SetFlags = linkToSharedProgs("SHPF_teams_SetFlags");
    teams.SetUp = linkToSharedProgs("SHPF_teams_SetUp");
    teams.AddClass = linkToSharedProgs("SHPF_teams_AddClass");
    teams.SetSpawnPoint = linkToSharedProgs("SHPF_teams_SetSpawnPoint");
 
    precache.Material = linkToSharedProgs("SHPF_precache_Material");
    precache.Model = linkToSharedProgs("SHPF_precache_Model");
    precache.Music = linkToSharedProgs("SHPF_precache_Music");
    precache.Sound = linkToSharedProgs("SHPF_precache_Sound");
    precache.Particle = linkToSharedProgs("SHPF_precache_Particle");
    precache.Entity = linkToSharedProgs("SHPF_precache_Entity");
    precache.SpriteFrame = linkToSharedProgs("SHPF_precache_SpriteFrame");
 
    soundKit.Play = linkToSharedProgs("SHPF_sounds_Play");
 
    weaponInfo.Type = linkToSharedProgs("SHPF_weaponInfo_Type");
    weaponInfo.StartAmmo = linkToSharedProgs("SHPF_weaponInfo_StartAmmo");
    weaponInfo.MaxAmmo = linkToSharedProgs("SHPF_weaponInfo_MaxAmmo");
    weaponInfo.AmmoTypes = linkToSharedProgs("SHPF_weaponInfo_AmmoTypes");
    weaponInfo.IsSemiAuto = linkToSharedProgs("SHPF_weaponInfo_IsSemiAuto");
    weaponInfo.InventoryType = linkToSharedProgs("SHPF_weaponInfo_InventoryType");
    weaponInfo.FireTime = linkToSharedProgs("SHPF_weaponInfo_FireTime");
    weaponInfo.ClipSize = linkToSharedProgs("SHPF_weaponInfo_ClipSize");
    weaponInfo.Class = linkToSharedProgs("SHPF_weaponInfo_Class");
    weaponInfo.IsClipOnly = linkToSharedProgs("SHPF_weaponInfo_IsClipOnly");
    weaponInfo.IsDetonationTimed = linkToSharedProgs("SHPF_weaponInfo_IsDetonationTimed");
 
    entityDef.GetString = linkToSharedProgs("SHPF_entityDef_GetString");
    entityDef.GetInteger = linkToSharedProgs("SHPF_entityDef_GetInteger");
    entityDef.GetBool = linkToSharedProgs("SHPF_entityDef_GetBool");
    entityDef.GetFloat = linkToSharedProgs("SHPF_entityDef_GetFloat");
    entityDef.GetVector = linkToSharedProgs("SHPF_entityDef_GetVector");
 
    is.AI = linkToSharedProgs("SHPF_is_AI");
    is.Bot = linkToSharedProgs("SHPF_is_Bot");
    is.Alive = linkToSharedProgs("SHPF_is_Alive");
    is.GodMode = linkToSharedProgs("SHPF_is_GodMode");
    is.Client = linkToSharedProgs("SHPF_is_Client");
    is.Player = linkToSharedProgs("SHPF_is_Player");
    is.Sentient = linkToSharedProgs("SHPF_is_Sentient");
    is.Item = linkToSharedProgs("SHPF_is_Item");
    is.Weapon = linkToSharedProgs("SHPF_is_Weapon");
 
    /* helpful finder */
    next.Actor = linkToSharedProgs("SHPF_next_Actor");
    next.Item = linkToSharedProgs("SHPF_next_Item");
    next.Weapon = linkToSharedProgs("SHPF_next_Weapon");
    next.Player = linkToSharedProgs("SHPF_next_Player");
    next.NPC = linkToSharedProgs("SHPF_next_NPC");
}