summaryrefslogtreecommitdiff
path: root/src/game/g_local.h
blob: 634f956c37af7c4dd64a645e3c254e1d9dd137f5 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
// Copyright (C) 1999-2000 Id Software, Inc.
//
// g_local.h -- local definitions for game module

/*
 *  Portions Copyright (C) 2000-2001 Tim Angus
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License as published by
 *  the Free Software Foundation; either version 2.1, 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 Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser 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.
 */

/*  To assertain which portions are licensed under the LGPL and which are
 *  licensed by Id Software, Inc. please run a diff between the equivalent
 *  versions of the "Tremulous" modification and the unmodified "Quake3"
 *  game source code.
 */
                  
#include "q_shared.h"
#include "bg_public.h"
#include "g_public.h"

//==================================================================

// the "gameversion" client command will print this plus compile date
#define GAMEVERSION "tremulous"

#define INFINITE      1000000

#define FRAMETIME     100         // msec
#define CARNAGE_REWARD_TIME 3000
#define REWARD_SPRITE_TIME  2000

#define INTERMISSION_DELAY_TIME 1000
#define SP_INTERMISSION_DELAY_TIME 5000

// gentity->flags
#define FL_GODMODE        0x00000010
#define FL_NOTARGET       0x00000020
#define FL_TEAMSLAVE      0x00000400  // not the first on the team
#define FL_NO_KNOCKBACK   0x00000800
#define FL_DROPPED_ITEM   0x00001000
#define FL_NO_BOTS        0x00002000  // spawn point not for bot use
#define FL_NO_HUMANS      0x00004000  // spawn point just for bots
#define FL_FORCE_GESTURE  0x00008000  // spawn point just for bots

// movers are things like doors, plats, buttons, etc
typedef enum {
  MOVER_POS1,
  MOVER_POS2,
  MOVER_1TO2,
  MOVER_2TO1
} moverState_t;

#define SP_PODIUM_MODEL   "models/mapobjects/podium/podium4.md3"

//============================================================================

typedef struct gentity_s gentity_t;
typedef struct gclient_s gclient_t;

struct gentity_s {
  entityState_t s;        // communicated by server to clients
  entityShared_t  r;        // shared by both the server system and game

  // DO NOT MODIFY ANYTHING ABOVE THIS, THE SERVER
  // EXPECTS THE FIELDS IN THAT ORDER!
  //================================

  struct gclient_s  *client;      // NULL if not a client

  qboolean  inuse;

  char    *classname;     // set in QuakeEd
  int     spawnflags;     // set in QuakeEd

  qboolean  neverFree;      // if true, FreeEntity will only unlink
                  // bodyque uses this

  int     flags;        // FL_* variables

  char    *model;
  char    *model2;
  int     freetime;     // level.time when the object was freed

  int     eventTime;      // events will be cleared EVENT_VALID_MSEC after set
  qboolean  freeAfterEvent;
  qboolean  unlinkAfterEvent;

  qboolean  physicsObject;    // if true, it can be pushed by movers and fall off edges
                  // all game items are physicsObjects,
  float   physicsBounce;    // 1.0 = continuous bounce, 0.0 = no bounce
  int     clipmask;     // brushes with this content value will be collided against
                  // when moving.  items and corpses do not collide against
                  // players, for instance

  // movers
  moverState_t moverState;
  int     soundPos1;
  int     sound1to2;
  int     sound2to1;
  int     soundPos2;
  int     soundLoop;
  gentity_t *parent;
  gentity_t *nextTrain;
  gentity_t *prevTrain;
  vec3_t    pos1, pos2;

  char    *message;

  int     timestamp;    // body queue sinking, etc

  float   angle;      // set in editor, -1 = up, -2 = down
  char    *target;
  char    *targetname;
  char    *team;
  char    *targetShaderName;
  char    *targetShaderNewName;
  gentity_t *target_ent;

  float   speed;
  vec3_t    movedir;

  //TA: acceleration evaluation
  qboolean  evaluateAcceleration;
  vec3_t    oldVelocity;
  vec3_t    acceleration;
  vec3_t    oldAccel;
  vec3_t    jerk;

  int     nextthink;
  void    (*think)(gentity_t *self);
  void    (*reached)(gentity_t *self);  // movers call this when hitting endpoint
  void    (*blocked)(gentity_t *self, gentity_t *other);
  void    (*touch)(gentity_t *self, gentity_t *other, trace_t *trace);
  void    (*use)(gentity_t *self, gentity_t *other, gentity_t *activator);
  void    (*pain)(gentity_t *self, gentity_t *attacker, int damage);
  void    (*die)(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod);

  int     pain_debounce_time;
  int     fly_sound_debounce_time;  // wind tunnel
  int     last_move_time;

  int     health;

  qboolean  takedamage;

  int     damage;
  int     splashDamage; // quad will increase this without increasing radius
  int     splashRadius;
  int     methodOfDeath;
  int     splashMethodOfDeath;

  int     count;

  gentity_t *chain;
  gentity_t *enemy;
  gentity_t *activator;
  gentity_t *teamchain;   // next entity in team
  gentity_t *teammaster;  // master of the team

  int     watertype;
  int     waterlevel;

  int     noise_index;

  // timing variables
  float   wait;
  float   random;

  gitem_t   *item;      // for bonus items

  int       biteam;       //TA: buildable item team
  gentity_t *parentNode;  //TA: for creep and defence/spawn dependencies
  qboolean  active;       //TA: for power repeater, but could be useful elsewhere
  qboolean  powered;      //TA: for human buildables
  int       builtBy;      //TA: clientNum of person that built this
  gentity_t *dccNode;     //TA: controlling dcc
  qboolean  dcced;        //TA: controlled by a dcc or not?

  int       credits[ MAX_CLIENTS ]; //TA: human credits for each client
  qboolean  creditsHash[ MAX_CLIENTS ]; //TA: track who has claimed credit
  int       killedBy;                   //TA: clientNum of killer

  gentity_t *targeted;    //TA: true if the player is currently a valid target of a turret

  vec4_t    animation;    //TA: animated map objects
};

typedef enum {
  CON_DISCONNECTED,
  CON_CONNECTING,
  CON_CONNECTED
} clientConnected_t;

typedef enum {
  SPECTATOR_NOT,
  SPECTATOR_FREE,
  SPECTATOR_LOCKED,
  SPECTATOR_FOLLOW,
  SPECTATOR_SCOREBOARD
} spectatorState_t;

typedef enum {
  TEAM_BEGIN,   // Beginning a team game, spawn at base
  TEAM_ACTIVE   // Now actively playing
} playerTeamStateState_t;

typedef struct {
  playerTeamStateState_t  state;

  int     location;

  int     captures;
  int     basedefense;
  int     carrierdefense;
  int     flagrecovery;
  int     fragcarrier;
  int     assists;

  float   lasthurtcarrier;
  float   lastreturnedflag;
  float   flagsince;
  float   lastfraggedcarrier;
} playerTeamState_t;

// the auto following clients don't follow a specific client
// number, but instead follow the first two active players
#define FOLLOW_ACTIVE1  -1
#define FOLLOW_ACTIVE2  -2

// client data that stays across multiple levels or tournament restarts
// this is achieved by writing all the data to cvar strings at game shutdown
// time and reading them back at connection time.  Anything added here
// MUST be dealt with in G_InitSessionData() / G_ReadSessionData() / G_WriteSessionData()
typedef struct {
  team_t    sessionTeam;
  int     spectatorTime;    // for determining next-in-line to play
  spectatorState_t  spectatorState;
  int     spectatorClient;  // for chasecam and follow mode
  int     wins, losses;   // tournament stats
  qboolean  teamLeader;     // true when this client is a team leader
} clientSession_t;

#define MAX_NETNAME       36
#define MAX_VOTE_COUNT    3

// client data that stays across multiple respawns, but is cleared
// on each level change or team change at ClientBegin()
typedef struct {
  clientConnected_t connected;
  usercmd_t cmd;        // we would lose angles if not persistant
  qboolean  localClient;    // true if "ip" info key is "localhost"
  qboolean  initialSpawn;   // the first spawn should be at a cool location
  qboolean  predictItemPickup;  // based on cg_predictItems userinfo
  qboolean  pmoveFixed;     //
  char    netname[ MAX_NETNAME ];
  int     maxHealth;      // for handicapping
  int     enterTime;      // level.time the client entered the game
  playerTeamState_t teamState;  // status in teamplay games
  int     voteCount;      // to prevent people from constantly calling votes
  int     teamVoteCount;    // to prevent people from constantly calling votes
  qboolean  teamInfo;     // send team overlay updates?

  int     pclass;   //TA: player class (copied to ent->client->ps.stats[ STAT_PCLASS ] once spawned)
                    //not really persistant.. this is just a nice place to stick it :)
  int     pitem;    //TA: humans have a starting item
  int     pteam;    //TA: player team (copied to ps.stats[ STAT_PTEAM ])
} clientPersistant_t;

// this structure is cleared on each ClientSpawn(),
// except for 'client->pers' and 'client->sess'
struct gclient_s {
  // ps MUST be the first element, because the server expects it
  playerState_t ps;       // communicated by server to clients

  // the rest of the structure is private to game
  clientPersistant_t  pers;
  clientSession_t   sess;

  qboolean  readyToExit;    // wishes to leave the intermission

  qboolean  noclip;

  int       lastCmdTime;    // level.time of last usercmd_t, for EF_CONNECTION
                    // we can't just use pers.lastCommand.time, because
                    // of the g_sycronousclients case
  int       buttons;
  int       oldbuttons;
  int       latched_buttons;

  vec3_t    oldOrigin;
  
  // sum up damage over an entire frame, so
  // shotgun blasts give a single big kick
  int       damage_armor;   // damage absorbed by armor
  int       damage_blood;   // damage taken out of health
  int       damage_knockback; // impact damage
  vec3_t    damage_from;    // origin for vector calculation
  qboolean  damage_fromWorld; // if true, don't use the damage_from vector

  int       accurateCount;    // for "impressive" reward sound
  int       accuracy_shots;   // total number of shots
  int       accuracy_hits;    // total number of hits
  //
  int       lastkilled_client;  // last client that this client killed
  int       lasthurt_client;  // last client that damaged this client
  int       lasthurt_mod;   // type of damage the client did

  // timers
  int       respawnTime;    // can respawn when time > this, force after g_forcerespwan
  int       inactivityTime;   // kick players when time > this
  qboolean  inactivityWarning;  // qtrue if the five seoond warning has been given
  int       rewardTime;     // clear the EF_AWARD_IMPRESSIVE, etc when time > this

  int       airOutTime;

  int       lastKillTime;   // for multiple kill rewards

  qboolean  fireHeld;     // used for hook
  qboolean  fire2Held;    // used for alt fire
  gentity_t *hook;        // grapple hook if out

  int       switchTeamTime;   // time the player switched teams

  gentity_t *torch;       //TA: torch entity ( NULL if switched off )

  // timeResidual is used to handle events that happen every second
  // like health / armor countdowns and regeneration
  //TA: two timers, one every 100 msecs, another every sec
  int       time100;
  int       time1000;

  char      *areabits;

  int       lastInfestTime; //TA: to keep track of how long infests take
  gentity_t *infestBody;  //TA: body that is being infested. must be persistant

  int       lastPoisonTime;
  int       lastGrabTime; //TA: yuck yuck hack urgh

  int       pouncePayload; //TA: amount of damage pounce attack will do
  qboolean  allowedToPounce;
};

#define MAX_LOCDAMAGE_TEXT    8192
#define MAX_LOCDAMAGE_REGIONS 32

//TA: store locational damage regions
typedef struct damageRegion_s
{
  float     minHeight, maxHeight;
  int       minAngle, maxAngle;
  
  float     modifier;

  qboolean  crouch;
} damageRegion_t;

#define MAX_ARMOUR_TEXT    8192
#define MAX_ARMOUR_REGIONS 32

//TA: store locational armour regions
typedef struct armourRegion_s
{
  float     minHeight, maxHeight;
  int       minAngle, maxAngle;
  
  float     modifier;

  qboolean  crouch;
} armourRegion_t;

//
// this structure is cleared as each map is entered
//
#define MAX_SPAWN_VARS      64
#define MAX_SPAWN_VARS_CHARS  4096

typedef struct {
  struct gclient_s  *clients;   // [maxclients]

  struct gentity_s  *gentities;
  int     gentitySize;
  int     num_entities;   // current number, <= MAX_GENTITIES

  int     warmupTime;     // restart match at this time

  fileHandle_t  logFile;

  // store latched cvars here that we want to get at often
  int     maxclients;

  int     framenum;
  int     time;         // in msec
  int     previousTime;     // so movers can back up when blocked

  int     startTime;        // level.time the map was started

  int     teamScores[TEAM_NUM_TEAMS];
  int     lastTeamLocationTime;   // last time of client team location update

  qboolean  newSession;       // don't use any old session data, because
                    // we changed gametype

  qboolean  restarted;        // waiting for a map_restart to fire

  int     numConnectedClients;
  int     numNonSpectatorClients; // includes connecting clients
  int     numPlayingClients;    // connected, non-spectators
  int     sortedClients[MAX_CLIENTS];   // sorted by score
  int     follow1, follow2;   // clientNums for auto-follow spectators

  int     snd_fry;        // sound index for standing in lava

  int     warmupModificationCount;  // for detecting if g_warmup is changed

  // voting state
  char    voteString[MAX_STRING_CHARS];
  char    voteDisplayString[MAX_STRING_CHARS];
  int     voteTime;       // level.time vote was called
  int     voteExecuteTime;    // time the vote is executed
  int     voteYes;
  int     voteNo;
  int     numVotingClients;   // set by CalculateRanks

  // team voting state
  char    teamVoteString[2][MAX_STRING_CHARS];
  int     teamVoteTime[2];    // level.time vote was called
  int     teamVoteYes[2];
  int     teamVoteNo[2];
  int     numteamVotingClients[2];// set by CalculateRanks

  // spawn variables
  qboolean  spawning;       // the G_Spawn*() functions are valid
  int     numSpawnVars;
  char    *spawnVars[MAX_SPAWN_VARS][2];  // key / value pairs
  int     numSpawnVarChars;
  char    spawnVarChars[MAX_SPAWN_VARS_CHARS];

  // intermission state
  int     intermissionQueued;   // intermission was qualified, but
                    // wait INTERMISSION_DELAY_TIME before
                    // actually going there so the last
                    // frag can be watched.  Disable future
                    // kills during this delay
  int     intermissiontime;   // time the intermission was started
  char    *changemap;
  qboolean  readyToExit;      // at least one client wants to exit
  int     exitTime;
  vec3_t    intermission_origin;  // also used for spectator spawns
  vec3_t    intermission_angle;

  qboolean  locationLinked;     // target_locations get linked
  gentity_t *locationHead;      // head of the location list

  //TA: extra stuff:
  int     numDroidSpawns;
  int     numHumanSpawns;
  
  int     numDroidClients;
  int     numHumanClients;
  
  int     numLiveDroidClients;
  int     numLiveHumanClients;
  
  int     droidBuildPoints;
  int     humanBuildPoints;
  int     humanBuildPointsPowered;
} level_locals_t;

//
// g_spawn.c
//
qboolean  G_SpawnString( const char *key, const char *defaultString, char **out );
// spawn string returns a temporary reference, you must CopyString() if you want to keep it
qboolean  G_SpawnFloat( const char *key, const char *defaultString, float *out );
qboolean  G_SpawnInt( const char *key, const char *defaultString, int *out );
qboolean  G_SpawnVector( const char *key, const char *defaultString, float *out );
void    G_SpawnEntitiesFromString( void );
char *G_NewString( const char *string );

//
// g_cmds.c
//
void Cmd_Score_f (gentity_t *ent);
void StopFollowing( gentity_t *ent );
void BroadcastTeamChange( gclient_t *client, int oldTeam );
void SetTeam( gentity_t *ent, char *s );
void Cmd_FollowCycle_f( gentity_t *ent, int dir );

//
// g_items.c
//
void G_CheckTeamItems( void );
void G_RunItem( gentity_t *ent );
void RespawnItem( gentity_t *ent );

void UseHoldableItem( gentity_t *ent );
void PrecacheItem (gitem_t *it);
gentity_t *Drop_Item( gentity_t *ent, gitem_t *item, float angle );
gentity_t *LaunchItem( gitem_t *item, vec3_t origin, vec3_t velocity );
void SetRespawn (gentity_t *ent, float delay);
void G_SpawnItem (gentity_t *ent, gitem_t *item);
void FinishSpawningItem( gentity_t *ent );
void Think_Weapon (gentity_t *ent);
int ArmorIndex (gentity_t *ent);
void  Add_Ammo (gentity_t *ent, int weapon, int count);
void Touch_Item (gentity_t *ent, gentity_t *other, trace_t *trace);

void ClearRegisteredItems( void );
void RegisterItem( gitem_t *item );
void SaveRegisteredItems( void );

//
// g_buildable.c
//
typedef enum
{
  IBE_NONE,
  
  IBE_NOROOM,
  IBE_NOCREEP,
  IBE_NOHIVEMIND,
  IBE_HIVEMIND,
  IBE_NOASSERT,
  IBE_SPWNWARN,
  IBE_REACTOR,
  IBE_REPEATER,
  IBE_RPLWARN,
  IBE_RPTWARN,
  IBE_NOPOWER,

  IBE_MAXERRORS
} itemBuildError_t;

itemBuildError_t  G_itemFits( gentity_t *ent, buildable_t buildable, int distance );
gentity_t         *G_buildItem( gentity_t *ent, buildable_t buildable, int distance, float speed );
void              G_setBuildableAnim( gentity_t *ent, buildableAnimNumber_t anim, qboolean force );
void              G_setIdleBuildableAnim( gentity_t *ent, buildableAnimNumber_t anim );

//
// g_utils.c
//
int G_ModelIndex( char *name );
int   G_SoundIndex( char *name );
void  G_TeamCommand( team_t team, char *cmd );
void  G_KillBox (gentity_t *ent);
gentity_t *G_Find (gentity_t *from, int fieldofs, const char *match);
gentity_t *G_PickTarget (char *targetname);
void  G_UseTargets (gentity_t *ent, gentity_t *activator);
void  G_SetMovedir ( vec3_t angles, vec3_t movedir);

void  G_InitGentity( gentity_t *e );
gentity_t *G_Spawn (void);
gentity_t *G_TempEntity( vec3_t origin, int event );
void  G_Sound( gentity_t *ent, int channel, int soundIndex );
void  G_FreeEntity( gentity_t *e );
qboolean  G_EntitiesFree( void );

void  G_TouchTriggers (gentity_t *ent);
void  G_TouchSolids (gentity_t *ent);

float *tv (float x, float y, float z);
char  *vtos( const vec3_t v );

float vectoyaw( const vec3_t vec );

void G_AddPredictableEvent( gentity_t *ent, int event, int eventParm );
void G_AddEvent( gentity_t *ent, int event, int eventParm );
void G_SetOrigin( gentity_t *ent, vec3_t origin );
void AddRemap(const char *oldShader, const char *newShader, float timeOffset);
const char *BuildShaderStateConfig();

//
// g_combat.c
//
qboolean CanDamage (gentity_t *targ, vec3_t origin);
void G_Damage (gentity_t *targ, gentity_t *inflictor, gentity_t *attacker, vec3_t dir, vec3_t point, int damage, int dflags, int mod);
void G_SelectiveDamage (gentity_t *targ, gentity_t *inflictor, gentity_t *attacker, vec3_t dir, vec3_t point, int damage, int dflags, int mod, int team);
qboolean G_RadiusDamage (vec3_t origin, gentity_t *attacker, float damage, float radius, gentity_t *ignore, int mod);
qboolean G_SelectiveRadiusDamage (vec3_t origin, gentity_t *attacker, float damage, float radius, gentity_t *ignore, int mod, int team );
void body_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath );
void TossClientItems( gentity_t *self );

//TA:
void G_InitDamageLocations( );

// damage flags
#define DAMAGE_RADIUS         0x00000001  // damage was indirect
#define DAMAGE_NO_ARMOR       0x00000002  // armour does not protect from this damage
#define DAMAGE_NO_KNOCKBACK   0x00000004  // do not affect velocity, just view angles
#define DAMAGE_NO_PROTECTION  0x00000008  // armor, shields, invulnerability, and godmode have no effect

//
// g_missile.c
//
void G_RunMissile( gentity_t *ent );

gentity_t *fire_blaster( gentity_t *self, vec3_t start, vec3_t aimdir );
gentity_t *fire_flamer( gentity_t *self, vec3_t start, vec3_t aimdir );
gentity_t *fire_plasma( gentity_t *self, vec3_t start, vec3_t aimdir );
gentity_t *fire_grenade( gentity_t *self, vec3_t start, vec3_t aimdir );
gentity_t *fire_rocket( gentity_t *self, vec3_t start, vec3_t dir );
gentity_t *fire_sawblade( gentity_t *self, vec3_t start, vec3_t dir );
gentity_t *fire_bfg( gentity_t *self, vec3_t start, vec3_t dir );
gentity_t *fire_grapple( gentity_t *self, vec3_t start, vec3_t dir );


//
// g_mover.c
//
void G_RunMover( gentity_t *ent );
void Touch_DoorTrigger( gentity_t *ent, gentity_t *other, trace_t *trace );

//
// g_trigger.c
//
void trigger_teleporter_touch (gentity_t *self, gentity_t *other, trace_t *trace );


//
// g_misc.c
//
void TeleportPlayer( gentity_t *player, vec3_t origin, vec3_t angles );
void ShineTorch( gentity_t *self );

//
// g_weapon.c
//
qboolean LogAccuracyHit( gentity_t *target, gentity_t *attacker );
void CalcMuzzlePoint( gentity_t *ent, vec3_t forward, vec3_t right, vec3_t up, vec3_t muzzlePoint );
void SnapVectorTowards( vec3_t v, vec3_t to );
qboolean CheckVenomAttack( gentity_t *ent );
qboolean CheckGrabAttack( gentity_t *ent );
qboolean CheckPounceAttack( gentity_t *ent );
void Weapon_HookFree (gentity_t *ent);
void Weapon_HookThink (gentity_t *ent);


//
// g_client.c
//
team_t TeamCount( int ignoreClientNum, int team );
int TeamLeader( int team );
team_t PickTeam( int ignoreClientNum );
void SetClientViewAngle( gentity_t *ent, vec3_t angle );
gentity_t *SelectSpawnPoint ( vec3_t avoidPoint, vec3_t origin, vec3_t angles );
void SpawnCorpse( gentity_t *ent );
void respawn (gentity_t *ent);
void BeginIntermission (void);
void InitClientPersistant (gclient_t *client);
void InitClientResp (gclient_t *client);
void InitBodyQue (void);
void ClientSpawn( gentity_t *ent, gentity_t *spawn );
void player_die (gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod);
void AddScore( gentity_t *ent, int score );

//TA: extra bits
void AddPoints( gentity_t *ent, int score );
int CalculatePoints( gentity_t *victim, gentity_t *attacker );

void CalculateRanks( void );
qboolean SpotWouldTelefrag( gentity_t *spot );

//
// g_svcmds.c
//
qboolean  ConsoleCommand( void );
void G_ProcessIPBans(void);
qboolean G_FilterPacket (char *from);

//
// g_weapon.c
//
void FireWeapon( gentity_t *ent );
void FireWeapon2( gentity_t *ent );

//
// p_hud.c
//
void MoveClientToIntermission (gentity_t *client);
void G_SetStats (gentity_t *ent);
void DeathmatchScoreboardMessage (gentity_t *client);

//
// g_cmds.c
//

//
// g_pweapon.c
//


//
// g_main.c
//
void FindIntermissionPoint( void );
void SetLeader(int team, int client);
void CheckTeamLeader( int team );
void G_RunThink (gentity_t *ent);
void QDECL G_LogPrintf( const char *fmt, ... );
void SendScoreboardMessageToAllClients( void );
void QDECL G_Printf( const char *fmt, ... );
void QDECL G_Error( const char *fmt, ... );

//
// g_client.c
//
char *ClientConnect( int clientNum, qboolean firstTime, qboolean isBot );
void ClientUserinfoChanged( int clientNum );
void ClientDisconnect( int clientNum );
void ClientBegin( int clientNum );
void ClientCommand( int clientNum );

//
// g_active.c
//
void ClientThink( int clientNum );
void ClientEndFrame( gentity_t *ent );
void G_RunClient( gentity_t *ent );

//
// g_team.c
//
qboolean OnSameTeam( gentity_t *ent1, gentity_t *ent2 );
void Team_CheckDroppedItem( gentity_t *dropped );

//
// g_mem.c
//
void *G_Alloc( int size );
void G_InitMemory( void );
void G_Free( void *ptr );
void G_DefragmentMemory( void );
void Svcmd_GameMem_f( void );

//
// g_session.c
//
void G_ReadSessionData( gclient_t *client );
void G_InitSessionData( gclient_t *client, char *userinfo );

void G_InitWorldSession( void );
void G_WriteSessionData( void );

//
// g_arenas.c
//
void UpdateTournamentInfo( void );
void SpawnModelsOnVictoryPads( void );
void Svcmd_AbortPodium_f( void );

//
// g_bot.c
//
/*void G_InitBots( qboolean restart );
char *G_GetBotInfoByNumber( int num );
char *G_GetBotInfoByName( const char *name );
void G_CheckBotSpawn( void );
void G_QueueBotBegin( int clientNum );
qboolean G_BotConnect( int clientNum, qboolean restart );
void Svcmd_AddBot_f( void );
void Svcmd_BotList_f( void );
void BotInterbreedEndMatch( void );*/

// ai_main.c

//some maxs
#define MAX_FILEPATH      144

//bot settings
/*typedef struct bot_settings_s
{
  char characterfile[MAX_FILEPATH];
  float skill;
  char team[MAX_FILEPATH];
} bot_settings_t;

int BotAISetup( int restart );
int BotAIShutdown( int restart );
int BotAILoadMap( int restart );
int BotAISetupClient( int client, bot_settings_t *settings );
int BotAIShutdownClient( int client );
int BotAIStartFrame( int time );*/


#include "g_team.h" // teamplay specific stuff


extern  level_locals_t  level;
extern  gentity_t   g_entities[MAX_GENTITIES];

#define FOFS(x) ((int)&(((gentity_t *)0)->x))

extern  vmCvar_t  g_gametype;
extern  vmCvar_t  g_dedicated;
extern  vmCvar_t  g_cheats;
extern  vmCvar_t  g_maxclients;     // allow this many total, including spectators
extern  vmCvar_t  g_maxGameClients;   // allow this many active
extern  vmCvar_t  g_restarted;

extern  vmCvar_t  g_dmflags;
extern  vmCvar_t  g_fraglimit;
extern  vmCvar_t  g_timelimit;
extern  vmCvar_t  g_capturelimit;
extern  vmCvar_t  g_friendlyFire;
extern  vmCvar_t  g_password;
extern  vmCvar_t  g_needpass;
extern  vmCvar_t  g_gravity;
extern  vmCvar_t  g_speed;
extern  vmCvar_t  g_knockback;
extern  vmCvar_t  g_quadfactor;
extern  vmCvar_t  g_forcerespawn;
extern  vmCvar_t  g_inactivity;
extern  vmCvar_t  g_debugMove;
extern  vmCvar_t  g_debugAlloc;
extern  vmCvar_t  g_debugDamage;
extern  vmCvar_t  g_weaponRespawn;
extern  vmCvar_t  g_weaponTeamRespawn;
extern  vmCvar_t  g_synchronousClients;
extern  vmCvar_t  g_motd;
extern  vmCvar_t  g_warmup;
extern  vmCvar_t  g_doWarmup;
extern  vmCvar_t  g_blood;
extern  vmCvar_t  g_allowVote;
extern  vmCvar_t  g_teamAutoJoin;
extern  vmCvar_t  g_teamForceBalance;
extern  vmCvar_t  g_banIPs;
extern  vmCvar_t  g_filterBan;
extern  vmCvar_t  g_smoothClients;
extern  vmCvar_t  pmove_fixed;
extern  vmCvar_t  pmove_msec;
extern  vmCvar_t  g_rankings;
extern  vmCvar_t  g_enableDust;
extern  vmCvar_t  g_enableBreath;
extern  vmCvar_t  g_singlePlayer;

extern  vmCvar_t  g_humanBuildPoints;
extern  vmCvar_t  g_droidBuildPoints;

void  trap_Printf( const char *fmt );
void  trap_Error( const char *fmt );
int   trap_Milliseconds( void );
int   trap_Argc( void );
void  trap_Argv( int n, char *buffer, int bufferLength );
void  trap_Args( char *buffer, int bufferLength );
int   trap_FS_FOpenFile( const char *qpath, fileHandle_t *f, fsMode_t mode );
void  trap_FS_Read( void *buffer, int len, fileHandle_t f );
void  trap_FS_Write( const void *buffer, int len, fileHandle_t f );
void  trap_FS_FCloseFile( fileHandle_t f );
int   trap_FS_GetFileList( const char *path, const char *extension, char *listbuf, int bufsize );
void  trap_SendConsoleCommand( int exec_when, const char *text );
void  trap_Cvar_Register( vmCvar_t *cvar, const char *var_name, const char *value, int flags );
void  trap_Cvar_Update( vmCvar_t *cvar );
void  trap_Cvar_Set( const char *var_name, const char *value );
int   trap_Cvar_VariableIntegerValue( const char *var_name );
float trap_Cvar_VariableValue( const char *var_name );
void  trap_Cvar_VariableStringBuffer( const char *var_name, char *buffer, int bufsize );
void  trap_LocateGameData( gentity_t *gEnts, int numGEntities, int sizeofGEntity_t, playerState_t *gameClients, int sizeofGameClient );
void  trap_DropClient( int clientNum, const char *reason );
void  trap_SendServerCommand( int clientNum, const char *text );
void  trap_SetConfigstring( int num, const char *string );
void  trap_GetConfigstring( int num, char *buffer, int bufferSize );
void  trap_GetUserinfo( int num, char *buffer, int bufferSize );
void  trap_SetUserinfo( int num, const char *buffer );
void  trap_GetServerinfo( char *buffer, int bufferSize );
void  trap_SetBrushModel( gentity_t *ent, const char *name );
void  trap_Trace( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentmask );
int   trap_PointContents( const vec3_t point, int passEntityNum );
qboolean trap_InPVS( const vec3_t p1, const vec3_t p2 );
qboolean trap_InPVSIgnorePortals( const vec3_t p1, const vec3_t p2 );
void  trap_AdjustAreaPortalState( gentity_t *ent, qboolean open );
qboolean trap_AreasConnected( int area1, int area2 );
void  trap_LinkEntity( gentity_t *ent );
void  trap_UnlinkEntity( gentity_t *ent );
int   trap_EntitiesInBox( const vec3_t mins, const vec3_t maxs, int *entityList, int maxcount );
qboolean trap_EntityContact( const vec3_t mins, const vec3_t maxs, const gentity_t *ent );
int   trap_BotAllocateClient( void );
void  trap_BotFreeClient( int clientNum );
void  trap_GetUsercmd( int clientNum, usercmd_t *cmd );
qboolean  trap_GetEntityToken( char *buffer, int bufferSize );

int   trap_DebugPolygonCreate(int color, int numPoints, vec3_t *points);
void  trap_DebugPolygonDelete(int id);

int   trap_BotLibSetup( void );
int   trap_BotLibShutdown( void );
int   trap_BotLibVarSet(char *var_name, char *value);
int   trap_BotLibVarGet(char *var_name, char *value, int size);
int   trap_BotLibDefine(char *string);
int   trap_BotLibStartFrame(float time);
int   trap_BotLibLoadMap(const char *mapname);
int   trap_BotLibUpdateEntity(int ent, void /* struct bot_updateentity_s */ *bue);
int   trap_BotLibTest(int parm0, char *parm1, vec3_t parm2, vec3_t parm3);

int   trap_BotGetSnapshotEntity( int clientNum, int sequence );
int   trap_BotGetServerCommand(int clientNum, char *message, int size);
void  trap_BotUserCommand(int client, usercmd_t *ucmd);

int   trap_AAS_BBoxAreas(vec3_t absmins, vec3_t absmaxs, int *areas, int maxareas);
int   trap_AAS_AreaInfo( int areanum, void /* struct aas_areainfo_s */ *info );
void    trap_AAS_EntityInfo(int entnum, void /* struct aas_entityinfo_s */ *info);

int     trap_AAS_Initialized(void);
void    trap_AAS_PresenceTypeBoundingBox(int presencetype, vec3_t mins, vec3_t maxs);
float   trap_AAS_Time(void);

int     trap_AAS_PointAreaNum(vec3_t point);
int   trap_AAS_PointReachabilityAreaIndex(vec3_t point);
int     trap_AAS_TraceAreas(vec3_t start, vec3_t end, int *areas, vec3_t *points, int maxareas);

int     trap_AAS_PointContents(vec3_t point);
int     trap_AAS_NextBSPEntity(int ent);
int     trap_AAS_ValueForBSPEpairKey(int ent, char *key, char *value, int size);
int     trap_AAS_VectorForBSPEpairKey(int ent, char *key, vec3_t v);
int     trap_AAS_FloatForBSPEpairKey(int ent, char *key, float *value);
int     trap_AAS_IntForBSPEpairKey(int ent, char *key, int *value);

int     trap_AAS_AreaReachability(int areanum);

int     trap_AAS_AreaTravelTimeToGoalArea(int areanum, vec3_t origin, int goalareanum, int travelflags);
int   trap_AAS_EnableRoutingArea( int areanum, int enable );
int   trap_AAS_PredictRoute(void /*struct aas_predictroute_s*/ *route, int areanum, vec3_t origin,
        int goalareanum, int travelflags, int maxareas, int maxtime,
        int stopevent, int stopcontents, int stoptfl, int stopareanum);

int   trap_AAS_AlternativeRouteGoals(vec3_t start, int startareanum, vec3_t goal, int goalareanum, int travelflags,
        void /*struct aas_altroutegoal_s*/ *altroutegoals, int maxaltroutegoals,
        int type);

int     trap_AAS_Swimming(vec3_t origin);
int     trap_AAS_PredictClientMovement(void /* aas_clientmove_s */ *move, int entnum, vec3_t origin, int presencetype, int onground, vec3_t velocity, vec3_t cmdmove, int cmdframes, int maxframes, float frametime, int stopevent, int stopareanum, int visualize);


void  trap_EA_Say(int client, char *str);
void  trap_EA_SayTeam(int client, char *str);
void  trap_EA_Command(int client, char *command);

void  trap_EA_Action(int client, int action);
void  trap_EA_Gesture(int client);

void  trap_EA_Talk(int client);
void  trap_EA_Attack(int client);
void  trap_EA_Use(int client);
void  trap_EA_Respawn(int client);
void  trap_EA_Crouch(int client);
void  trap_EA_MoveUp(int client);
void  trap_EA_MoveDown(int client);
void  trap_EA_MoveForward(int client);
void  trap_EA_MoveBack(int client);
void  trap_EA_MoveLeft(int client);
void  trap_EA_MoveRight(int client);
void  trap_EA_SelectWeapon(int client, int weapon);
void  trap_EA_Jump(int client);
void  trap_EA_DelayedJump(int client);
void  trap_EA_Move(int client, vec3_t dir, float speed);
void  trap_EA_View(int client, vec3_t viewangles);

void  trap_EA_EndRegular(int client, float thinktime);
void  trap_EA_GetInput(int client, float thinktime, void /* struct bot_input_s */ *input);
void  trap_EA_ResetInput(int client);


int   trap_BotLoadCharacter(char *charfile, float skill);
void  trap_BotFreeCharacter(int character);
float trap_Characteristic_Float(int character, int index);
float trap_Characteristic_BFloat(int character, int index, float min, float max);
int   trap_Characteristic_Integer(int character, int index);
int   trap_Characteristic_BInteger(int character, int index, int min, int max);
void  trap_Characteristic_String(int character, int index, char *buf, int size);

int   trap_BotAllocChatState(void);
void  trap_BotFreeChatState(int handle);
void  trap_BotQueueConsoleMessage(int chatstate, int type, char *message);
void  trap_BotRemoveConsoleMessage(int chatstate, int handle);
int   trap_BotNextConsoleMessage(int chatstate, void /* struct bot_consolemessage_s */ *cm);
int   trap_BotNumConsoleMessages(int chatstate);
void  trap_BotInitialChat(int chatstate, char *type, int mcontext, char *var0, char *var1, char *var2, char *var3, char *var4, char *var5, char *var6, char *var7 );
int   trap_BotNumInitialChats(int chatstate, char *type);
int   trap_BotReplyChat(int chatstate, char *message, int mcontext, int vcontext, char *var0, char *var1, char *var2, char *var3, char *var4, char *var5, char *var6, char *var7 );
int   trap_BotChatLength(int chatstate);
void  trap_BotEnterChat(int chatstate, int client, int sendto);
void  trap_BotGetChatMessage(int chatstate, char *buf, int size);
int   trap_StringContains(char *str1, char *str2, int casesensitive);
int   trap_BotFindMatch(char *str, void /* struct bot_match_s */ *match, unsigned long int context);
void  trap_BotMatchVariable(void /* struct bot_match_s */ *match, int variable, char *buf, int size);
void  trap_UnifyWhiteSpaces(char *string);
void  trap_BotReplaceSynonyms(char *string, unsigned long int context);
int   trap_BotLoadChatFile(int chatstate, char *chatfile, char *chatname);
void  trap_BotSetChatGender(int chatstate, int gender);
void  trap_BotSetChatName(int chatstate, char *name, int client);
void  trap_BotResetGoalState(int goalstate);
void  trap_BotRemoveFromAvoidGoals(int goalstate, int number);
void  trap_BotResetAvoidGoals(int goalstate);
void  trap_BotPushGoal(int goalstate, void /* struct bot_goal_s */ *goal);
void  trap_BotPopGoal(int goalstate);
void  trap_BotEmptyGoalStack(int goalstate);
void  trap_BotDumpAvoidGoals(int goalstate);
void  trap_BotDumpGoalStack(int goalstate);
void  trap_BotGoalName(int number, char *name, int size);
int   trap_BotGetTopGoal(int goalstate, void /* struct bot_goal_s */ *goal);
int   trap_BotGetSecondGoal(int goalstate, void /* struct bot_goal_s */ *goal);
int   trap_BotChooseLTGItem(int goalstate, vec3_t origin, int *inventory, int travelflags);
int   trap_BotChooseNBGItem(int goalstate, vec3_t origin, int *inventory, int travelflags, void /* struct bot_goal_s */ *ltg, float maxtime);
int   trap_BotTouchingGoal(vec3_t origin, void /* struct bot_goal_s */ *goal);
int   trap_BotItemGoalInVisButNotVisible(int viewer, vec3_t eye, vec3_t viewangles, void /* struct bot_goal_s */ *goal);
int   trap_BotGetNextCampSpotGoal(int num, void /* struct bot_goal_s */ *goal);
int   trap_BotGetMapLocationGoal(char *name, void /* struct bot_goal_s */ *goal);
int   trap_BotGetLevelItemGoal(int index, char *classname, void /* struct bot_goal_s */ *goal);
float trap_BotAvoidGoalTime(int goalstate, int number);
void  trap_BotSetAvoidGoalTime(int goalstate, int number, float avoidtime);
void  trap_BotInitLevelItems(void);
void  trap_BotUpdateEntityItems(void);
int   trap_BotLoadItemWeights(int goalstate, char *filename);
void  trap_BotFreeItemWeights(int goalstate);
void  trap_BotInterbreedGoalFuzzyLogic(int parent1, int parent2, int child);
void  trap_BotSaveGoalFuzzyLogic(int goalstate, char *filename);
void  trap_BotMutateGoalFuzzyLogic(int goalstate, float range);
int   trap_BotAllocGoalState(int state);
void  trap_BotFreeGoalState(int handle);

void  trap_BotResetMoveState(int movestate);
void  trap_BotMoveToGoal(void /* struct bot_moveresult_s */ *result, int movestate, void /* struct bot_goal_s */ *goal, int travelflags);
int   trap_BotMoveInDirection(int movestate, vec3_t dir, float speed, int type);
void  trap_BotResetAvoidReach(int movestate);
void  trap_BotResetLastAvoidReach(int movestate);
int   trap_BotReachabilityArea(vec3_t origin, int testground);
int   trap_BotMovementViewTarget(int movestate, void /* struct bot_goal_s */ *goal, int travelflags, float lookahead, vec3_t target);
int   trap_BotPredictVisiblePosition(vec3_t origin, int areanum, void /* struct bot_goal_s */ *goal, int travelflags, vec3_t target);
int   trap_BotAllocMoveState(void);
void  trap_BotFreeMoveState(int handle);
void  trap_BotInitMoveState(int handle, void /* struct bot_initmove_s */ *initmove);
void  trap_BotAddAvoidSpot(int movestate, vec3_t origin, float radius, int type);

int   trap_BotChooseBestFightWeapon(int weaponstate, int *inventory);
void  trap_BotGetWeaponInfo(int weaponstate, int weapon, void /* struct weaponinfo_s */ *weaponinfo);
int   trap_BotLoadWeaponWeights(int weaponstate, char *filename);
int   trap_BotAllocWeaponState(void);
void  trap_BotFreeWeaponState(int weaponstate);
void  trap_BotResetWeaponState(int weaponstate);

int   trap_GeneticParentsAndChildSelection(int numranks, float *ranks, int *parent1, int *parent2, int *child);

void  trap_SnapVector( float *v );