/
shareddefs.h
954 lines (794 loc) · 32.6 KB
/
shareddefs.h
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
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Definitions that are shared by the game DLL and the client DLL.
//
// $NoKeywords: $
//=============================================================================//
#ifndef SHAREDDEFS_H
#define SHAREDDEFS_H
#ifdef _WIN32
#pragma once
#endif
#define TICK_INTERVAL (gpGlobals->interval_per_tick)
#define TIME_TO_TICKS( dt ) ( (int)( 0.5f + (float)(dt) / TICK_INTERVAL ) )
#define TICKS_TO_TIME( t ) ( TICK_INTERVAL *( t ) )
#define ROUND_TO_TICKS( t ) ( TICK_INTERVAL * TIME_TO_TICKS( t ) )
#define TICK_NEVER_THINK (-1)
#if defined( TF_DLL )
#define ANIMATION_CYCLE_BITS 10
#else
#define ANIMATION_CYCLE_BITS 15
#endif
#define ANIMATION_CYCLE_MINFRAC (1.0f / (1<<ANIMATION_CYCLE_BITS))
// Each mod defines these for itself.
class CViewVectors
{
public:
CViewVectors() {}
CViewVectors(
Vector vView,
Vector vHullMin,
Vector vHullMax,
Vector vDuckHullMin,
Vector vDuckHullMax,
Vector vDuckView,
Vector vObsHullMin,
Vector vObsHullMax,
Vector vDeadViewHeight )
{
m_vView = vView;
m_vHullMin = vHullMin;
m_vHullMax = vHullMax;
m_vDuckHullMin = vDuckHullMin;
m_vDuckHullMax = vDuckHullMax;
m_vDuckView = vDuckView;
m_vObsHullMin = vObsHullMin;
m_vObsHullMax = vObsHullMax;
m_vDeadViewHeight = vDeadViewHeight;
}
// Height above entity position where the viewer's eye is.
Vector m_vView;
Vector m_vHullMin;
Vector m_vHullMax;
Vector m_vDuckHullMin;
Vector m_vDuckHullMax;
Vector m_vDuckView;
Vector m_vObsHullMin;
Vector m_vObsHullMax;
Vector m_vDeadViewHeight;
};
// Height above entity position where the viewer's eye is.
#define VEC_VIEW g_pGameRules->GetViewVectors()->m_vView
#define VEC_HULL_MIN g_pGameRules->GetViewVectors()->m_vHullMin
#define VEC_HULL_MAX g_pGameRules->GetViewVectors()->m_vHullMax
#define VEC_DUCK_HULL_MIN g_pGameRules->GetViewVectors()->m_vDuckHullMin
#define VEC_DUCK_HULL_MAX g_pGameRules->GetViewVectors()->m_vDuckHullMax
#define VEC_DUCK_VIEW g_pGameRules->GetViewVectors()->m_vDuckView
#define VEC_OBS_HULL_MIN g_pGameRules->GetViewVectors()->m_vObsHullMin
#define VEC_OBS_HULL_MAX g_pGameRules->GetViewVectors()->m_vObsHullMax
#define VEC_DEAD_VIEWHEIGHT g_pGameRules->GetViewVectors()->m_vDeadViewHeight
// If the player (enemy bots) are scaled, adjust the hull
#define VEC_VIEW_SCALED( player ) ( g_pGameRules->GetViewVectors()->m_vView * player->GetModelScale() )
#define VEC_HULL_MIN_SCALED( player ) ( g_pGameRules->GetViewVectors()->m_vHullMin * player->GetModelScale() )
#define VEC_HULL_MAX_SCALED( player ) ( g_pGameRules->GetViewVectors()->m_vHullMax * player->GetModelScale() )
#define VEC_DUCK_HULL_MIN_SCALED( player ) ( g_pGameRules->GetViewVectors()->m_vDuckHullMin * player->GetModelScale() )
#define VEC_DUCK_HULL_MAX_SCALED( player ) ( g_pGameRules->GetViewVectors()->m_vDuckHullMax * player->GetModelScale() )
#define VEC_DUCK_VIEW_SCALED( player ) ( g_pGameRules->GetViewVectors()->m_vDuckView * player->GetModelScale() )
#define VEC_OBS_HULL_MIN_SCALED( player ) ( g_pGameRules->GetViewVectors()->m_vObsHullMin * player->GetModelScale() )
#define VEC_OBS_HULL_MAX_SCALED( player ) ( g_pGameRules->GetViewVectors()->m_vObsHullMax * player->GetModelScale() )
#define VEC_DEAD_VIEWHEIGHT_SCALED( player ) ( g_pGameRules->GetViewVectors()->m_vDeadViewHeight * player->GetModelScale() )
#define WATERJUMP_HEIGHT 8
#define MAX_CLIMB_SPEED 200
#if defined(TF_DLL) || defined(TF_CLIENT_DLL)
#define TIME_TO_DUCK 0.2
#define TIME_TO_DUCK_MS 200.0f
#else
#define TIME_TO_DUCK 0.4
#define TIME_TO_DUCK_MS 400.0f
#endif
#define TIME_TO_UNDUCK 0.2
#define TIME_TO_UNDUCK_MS 200.0f
#define MAX_WEAPON_SLOTS 6 // hud item selection slots
#define MAX_WEAPON_POSITIONS 20 // max number of items within a slot
#define MAX_ITEM_TYPES 6 // hud item selection slots
#define MAX_WEAPONS 48 // Max number of weapons available
#define MAX_ITEMS 5 // hard coded item types
#define WEAPON_NOCLIP -1 // clip sizes set to this tell the weapon it doesn't use a clip
#define MAX_AMMO_TYPES 32 // ???
#define MAX_AMMO_SLOTS 32 // not really slots
#define HUD_PRINTNOTIFY 1
#define HUD_PRINTCONSOLE 2
#define HUD_PRINTTALK 3
#define HUD_PRINTCENTER 4
// Vote creation or processing failure codes
typedef enum
{
VOTE_FAILED_GENERIC = 0,
VOTE_FAILED_TRANSITIONING_PLAYERS,
VOTE_FAILED_RATE_EXCEEDED,
VOTE_FAILED_YES_MUST_EXCEED_NO,
VOTE_FAILED_QUORUM_FAILURE,
VOTE_FAILED_ISSUE_DISABLED,
VOTE_FAILED_MAP_NOT_FOUND,
VOTE_FAILED_MAP_NAME_REQUIRED,
VOTE_FAILED_ON_COOLDOWN,
VOTE_FAILED_TEAM_CANT_CALL,
VOTE_FAILED_WAITINGFORPLAYERS,
VOTE_FAILED_PLAYERNOTFOUND,
VOTE_FAILED_CANNOT_KICK_ADMIN,
VOTE_FAILED_SCRAMBLE_IN_PROGRESS,
VOTE_FAILED_SPECTATOR,
VOTE_FAILED_NEXTLEVEL_SET,
VOTE_FAILED_MAP_NOT_VALID,
VOTE_FAILED_CANNOT_KICK_FOR_TIME,
VOTE_FAILED_CANNOT_KICK_DURING_ROUND,
VOTE_FAILED_VOTE_IN_PROGRESS,
VOTE_FAILED_KICK_LIMIT_REACHED,
// TF-specific?
VOTE_FAILED_MODIFICATION_ALREADY_ACTIVE,
} vote_create_failed_t;
enum
{
#ifdef STAGING_ONLY
SERVER_MODIFICATION_ITEM_DURATION_IN_MINUTES = 2
#else
SERVER_MODIFICATION_ITEM_DURATION_IN_MINUTES = 120
#endif
};
#define MAX_VOTE_DETAILS_LENGTH 64
#define INVALID_ISSUE -1
#define MAX_VOTE_OPTIONS 5
#define DEDICATED_SERVER 99
enum CastVote
{
VOTE_OPTION1, // Use this for Yes
VOTE_OPTION2, // Use this for No
VOTE_OPTION3,
VOTE_OPTION4,
VOTE_OPTION5,
VOTE_UNCAST
};
//===================================================================================================================
// Close caption flags
#define CLOSE_CAPTION_WARNIFMISSING ( 1<<0 )
#define CLOSE_CAPTION_FROMPLAYER ( 1<<1 )
#define CLOSE_CAPTION_GENDER_MALE ( 1<<2 )
#define CLOSE_CAPTION_GENDER_FEMALE ( 1<<3 )
//===================================================================================================================
// Hud Element hiding flags
#define HIDEHUD_WEAPONSELECTION ( 1<<0 ) // Hide ammo count & weapon selection
#define HIDEHUD_FLASHLIGHT ( 1<<1 )
#define HIDEHUD_ALL ( 1<<2 )
#define HIDEHUD_HEALTH ( 1<<3 ) // Hide health & armor / suit battery
#define HIDEHUD_PLAYERDEAD ( 1<<4 ) // Hide when local player's dead
#define HIDEHUD_NEEDSUIT ( 1<<5 ) // Hide when the local player doesn't have the HEV suit
#define HIDEHUD_MISCSTATUS ( 1<<6 ) // Hide miscellaneous status elements (trains, pickup history, death notices, etc)
#define HIDEHUD_CHAT ( 1<<7 ) // Hide all communication elements (saytext, voice icon, etc)
#define HIDEHUD_CROSSHAIR ( 1<<8 ) // Hide crosshairs
#define HIDEHUD_VEHICLE_CROSSHAIR ( 1<<9 ) // Hide vehicle crosshair
#define HIDEHUD_INVEHICLE ( 1<<10 )
#define HIDEHUD_BONUS_PROGRESS ( 1<<11 ) // Hide bonus progress display (for bonus map challenges)
#define HIDEHUD_BITCOUNT 12
//===================================================================================================================
// suit usage bits
#define bits_SUIT_DEVICE_SPRINT 0x00000001
#define bits_SUIT_DEVICE_FLASHLIGHT 0x00000002
#define bits_SUIT_DEVICE_BREATHER 0x00000004
#define MAX_SUIT_DEVICES 3
//===================================================================================================================
// Player Defines
// Max number of players in a game ( see const.h for ABSOLUTE_PLAYER_LIMIT (256 ) )
// The Source engine is really designed for 32 or less players. If you raise this number above 32, you better know what you are doing
// and have a good answer for a bunch of perf question related to player simulation, thinking logic, tracelines, networking overhead, etc.
// But if you are brave or are doing something interesting, go for it... ywb 9/22/03
//You might be wondering why these aren't multiple of 2. Well the reason is that if servers decide to have HLTV or Replay enabled we need the extra slot.
//This is ok since MAX_PLAYERS is used for code specific things like arrays and loops, but it doesn't really means that this is the max number of players allowed
//Since this is decided by the gamerules (and it can be whatever number as long as its less than MAX_PLAYERS).
#if defined( CSTRIKE_DLL )
#define MAX_PLAYERS 65 // Absolute max players supported
#else
#define MAX_PLAYERS 33 // Absolute max players supported
#endif
#define MAX_PLACE_NAME_LENGTH 18
#define MAX_FOV 90
//===================================================================================================================
// Team Defines
#define TEAM_ANY -2
#define TEAM_INVALID -1
#define TEAM_UNASSIGNED 0 // not assigned to a team
#define TEAM_SPECTATOR 1 // spectator team
// Start your team numbers after this
#define LAST_SHARED_TEAM TEAM_SPECTATOR
// The first team that's game specific (i.e. not unassigned / spectator)
#define FIRST_GAME_TEAM (LAST_SHARED_TEAM+1)
#define MAX_TEAMS 32 // Max number of teams in a game
#define MAX_TEAM_NAME_LENGTH 32 // Max length of a team's name
// Weapon m_iState
#define WEAPON_IS_ONTARGET 0x40
#define WEAPON_NOT_CARRIED 0 // Weapon is on the ground
#define WEAPON_IS_CARRIED_BY_PLAYER 1 // This client is carrying this weapon.
#define WEAPON_IS_ACTIVE 2 // This client is carrying this weapon and it's the currently held weapon
// -----------------------------------------
// Skill Level
// -----------------------------------------
#define SKILL_EASY 1
#define SKILL_MEDIUM 2
#define SKILL_HARD 3
// Weapon flags
// -----------------------------------------
// Flags - NOTE: KEEP g_ItemFlags IN WEAPON_PARSE.CPP UPDATED WITH THESE
// -----------------------------------------
#define ITEM_FLAG_SELECTONEMPTY (1<<0)
#define ITEM_FLAG_NOAUTORELOAD (1<<1)
#define ITEM_FLAG_NOAUTOSWITCHEMPTY (1<<2)
#define ITEM_FLAG_LIMITINWORLD (1<<3)
#define ITEM_FLAG_EXHAUSTIBLE (1<<4) // A player can totally exhaust their ammo supply and lose this weapon
#define ITEM_FLAG_DOHITLOCATIONDMG (1<<5) // This weapon take hit location into account when applying damage
#define ITEM_FLAG_NOAMMOPICKUPS (1<<6) // Don't draw ammo pickup sprites/sounds when ammo is received
#define ITEM_FLAG_NOITEMPICKUP (1<<7) // Don't draw weapon pickup when this weapon is picked up by the player
// NOTE: KEEP g_ItemFlags IN WEAPON_PARSE.CPP UPDATED WITH THESE
// Humans only have left and right hands, though we might have aliens with more
// than two, sigh
#define MAX_VIEWMODELS 2
#define MAX_BEAM_ENTS 10
#define TRACER_TYPE_DEFAULT 0x00000001
#define TRACER_TYPE_GUNSHIP 0x00000002
#define TRACER_TYPE_STRIDER 0x00000004 // Here ya go, Jay!
#define TRACER_TYPE_GAUSS 0x00000008
#define TRACER_TYPE_WATERBULLET 0x00000010
#define MUZZLEFLASH_TYPE_DEFAULT 0x00000001
#define MUZZLEFLASH_TYPE_GUNSHIP 0x00000002
#define MUZZLEFLASH_TYPE_STRIDER 0x00000004
// Muzzle flash definitions (for the flags field of the "MuzzleFlash" DispatchEffect)
enum
{
MUZZLEFLASH_AR2 = 0,
MUZZLEFLASH_SHOTGUN,
MUZZLEFLASH_SMG1,
MUZZLEFLASH_SMG2,
MUZZLEFLASH_PISTOL,
MUZZLEFLASH_COMBINE,
MUZZLEFLASH_357,
MUZZLEFLASH_RPG,
MUZZLEFLASH_COMBINE_TURRET,
MUZZLEFLASH_FIRSTPERSON = 0x100,
};
// Tracer Flags
#define TRACER_FLAG_WHIZ 0x0001
#define TRACER_FLAG_USEATTACHMENT 0x0002
#define TRACER_DONT_USE_ATTACHMENT -1
// Entity Dissolve types
enum
{
ENTITY_DISSOLVE_NORMAL = 0,
ENTITY_DISSOLVE_ELECTRICAL,
ENTITY_DISSOLVE_ELECTRICAL_LIGHT,
ENTITY_DISSOLVE_CORE,
// NOTE: Be sure to up the bits if you make more dissolve types
ENTITY_DISSOLVE_BITS = 3
};
// ---------------------------
// Hit Group standards
// ---------------------------
#define HITGROUP_GENERIC 0
#define HITGROUP_HEAD 1
#define HITGROUP_CHEST 2
#define HITGROUP_STOMACH 3
#define HITGROUP_LEFTARM 4
#define HITGROUP_RIGHTARM 5
#define HITGROUP_LEFTLEG 6
#define HITGROUP_RIGHTLEG 7
#define HITGROUP_GEAR 10 // alerts NPC, but doesn't do damage or bleed (1/100th damage)
//
// Enumerations for setting player animation.
//
enum PLAYER_ANIM
{
PLAYER_IDLE,
PLAYER_WALK,
PLAYER_JUMP,
PLAYER_SUPERJUMP,
PLAYER_DIE,
PLAYER_ATTACK1,
PLAYER_IN_VEHICLE,
// TF Player animations
PLAYER_RELOAD,
PLAYER_START_AIMING,
PLAYER_LEAVE_AIMING,
};
#ifdef HL2_DLL
// HL2 has 600 gravity by default
// NOTE: The discrete ticks can have quantization error, so these numbers are biased a little to
// make the heights more exact
#define PLAYER_FATAL_FALL_SPEED 922.5f // approx 60 feet sqrt( 2 * gravity * 60 * 12 )
#define PLAYER_MAX_SAFE_FALL_SPEED 526.5f // approx 20 feet sqrt( 2 * gravity * 20 * 12 )
#define PLAYER_LAND_ON_FLOATING_OBJECT 173 // Can fall another 173 in/sec without getting hurt
#define PLAYER_MIN_BOUNCE_SPEED 173
#define PLAYER_FALL_PUNCH_THRESHOLD 303.0f // won't punch player's screen/make scrape noise unless player falling at least this fast - at least a 76" fall (sqrt( 2 * g * 76))
#else
#define PLAYER_FATAL_FALL_SPEED 1024 // approx 60 feet
#define PLAYER_MAX_SAFE_FALL_SPEED 580 // approx 20 feet
#define PLAYER_LAND_ON_FLOATING_OBJECT 200 // Can go another 200 units without getting hurt
#define PLAYER_MIN_BOUNCE_SPEED 200
#define PLAYER_FALL_PUNCH_THRESHOLD (float)350 // won't punch player's screen/make scrape noise unless player falling at least this fast.
#endif
#define DAMAGE_FOR_FALL_SPEED 100.0f / ( PLAYER_FATAL_FALL_SPEED - PLAYER_MAX_SAFE_FALL_SPEED ) // damage per unit per second.
#define AUTOAIM_2DEGREES 0.0348994967025
#define AUTOAIM_5DEGREES 0.08715574274766
#define AUTOAIM_8DEGREES 0.1391731009601
#define AUTOAIM_10DEGREES 0.1736481776669
#define AUTOAIM_20DEGREES 0.3490658503989
#define AUTOAIM_SCALE_DEFAULT 1.0f
#define AUTOAIM_SCALE_DIRECT_ONLY 0.0f
// instant damage
// For a means of resolving these consts into debug string text, see function
// CTakeDamageInfo::DebugGetDamageTypeString(unsigned int DamageType, char *outbuf, unsigned int outbuflength )
#define DMG_GENERIC 0 // generic damage -- do not use if you want players to flinch and bleed!
#define DMG_CRUSH (1 << 0) // crushed by falling or moving object.
// NOTE: It's assumed crush damage is occurring as a result of physics collision, so no extra physics force is generated by crush damage.
// DON'T use DMG_CRUSH when damaging entities unless it's the result of a physics collision. You probably want DMG_CLUB instead.
#define DMG_BULLET (1 << 1) // shot
#define DMG_SLASH (1 << 2) // cut, clawed, stabbed
#define DMG_BURN (1 << 3) // heat burned
#define DMG_VEHICLE (1 << 4) // hit by a vehicle
#define DMG_FALL (1 << 5) // fell too far
#define DMG_BLAST (1 << 6) // explosive blast damage
#define DMG_CLUB (1 << 7) // crowbar, punch, headbutt
#define DMG_SHOCK (1 << 8) // electric shock
#define DMG_SONIC (1 << 9) // sound pulse shockwave
#define DMG_ENERGYBEAM (1 << 10) // laser or other high energy beam
#define DMG_PREVENT_PHYSICS_FORCE (1 << 11) // Prevent a physics force
#define DMG_NEVERGIB (1 << 12) // with this bit OR'd in, no damage type will be able to gib victims upon death
#define DMG_ALWAYSGIB (1 << 13) // with this bit OR'd in, any damage type can be made to gib victims upon death.
#define DMG_DROWN (1 << 14) // Drowning
#define DMG_PARALYZE (1 << 15) // slows affected creature down
#define DMG_NERVEGAS (1 << 16) // nerve toxins, very bad
#define DMG_POISON (1 << 17) // blood poisoning - heals over time like drowning damage
#define DMG_RADIATION (1 << 18) // radiation exposure
#define DMG_DROWNRECOVER (1 << 19) // drowning recovery
#define DMG_ACID (1 << 20) // toxic chemicals or acid burns
#define DMG_SLOWBURN (1 << 21) // in an oven
#define DMG_REMOVENORAGDOLL (1<<22) // with this bit OR'd in, no ragdoll will be created, and the target will be quietly removed.
// use this to kill an entity that you've already got a server-side ragdoll for
#define DMG_PHYSGUN (1<<23) // Hit by manipulator. Usually doesn't do any damage.
#define DMG_PLASMA (1<<24) // Shot by Cremator
#define DMG_AIRBOAT (1<<25) // Hit by the airboat's gun
#define DMG_DISSOLVE (1<<26) // Dissolving!
#define DMG_BLAST_SURFACE (1<<27) // A blast on the surface of water that cannot harm things underwater
#define DMG_DIRECT (1<<28)
#define DMG_BUCKSHOT (1<<29) // not quite a bullet. Little, rounder, different.
// NOTE: DO NOT ADD ANY MORE CUSTOM DMG_ TYPES. MODS USE THE DMG_LASTGENERICFLAG BELOW, AND
// IF YOU ADD NEW DMG_ TYPES, THEIR TYPES WILL BE HOSED. WE NEED A BETTER SOLUTION.
// TODO: keep this up to date so all the mod-specific flags don't overlap anything.
#define DMG_LASTGENERICFLAG DMG_BUCKSHOT
// settings for m_takedamage
#define DAMAGE_NO 0
#define DAMAGE_EVENTS_ONLY 1 // Call damage functions, but don't modify health
#define DAMAGE_YES 2
#define DAMAGE_AIM 3
// Spectator Movement modes
enum {
OBS_MODE_NONE = 0, // not in spectator mode
OBS_MODE_DEATHCAM, // special mode for death cam animation
OBS_MODE_FREEZECAM, // zooms to a target, and freeze-frames on them
OBS_MODE_FIXED, // view from a fixed camera position
OBS_MODE_IN_EYE, // follow a player in first person view
OBS_MODE_CHASE, // follow a player in third person view
OBS_MODE_POI, // PASSTIME point of interest - game objective, big fight, anything interesting; added in the middle of the enum due to tons of hard-coded "<ROAMING" enum compares
OBS_MODE_ROAMING, // free roaming
NUM_OBSERVER_MODES,
};
#define LAST_PLAYER_OBSERVERMODE OBS_MODE_ROAMING
// Force Camera Restrictions with mp_forcecamera
enum {
OBS_ALLOW_ALL = 0, // allow all modes, all targets
OBS_ALLOW_TEAM, // allow only own team & first person, no PIP
OBS_ALLOW_NONE, // don't allow any spectating after death (fixed & fade to black)
OBS_ALLOW_NUM_MODES,
};
enum
{
TYPE_TEXT = 0, // just display this plain text
TYPE_INDEX, // lookup text & title in stringtable
TYPE_URL, // show this URL
TYPE_FILE, // show this local file
} ;
//=============================================================================
// HPE_BEGIN:
// [Forrest] Replaced text window command string with TEXTWINDOW_CMD enumeration
// of options. Passing a command string is dangerous and allowed a server network
// message to run arbitrary commands on the client.
//=============================================================================
enum
{
TEXTWINDOW_CMD_NONE = 0,
TEXTWINDOW_CMD_JOINGAME,
TEXTWINDOW_CMD_CHANGETEAM,
TEXTWINDOW_CMD_IMPULSE101,
TEXTWINDOW_CMD_MAPINFO,
TEXTWINDOW_CMD_CLOSED_HTMLPAGE,
TEXTWINDOW_CMD_CHOOSETEAM,
};
//=============================================================================
// HPE_END
//=============================================================================
// VGui Screen Flags
enum
{
VGUI_SCREEN_ACTIVE = 0x1,
VGUI_SCREEN_VISIBLE_TO_TEAMMATES = 0x2,
VGUI_SCREEN_ATTACHED_TO_VIEWMODEL = 0x4,
VGUI_SCREEN_TRANSPARENT = 0x8,
VGUI_SCREEN_ONLY_USABLE_BY_OWNER = 0x10,
VGUI_SCREEN_MAX_BITS = 5
};
typedef enum
{
USE_OFF = 0,
USE_ON = 1,
USE_SET = 2,
USE_TOGGLE = 3
} USE_TYPE;
// basic team colors
#define COLOR_RED Color(255, 64, 64, 255)
#define COLOR_BLUE Color(153, 204, 255, 255)
#define COLOR_YELLOW Color(255, 178, 0, 255)
#define COLOR_GREEN Color(153, 255, 153, 255)
#define COLOR_GREY Color(204, 204, 204, 255)
#define COLOR_WHITE Color(255, 255, 255, 255)
#define COLOR_BLACK Color(0, 0, 0, 255)
// All NPCs need this data
enum
{
DONT_BLEED = -1,
BLOOD_COLOR_RED = 0,
BLOOD_COLOR_YELLOW,
BLOOD_COLOR_GREEN,
BLOOD_COLOR_MECH,
#if defined( HL2_EPISODIC )
BLOOD_COLOR_ANTLION, // FIXME: Move to Base HL2
BLOOD_COLOR_ZOMBIE, // FIXME: Move to Base HL2
BLOOD_COLOR_ANTLION_WORKER,
#endif // HL2_EPISODIC
};
//-----------------------------------------------------------------------------
// Vehicles may have more than one passenger.
// This enum may be expanded by derived classes
//-----------------------------------------------------------------------------
enum PassengerRole_t
{
VEHICLE_ROLE_NONE = -1,
VEHICLE_ROLE_DRIVER = 0, // Only one driver
LAST_SHARED_VEHICLE_ROLE,
};
//-----------------------------------------------------------------------------
// Water splash effect flags
//-----------------------------------------------------------------------------
enum
{
FX_WATER_IN_SLIME = 0x1,
};
// Shared think context stuff
#define MAX_CONTEXT_LENGTH 32
#define NO_THINK_CONTEXT -1
// entity flags, CBaseEntity::m_iEFlags
enum
{
EFL_KILLME = (1<<0), // This entity is marked for death -- This allows the game to actually delete ents at a safe time
EFL_DORMANT = (1<<1), // Entity is dormant, no updates to client
EFL_NOCLIP_ACTIVE = (1<<2), // Lets us know when the noclip command is active.
EFL_SETTING_UP_BONES = (1<<3), // Set while a model is setting up its bones.
EFL_KEEP_ON_RECREATE_ENTITIES = (1<<4), // This is a special entity that should not be deleted when we restart entities only
EFL_HAS_PLAYER_CHILD= (1<<4), // One of the child entities is a player.
EFL_DIRTY_SHADOWUPDATE = (1<<5), // Client only- need shadow manager to update the shadow...
EFL_NOTIFY = (1<<6), // Another entity is watching events on this entity (used by teleport)
// The default behavior in ShouldTransmit is to not send an entity if it doesn't
// have a model. Certain entities want to be sent anyway because all the drawing logic
// is in the client DLL. They can set this flag and the engine will transmit them even
// if they don't have a model.
EFL_FORCE_CHECK_TRANSMIT = (1<<7),
EFL_BOT_FROZEN = (1<<8), // This is set on bots that are frozen.
EFL_SERVER_ONLY = (1<<9), // Non-networked entity.
EFL_NO_AUTO_EDICT_ATTACH = (1<<10), // Don't attach the edict; we're doing it explicitly
// Some dirty bits with respect to abs computations
EFL_DIRTY_ABSTRANSFORM = (1<<11),
EFL_DIRTY_ABSVELOCITY = (1<<12),
EFL_DIRTY_ABSANGVELOCITY = (1<<13),
EFL_DIRTY_SURROUNDING_COLLISION_BOUNDS = (1<<14),
EFL_DIRTY_SPATIAL_PARTITION = (1<<15),
// UNUSED = (1<<16),
EFL_IN_SKYBOX = (1<<17), // This is set if the entity detects that it's in the skybox.
// This forces it to pass the "in PVS" for transmission.
EFL_USE_PARTITION_WHEN_NOT_SOLID = (1<<18), // Entities with this flag set show up in the partition even when not solid
EFL_TOUCHING_FLUID = (1<<19), // Used to determine if an entity is floating
// FIXME: Not really sure where I should add this...
EFL_IS_BEING_LIFTED_BY_BARNACLE = (1<<20),
EFL_NO_ROTORWASH_PUSH = (1<<21), // I shouldn't be pushed by the rotorwash
EFL_NO_THINK_FUNCTION = (1<<22),
EFL_NO_GAME_PHYSICS_SIMULATION = (1<<23),
EFL_CHECK_UNTOUCH = (1<<24),
EFL_DONTBLOCKLOS = (1<<25), // I shouldn't block NPC line-of-sight
EFL_DONTWALKON = (1<<26), // NPC;s should not walk on this entity
EFL_NO_DISSOLVE = (1<<27), // These guys shouldn't dissolve
EFL_NO_MEGAPHYSCANNON_RAGDOLL = (1<<28), // Mega physcannon can't ragdoll these guys.
EFL_NO_WATER_VELOCITY_CHANGE = (1<<29), // Don't adjust this entity's velocity when transitioning into water
EFL_NO_PHYSCANNON_INTERACTION = (1<<30), // Physcannon can't pick these up or punt them
EFL_NO_DAMAGE_FORCES = (1<<31), // Doesn't accept forces from physics damage
};
//-----------------------------------------------------------------------------
// EFFECTS
//-----------------------------------------------------------------------------
const int FX_BLOODSPRAY_DROPS = 0x01;
const int FX_BLOODSPRAY_GORE = 0x02;
const int FX_BLOODSPRAY_CLOUD = 0x04;
const int FX_BLOODSPRAY_ALL = 0xFF;
//-----------------------------------------------------------------------------
#define MAX_SCREEN_OVERLAYS 10
// These are the types of data that hang off of CBaseEntities and the flag bits used to mark their presence
enum
{
GROUNDLINK = 0,
TOUCHLINK,
STEPSIMULATION,
MODELSCALE,
POSITIONWATCHER,
PHYSICSPUSHLIST,
VPHYSICSUPDATEAI,
VPHYSICSWATCHER,
// Must be last and <= 32
NUM_DATAOBJECT_TYPES,
};
class CBaseEntity;
//-----------------------------------------------------------------------------
// Bullet firing information
//-----------------------------------------------------------------------------
class CBaseEntity;
enum FireBulletsFlags_t
{
FIRE_BULLETS_FIRST_SHOT_ACCURATE = 0x1, // Pop the first shot with perfect accuracy
FIRE_BULLETS_DONT_HIT_UNDERWATER = 0x2, // If the shot hits its target underwater, don't damage it
FIRE_BULLETS_ALLOW_WATER_SURFACE_IMPACTS = 0x4, // If the shot hits water surface, still call DoImpactEffect
FIRE_BULLETS_TEMPORARY_DANGER_SOUND = 0x8, // Danger sounds added from this impact can be stomped immediately if another is queued
};
struct FireBulletsInfo_t
{
FireBulletsInfo_t()
{
m_iShots = 1;
m_vecSpread.Init( 0, 0, 0 );
m_flDistance = 8192;
m_iTracerFreq = 4;
m_flDamage = 0;
m_iPlayerDamage = 0;
m_pAttacker = NULL;
m_nFlags = 0;
m_pAdditionalIgnoreEnt = NULL;
m_flDamageForceScale = 1.0f;
#ifdef _DEBUG
m_iAmmoType = -1;
m_vecSrc.Init( VEC_T_NAN, VEC_T_NAN, VEC_T_NAN );
m_vecDirShooting.Init( VEC_T_NAN, VEC_T_NAN, VEC_T_NAN );
#endif
m_bPrimaryAttack = true;
m_bUseServerRandomSeed = false;
}
FireBulletsInfo_t( int nShots, const Vector &vecSrc, const Vector &vecDir, const Vector &vecSpread, float flDistance, int nAmmoType, bool bPrimaryAttack = true )
{
m_iShots = nShots;
m_vecSrc = vecSrc;
m_vecDirShooting = vecDir;
m_vecSpread = vecSpread;
m_flDistance = flDistance;
m_iAmmoType = nAmmoType;
m_iTracerFreq = 4;
m_flDamage = 0;
m_iPlayerDamage = 0;
m_pAttacker = NULL;
m_nFlags = 0;
m_pAdditionalIgnoreEnt = NULL;
m_flDamageForceScale = 1.0f;
m_bPrimaryAttack = bPrimaryAttack;
m_bUseServerRandomSeed = false;
}
int m_iShots;
Vector m_vecSrc;
Vector m_vecDirShooting;
Vector m_vecSpread;
float m_flDistance;
int m_iAmmoType;
int m_iTracerFreq;
float m_flDamage;
int m_iPlayerDamage; // Damage to be used instead of m_flDamage if we hit a player
int m_nFlags; // See FireBulletsFlags_t
float m_flDamageForceScale;
CBaseEntity *m_pAttacker;
CBaseEntity *m_pAdditionalIgnoreEnt;
bool m_bPrimaryAttack;
bool m_bUseServerRandomSeed;
};
//-----------------------------------------------------------------------------
// Purpose: Data for making the MOVETYPE_STEP entities appear to simulate every frame
// We precompute the simulation and then meter it out each tick during networking of the
// entities origin and orientation. Uses a bit more bandwidth, but it solves the NPCs interacting
// with elevators/lifts bugs.
//-----------------------------------------------------------------------------
struct StepSimulationStep
{
int nTickCount;
Vector vecOrigin;
Quaternion qRotation;
};
struct StepSimulationData
{
// Are we using the Step Simulation Data
bool m_bOriginActive;
bool m_bAnglesActive;
// This is the pre-pre-Think position, orientation (Quaternion) and tick count
StepSimulationStep m_Previous2;
// This is the pre-Think position, orientation (Quaternion) and tick count
StepSimulationStep m_Previous;
// This is a potential mid-think position, orientation (Quaternion) and tick count
// Used to mark motion discontinuities that happen between thinks
StepSimulationStep m_Discontinuity;
// This is the goal or post-Think position and orientation (and Quaternion for blending) and next think time tick
StepSimulationStep m_Next;
QAngle m_angNextRotation;
// This variable is used so that we only compute networked origin/angles once per tick
int m_nLastProcessTickCount;
// The computed/interpolated network origin/angles to use
Vector m_vecNetworkOrigin;
QAngle m_angNetworkAngles;
};
//-----------------------------------------------------------------------------
// Purpose: Simple state tracking for changing model sideways shrinkage during barnacle swallow
//-----------------------------------------------------------------------------
struct ModelScale
{
float m_flModelScaleStart;
float m_flModelScaleGoal;
float m_flModelScaleFinishTime;
float m_flModelScaleStartTime;
};
#include "soundflags.h"
struct CSoundParameters;
typedef short HSOUNDSCRIPTHANDLE;
//-----------------------------------------------------------------------------
// Purpose: Aggregates and sets default parameters for EmitSound function calls
//-----------------------------------------------------------------------------
struct EmitSound_t
{
EmitSound_t() :
m_nChannel( 0 ),
m_pSoundName( 0 ),
m_flVolume( VOL_NORM ),
m_SoundLevel( SNDLVL_NONE ),
m_nFlags( 0 ),
m_nPitch( PITCH_NORM ),
m_nSpecialDSP( 0 ),
m_pOrigin( 0 ),
m_flSoundTime( 0.0f ),
m_pflSoundDuration( 0 ),
m_bEmitCloseCaption( true ),
m_bWarnOnMissingCloseCaption( false ),
m_bWarnOnDirectWaveReference( false ),
m_nSpeakerEntity( -1 ),
m_UtlVecSoundOrigin(),
m_hSoundScriptHandle( -1 )
{
}
EmitSound_t( const CSoundParameters &src );
int m_nChannel;
char const *m_pSoundName;
float m_flVolume;
soundlevel_t m_SoundLevel;
int m_nFlags;
int m_nPitch;
int m_nSpecialDSP;
const Vector *m_pOrigin;
float m_flSoundTime; ///< NOT DURATION, but rather, some absolute time in the future until which this sound should be delayed
float *m_pflSoundDuration;
bool m_bEmitCloseCaption;
bool m_bWarnOnMissingCloseCaption;
bool m_bWarnOnDirectWaveReference;
int m_nSpeakerEntity;
mutable CUtlVector< Vector > m_UtlVecSoundOrigin; ///< Actual sound origin(s) (can be multiple if sound routed through speaker entity(ies) )
mutable HSOUNDSCRIPTHANDLE m_hSoundScriptHandle;
};
#define MAX_ACTORS_IN_SCENE 16
//-----------------------------------------------------------------------------
// Multiplayer specific defines
//-----------------------------------------------------------------------------
#define MAX_CONTROL_POINTS 8
#define MAX_CONTROL_POINT_GROUPS 8
// Maximum number of points that a control point may need owned to be cappable
#define MAX_PREVIOUS_POINTS 3
// The maximum number of teams the control point system knows how to deal with
#define MAX_CONTROL_POINT_TEAMS 8
// Maximum length of the cap layout string
#define MAX_CAPLAYOUT_LENGTH 32
// Maximum length of the current round printname
#define MAX_ROUND_NAME 32
// Maximum length of the current round name
#define MAX_ROUND_IMAGE_NAME 64
// Score added to the team score for a round win
#define TEAMPLAY_ROUND_WIN_SCORE 1
enum
{
CP_WARN_NORMAL = 0,
CP_WARN_FINALCAP,
CP_WARN_NO_ANNOUNCEMENTS
};
// YWB: 3/12/2007
// Changing the following #define for Prediction Error checking (See gamemovement.cpp for overview) will to 1 or 2 enables the system, 0 turns it off
// Level 1 enables it, but doesn't force "full precision" networking, so you can still get lots of errors in position/velocity/etc.
// Level 2 enables it but also forces origins/angles to be sent full precision, so other fields can be error / tolerance checked
// NOTE: This stuff only works on a listen server since it punches a hole from the client .dll to server .dll!!!
#define PREDICTION_ERROR_CHECK_LEVEL 0
//-----------------------------------------------------------------------------
// Round timer states
//-----------------------------------------------------------------------------
enum
{
RT_STATE_SETUP, // Timer is in setup mode
RT_STATE_NORMAL, // Timer is in normal mode
};
enum
{
SIMULATION_TIME_WINDOW_BITS = 8,
};
//-----------------------------------------------------------------------------
// Commentary Mode
//-----------------------------------------------------------------------------
#if defined(TF_DLL) || defined(TF_CLIENT_DLL)
#define GAME_HAS_NO_USE_KEY
#if defined( SPROP_COORD )
#undef SPROP_COORD
#endif
#define SPROP_COORD SPROP_COORD_MP
#endif
// The player's method of starting / stopping commentary
#ifdef GAME_HAS_NO_USE_KEY
#define COMMENTARY_BUTTONS (IN_ATTACK | IN_ATTACK2 | IN_USE)
#else
#define COMMENTARY_BUTTONS (IN_USE)
#endif
#define TEAM_TRAIN_MAX_TEAMS 4
#define TEAM_TRAIN_MAX_HILLS 5
#define TEAM_TRAIN_FLOATS_PER_HILL 2
#define TEAM_TRAIN_HILLS_ARRAY_SIZE TEAM_TRAIN_MAX_TEAMS * TEAM_TRAIN_MAX_HILLS * TEAM_TRAIN_FLOATS_PER_HILL
enum
{
HILL_TYPE_NONE = 0,
HILL_TYPE_UPHILL,
HILL_TYPE_DOWNHILL,
};
#define NOINTERP_PARITY_MAX 4
#define NOINTERP_PARITY_MAX_BITS 2
//-----------------------------------------------------------------------------
// Generic activity lookup support
//-----------------------------------------------------------------------------
enum
{
kActivityLookup_Unknown = -2, // hasn't been searched for
kActivityLookup_Missing = -1, // has been searched for but wasn't found
};
#if defined(TF_DLL) || defined(TF_CLIENT_DLL)
//-----------------------------------------------------------------------------
// Vision Filters.
//-----------------------------------------------------------------------------
// Also used in the item schema to define vision filter or vision mode opt in
#define TF_VISION_FILTER_NONE 0
#define TF_VISION_FILTER_PYRO (1<<0) // 1
#define TF_VISION_FILTER_HALLOWEEN (1<<1) // 2
#define TF_VISION_FILTER_ROME (1<<2) // 4
// THIS ENUM SHOULD MATCH THE ORDER OF THE FLAGS ABOVE
enum
{
VISION_MODE_NONE = 0,
VISION_MODE_PYRO,
VISION_MODE_HALLOWEEN,
VISION_MODE_ROME,
MAX_VISION_MODES
};
#endif // TF_DLL || TF_CLIENT_DLL
#endif // SHAREDDEFS_H