game.h

Go to the documentation of this file.

/*
All original material Copyright (C) 2002-2010 UFO: Alien Invasion.

Original file from Quake 2 v3.21: quake2-2.31/game/game.h
Copyright (C) 1997-2001 Id Software, Inc.

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 2
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, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#ifndef GAME_GAME_H
#define GAME_GAME_H

#include "../shared/defines.h"
#include "../shared/typedefs.h"
#include "../common/tracing.h"
#include "../common/cvar.h"

#define GAME_API_VERSION    8

typedef enum {
    SOLID_NOT,                  
    SOLID_TRIGGER,              
    SOLID_BBOX,                 
    SOLID_BSP                   
} solid_t;

/*=============================================================== */

typedef struct edict_s edict_t;
typedef struct player_s player_t;


#ifndef GAME_INCLUDE

struct player_s {
    qboolean inuse;
    int num;                    
    qboolean isReady;

};

struct edict_s {
    qboolean inuse;
    int linkcount;      
    int number;         
    vec3_t origin;      
    vec3_t angles;      
    solid_t solid;

    vec3_t mins, maxs; 
    vec3_t absmin, absmax; 
    vec3_t size;

    edict_t *child; 
    edict_t *owner; 
    int modelindex; 
};


#endif  /* GAME_INCLUDE */

/*=============================================================== */

typedef struct {
    /* client/server information */
    int seed; 
    csi_t *csi;
    routing_t *routingMap;  
    /* special messages */

    void (IMPORT *BroadcastPrintf) (int printlevel, const char *fmt, ...) __attribute__((format(printf, 2, 3)));
    void (IMPORT *DPrintf) (const char *fmt, ...) __attribute__((format(printf, 1, 2)));
    void (IMPORT *PlayerPrintf) (const player_t * player, int printlevel, const char *fmt, va_list ap);

    void (IMPORT *PositionedSound) (int mask, const vec3_t origin, const edict_t *ent, const char *sound);

    void (IMPORT *ConfigString) (int num, const char *fmt, ...) __attribute__((format(printf, 2, 3)));

    void (IMPORT *Error) (const char *fmt, ...) __attribute__((noreturn, format(printf, 1, 2)));

    int (IMPORT *ModelIndex) (const char *name);

    void (IMPORT *SetInlineModelOrientation) (const char *name, const vec3_t origin, const vec3_t angles);

    void (IMPORT *SetModel) (edict_t * ent, const char *name);

    trace_t (IMPORT *Trace) (const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, const edict_t * passent, int contentmask);

    int (IMPORT *PointContents) (vec3_t point);
    const char* (IMPORT *GetFootstepSound) (const char* texture);
    float (IMPORT *GetBounceFraction) (const char *texture);
    qboolean (IMPORT *LoadModelMinsMaxs) (const char *model, int frame, vec3_t mins, vec3_t maxs);

    void (IMPORT *LinkEdict) (edict_t * ent);
    void (IMPORT *UnlinkEdict) (edict_t * ent);
    int (IMPORT *BoxEdicts) (const vec3_t mins, const vec3_t maxs, edict_t **list, int maxcount);
    int (IMPORT *TouchEdicts) (const vec3_t mins, const vec3_t maxs, edict_t **list, int maxcount, edict_t *skip);

    qboolean (IMPORT *TestLine) (const vec3_t start, const vec3_t stop, const int levelmask);
    qboolean (IMPORT *TestLineWithEnt) (const vec3_t start, const vec3_t stop, const int levelmask, const char **entlist);
    float (IMPORT *GrenadeTarget) (const vec3_t from, const vec3_t at, float speed, qboolean launched, qboolean rolled, vec3_t v0);

    void (IMPORT *MoveCalc) (const routing_t * map, actorSizeEnum_t actorSize, pathing_t * path, const pos3_t from, byte crouchingState, int distance, pos_t ** forbiddenList, int forbiddenListLength);
    void (IMPORT *MoveStore) (pathing_t * path);
    pos_t (IMPORT *MoveLength) (const pathing_t * path, const pos3_t to, byte crouchingState, qboolean stored);
    int (IMPORT *MoveNext) (const pathing_t *path, const pos3_t from, byte crouchingState);
    int (IMPORT *GridFloor) (const routing_t * map, actorSizeEnum_t actorSize, const pos3_t pos);
    int (IMPORT *GetTUsForDirection) (int dir);
    pos_t (IMPORT *GridFall) (const routing_t * map, actorSizeEnum_t actorSize, const pos3_t pos);
    void (IMPORT *GridPosToVec) (const routing_t * map, actorSizeEnum_t actorSize, const pos3_t pos, vec3_t vec);
    void (IMPORT *GridRecalcRouting) (routing_t * map, const char *name, const char **list);

    /* filesystem functions */
    const char *(IMPORT *FS_Gamedir) (void);
    int (IMPORT *FS_LoadFile) (const char *path, byte **buffer);
    void (IMPORT *FS_FreeFile) (void *buffer);

    /* network messaging (writing) */
    void (IMPORT *WriteChar) (char c);

    void (IMPORT *WriteByte) (byte c);
    byte* (IMPORT *WriteDummyByte) (byte c);
    void (IMPORT *WriteShort) (int c);

    void (IMPORT *WriteLong) (int c);
    void (IMPORT *WriteString) (const char *s);
    void (IMPORT *WritePos) (const vec3_t pos); 
    void (IMPORT *WriteGPos) (const pos3_t pos);
    void (IMPORT *WriteDir) (const vec3_t pos); 
    void (IMPORT *WriteAngle) (float f);
    void (IMPORT *WriteFormat) (const char *format, ...);

    void (IMPORT *AbortEvents) (void);
    void (IMPORT *EndEvents) (void);
    void (IMPORT *AddEvent) (unsigned int mask, int eType);
    int (IMPORT *GetEvent) (void);

    /* network messaging (reading) */
    int (IMPORT *ReadChar) (void);
    int (IMPORT *ReadByte) (void);
    int (IMPORT *ReadShort) (void);
    int (IMPORT *ReadLong) (void);
    int (IMPORT *ReadString) (char *str, size_t length);
    void (IMPORT *ReadPos) (vec3_t pos);
    void (IMPORT *ReadGPos) (pos3_t pos);
    void (IMPORT *ReadDir) (vec3_t vector);
    float (IMPORT *ReadAngle) (void);
    void (IMPORT *ReadData) (void *buffer, int size);
    void (IMPORT *ReadFormat) (const char *format, ...);

    qboolean (IMPORT *GetConstInt) (const char *name, int *value);
    qboolean (IMPORT *GetConstIntFromNamespace) (const char *space, const char *name, int *value);
    const char* (IMPORT *GetConstVariable) (const char *space, int value);
    void (IMPORT *RegisterConstInt) (const char *name, int value);
    qboolean (IMPORT *UnregisterConstVariable) (const char *name);

    /* misc functions */
    void (IMPORT *GetCharacterValues) (const char *teamDefinition, character_t *chr);

    /* managed memory allocation */
    void *(IMPORT *TagMalloc) (int size, int tag, const char *file, int line);
    void (IMPORT *TagFree) (void *block, const char *file, int line);
    void (IMPORT *FreeTags) (int tag, const char *file, int line);

    /* console variable interaction */
    cvar_t *(IMPORT *Cvar_Get) (const char *varName, const char *value, int flags, const char* desc);
    cvar_t *(IMPORT *Cvar_Set) (const char *varName, const char *value);
    const char *(IMPORT *Cvar_String) (const char *varName);

    /* ClientCommand and ServerCommand parameter access */
    int (IMPORT *Cmd_Argc) (void);
    const char *(IMPORT *Cmd_Argv) (int n);
    const char *(IMPORT *Cmd_Args) (void);      
    void (IMPORT *AddCommandString) (const char *text);
} game_import_t;

typedef struct {
    int apiversion;

    void (EXPORT *Init) (void);
    void (EXPORT *Shutdown) (void);

    /* each new level entered will cause a call to G_SpawnEntities */
    void (EXPORT *SpawnEntities) (const char *mapname, qboolean day, const char *entstring);

    qboolean (EXPORT *ClientConnect) (player_t * client, char *userinfo, size_t userinfoSize);
    qboolean (EXPORT *ClientBegin) (player_t * client);
    void (EXPORT *ClientSpawn) (player_t * client);
    void (EXPORT *ClientUserinfoChanged) (player_t * client, char *userinfo);
    void (EXPORT *ClientDisconnect) (player_t * client);
    void (EXPORT *ClientCommand) (player_t * client);

    int (EXPORT *ClientAction) (player_t * client);
    void (EXPORT *ClientEndRound) (player_t * client);
    void (EXPORT *ClientTeamInfo) (const player_t * client);
    void (EXPORT *ClientInitActorStates) (const player_t * client);
    int (EXPORT *ClientGetTeamNum) (const player_t * client);
    int (EXPORT *ClientGetTeamNumPref) (const player_t * client);
    qboolean (EXPORT *ClientIsReady) (const player_t * client);

    int (EXPORT *ClientGetActiveTeam) (void);
    const char* (EXPORT *ClientGetName) (int pnum);

    qboolean (EXPORT *RunFrame) (void);

    void (EXPORT *ServerCommand) (void);

    /* global variables shared between game and server */

    /* The edict array is allocated in the game dll so it */
    /* can vary in size from one game to another. */

    struct edict_s *edicts;
    int edict_size;
    int num_edicts;             
    int max_edicts;

    struct player_s *players;
    int player_size;
    int maxplayersperteam;
} game_export_t;

game_export_t *GetGameAPI(game_import_t * import);

#endif /* GAME_GAME_H */