monster movement interpolation now works in both protocols (shared code), this bloate...
[divverent/darkplaces.git] / client.h
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19 */
20 // client.h
21
22 #ifndef CLIENT_H
23 #define CLIENT_H
24
25 // LordHavoc: 256 dynamic lights
26 #define MAX_DLIGHTS 256
27 // LordHavoc: this affects the lighting scale of the whole game
28 #define LIGHTOFFSET 1024.0f
29 // max lights shining on one entity
30 #define MAXENTLIGHTS 128
31
32 extern int cl_max_entities;
33 extern int cl_max_static_entities;
34 extern int cl_max_temp_entities;
35 extern int cl_max_effects;
36 extern int cl_max_beams;
37
38 typedef struct effect_s
39 {
40         int active;
41         vec3_t origin;
42         float starttime;
43         float framerate;
44         int modelindex;
45         int startframe;
46         int endframe;
47         // these are for interpolation
48         int frame;
49         double frame1time;
50         double frame2time;
51 }
52 cl_effect_t;
53
54 typedef struct
55 {
56         int             entity;
57         struct model_s  *model;
58         float   endtime;
59         vec3_t  start, end;
60 }
61 beam_t;
62
63 typedef struct
64 {
65         // location
66         vec3_t  origin;
67         // stop lighting after this time
68         float   die;
69         // color of light
70         vec3_t  color;
71         // brightness (not really radius anymore)
72         float   radius;
73         // drop this each second
74         float   decay;
75         // the entity that spawned this light (can be NULL if it will never be replaced)
76         //entity_render_t *ent;
77 }
78 dlight_t;
79
80 typedef struct frameblend_s
81 {
82         int frame;
83         float lerp;
84 }
85 frameblend_t;
86
87 // LordHavoc: disregard the following warning, entlights stuff is semi-persistent...
88 // LordHavoc: nothing in this structure is persistent, it may be overwritten by the client every frame, for persistent data use entity_lerp_t.
89 typedef struct entity_render_s
90 {
91         // location
92         vec3_t origin;
93         // orientation
94         vec3_t angles;
95         // opacity (alpha) of the model
96         float alpha;
97         // size the model is shown
98         float scale;
99
100         // NULL = no model
101         model_t *model;
102         // current uninterpolated animation frame (for things which do not use interpolation)
103         int frame;
104         // entity shirt and pants colors
105         int colormap;
106         // light, particles, etc
107         int effects;
108         // for Alias models
109         int skinnum;
110         // render flags
111         int flags;
112
113         // these are copied from the persistent data
114
115         // frame that the model is interpolating from
116         int frame1;
117         // frame that the model is interpolating to
118         int frame2;
119         // interpolation factor, usually computed from frame2time
120         double framelerp;
121         // time frame1 began playing (for framegroup animations)
122         double frame1time;
123         // time frame2 began playing (for framegroup animations)
124         double frame2time;
125
126         // calculated by the renderer (but not persistent)
127
128         // if visframe == r_framecount, it is visible
129         int visframe;
130         // calculated during R_AddModelEntities
131         vec3_t mins, maxs;
132         // 4 frame numbers (-1 if not used) and their blending scalers (0-1), if interpolation is not desired, use frame instead
133         frameblend_t frameblend[4];
134
135         // caching results of static light traces (this is semi-persistent)
136         double entlightstime;
137         vec3_t entlightsorigin;
138         int numentlights;
139         unsigned short entlights[MAXENTLIGHTS];
140 }
141 entity_render_t;
142
143 typedef struct entity_persistent_s
144 {
145         // particles
146
147         // trail rendering
148         vec3_t trail_origin;
149         float trail_time;
150
151         // effects
152
153         // muzzleflash fading
154         float muzzleflash;
155
156         // interpolated movement
157
158         // start time of move
159         float lerpstarttime;
160         // time difference from start to end of move
161         float lerpdeltatime;
162         // the move itself, start and end
163         float oldorigin[3];
164         float oldangles[3];
165         float neworigin[3];
166         float newangles[3];
167
168         // interpolated animation
169
170         // lerp resets when model changes
171         int modelindex;
172         // frame that the model is interpolating from
173         int frame1;
174         // frame that the model is interpolating to
175         int frame2;
176         // interpolation factor, usually computed from frame2time
177         double framelerp;
178         // time frame1 began playing (for framegroup animations)
179         double frame1time;
180         // time frame2 began playing (for framegroup animations)
181         double frame2time;
182 }
183 entity_persistent_t;
184
185 typedef struct entity_s
186 {
187         // baseline state (default values)
188         entity_state_t state_baseline;
189         // previous state (interpolating from this)
190         entity_state_t state_previous;
191         // current state (interpolating to this)
192         entity_state_t state_current;
193
194         // used for regenerating parts of render
195         entity_persistent_t persistent;
196
197         // the only data the renderer should know about
198         entity_render_t render;
199 }
200 entity_t;
201
202 typedef struct
203 {
204         vec3_t  viewangles;
205
206 // intended velocities
207         float   forwardmove;
208         float   sidemove;
209         float   upmove;
210 } usercmd_t;
211
212 typedef struct
213 {
214         int             length;
215         char    map[MAX_STYLESTRING];
216 } lightstyle_t;
217
218 typedef struct
219 {
220         char    name[MAX_SCOREBOARDNAME];
221         float   entertime;
222         int             frags;
223         int             colors; // two 4 bit fields
224 } scoreboard_t;
225
226 typedef struct
227 {
228         int             destcolor[3];
229         int             percent;                // 0-256
230 } cshift_t;
231
232 #define CSHIFT_CONTENTS 0
233 #define CSHIFT_DAMAGE   1
234 #define CSHIFT_BONUS    2
235 #define CSHIFT_POWERUP  3
236 #define NUM_CSHIFTS             4
237
238 #define NAME_LENGTH     64
239
240
241 //
242 // client_state_t should hold all pieces of the client state
243 //
244
245 #define SIGNONS         4                       // signon messages to receive before connected
246
247 #define MAX_MAPSTRING   2048
248 #define MAX_DEMOS               8
249 #define MAX_DEMONAME    16
250
251 typedef enum
252 {
253         ca_dedicated,           // a dedicated server with no ability to start a client
254         ca_disconnected,        // full screen console with no connection
255         ca_connected            // valid netcon, talking to a server
256 }
257 cactive_t;
258
259 //
260 // the client_static_t structure is persistent through an arbitrary number
261 // of server connections
262 //
263 typedef struct
264 {
265         cactive_t state;
266
267 // personalization data sent to server
268         char mapstring[MAX_QPATH];
269         // to restart a level
270         //char spawnparms[MAX_MAPSTRING];
271
272 // demo loop control
273         // -1 = don't play demos
274         int demonum;
275         // list of demos in loop
276         char demos[MAX_DEMOS][MAX_DEMONAME];
277
278 // demo recording info must be here, because record is started before
279 // entering a map (and clearing client_state_t)
280         qboolean demorecording;
281         qboolean demoplayback;
282         qboolean timedemo;
283         // -1 = use normal cd track
284         int forcetrack;
285         QFile *demofile;
286         // to meter out one message a frame
287         int td_lastframe;
288         // host_framecount at start
289         int td_startframe;
290         // realtime at second frame of timedemo (LordHavoc: changed to double)
291         double td_starttime;
292         // LordHavoc: pausedemo
293         qboolean demopaused;
294
295
296 // connection information
297         // 0 to SIGNONS
298         int signon;
299         // network socket
300         struct qsocket_s *netcon;
301         // writing buffer to send to server
302         sizebuf_t message;
303 }
304 client_static_t;
305
306 extern client_static_t  cls;
307
308 //
309 // the client_state_t structure is wiped completely at every
310 // server signon
311 //
312 typedef struct
313 {
314         // when connecting to the server throw out the first couple move messages
315         // so the player doesn't accidentally do something the first frame
316         int movemessages;
317
318         // send a clc_nop periodically until connected
319         float sendnoptime;
320
321         // last command sent to the server
322         usercmd_t cmd;
323
324 // information for local display
325         // health, etc
326         int stats[MAX_CL_STATS];
327         // inventory bit flags
328         int items;
329         // cl.time of acquiring item, for blinking
330         float item_gettime[32];
331         // use pain anim frame if cl.time < this
332         float faceanimtime;
333
334         // color shifts for damage, powerups
335         cshift_t cshifts[NUM_CSHIFTS];
336         // and content types
337         cshift_t prev_cshifts[NUM_CSHIFTS];
338
339 // the client maintains its own idea of view angles, which are
340 // sent to the server each frame.  The server sets punchangle when
341 // the view is temporarily offset, and an angle reset commands at the start
342 // of each level and after teleporting.
343
344         // during demo playback viewangles is lerped between these
345         vec3_t mviewangles[2];
346         // either client controlled, or lerped from demo mviewangles
347         vec3_t viewangles;
348
349         // update by server, used for lean+bob (0 is newest)
350         vec3_t mvelocity[2];
351         // lerped between mvelocity[0] and [1]
352         vec3_t velocity;
353
354         // temporary offset
355         vec3_t punchangle;
356         // LordHavoc: origin view kick
357         vec3_t punchvector;
358
359 // pitch drifting vars
360         float idealpitch;
361         float pitchvel;
362         qboolean nodrift;
363         float driftmove;
364         double laststop;
365
366         float viewheight;
367         // local amount for smoothing stepups
368         //float crouch;
369
370         // sent by server
371         qboolean paused;
372         qboolean onground;
373         qboolean inwater;
374
375         // don't change view angle, full screen, etc
376         int intermission;
377         // latched at intermission start
378         int completed_time;
379
380         // the timestamp of the last two messages
381         double mtime[2];
382
383         // clients view of time, time should be between mtime[0] and mtime[1] to
384         // generate a lerp point for other data, oldtime is the previous frame's
385         // value of time, frametime is the difference between time and oldtime
386         double time, oldtime, frametime;
387
388         // copy of realtime from last recieved message, for net trouble icon
389         float last_received_message;
390
391 // information that is static for the entire time connected to a server
392         struct model_s *model_precache[MAX_MODELS];
393         struct sfx_s *sound_precache[MAX_SOUNDS];
394
395         // for display on solo scoreboard
396         char levelname[40];
397         // cl_entitites[cl.viewentity] = player
398         int viewentity;
399         // the real player entity (normally same as viewentity,
400         // different than viewentity if mod uses chasecam or other tricks)
401         int playerentity;
402         // max players that can be in this game
403         int maxclients;
404         // type of game (deathmatch, coop, singleplayer)
405         int gametype;
406
407 // refresh related state
408
409         // cl_entitites[0].model
410         struct model_s *worldmodel;
411
412         // the gun model
413         entity_t viewent;
414
415         // cd audio
416         int cdtrack, looptrack;
417
418 // frag scoreboard
419
420         // [cl.maxclients]
421         scoreboard_t *scores;
422
423         // used by view code for setting up eye position
424         vec3_t viewentorigin;
425         // LordHavoc: sniping zoom, QC controlled
426         float viewzoom;
427         // for interpolation
428         float viewzoomold, viewzoomnew;
429
430         // entity database stuff
431         vec3_t viewentoriginold, viewentoriginnew;
432         entity_database_t entitydatabase;
433 }
434 client_state_t;
435
436 extern mempool_t *cl_scores_mempool;
437
438 //
439 // cvars
440 //
441 extern cvar_t cl_name;
442 extern cvar_t cl_color;
443 extern cvar_t cl_pmodel;
444
445 extern cvar_t cl_upspeed;
446 extern cvar_t cl_forwardspeed;
447 extern cvar_t cl_backspeed;
448 extern cvar_t cl_sidespeed;
449
450 extern cvar_t cl_movespeedkey;
451
452 extern cvar_t cl_yawspeed;
453 extern cvar_t cl_pitchspeed;
454
455 extern cvar_t cl_anglespeedkey;
456
457 extern cvar_t cl_autofire;
458
459 extern cvar_t cl_shownet;
460 extern cvar_t cl_nolerp;
461
462 extern cvar_t cl_pitchdriftspeed;
463 extern cvar_t lookspring;
464 extern cvar_t lookstrafe;
465 extern cvar_t sensitivity;
466
467 extern cvar_t freelook;
468
469 extern cvar_t m_pitch;
470 extern cvar_t m_yaw;
471 extern cvar_t m_forward;
472 extern cvar_t m_side;
473
474 extern cvar_t r_draweffects;
475
476 extern cvar_t cl_explosions;
477 extern cvar_t cl_stainmaps;
478
479 // these are updated by
480 extern int cl_num_entities;
481 extern int cl_num_static_entities;
482 extern int cl_num_temp_entities;
483 extern int cl_num_brushmodel_entities;
484
485 extern entity_t *cl_entities;
486 extern qbyte *cl_entities_active;
487 extern entity_t *cl_static_entities;
488 extern entity_t *cl_temp_entities;
489 extern entity_render_t **cl_brushmodel_entities;
490 extern cl_effect_t *cl_effects;
491 extern beam_t *cl_beams;
492 extern dlight_t *cl_dlights;
493 extern lightstyle_t *cl_lightstyle;
494
495
496 extern client_state_t cl;
497
498 extern void CL_AllocDlight (entity_render_t *ent, vec3_t org, float radius, float red, float green, float blue, float decay, float lifetime);
499 extern void CL_DecayLights (void);
500
501 //=============================================================================
502
503 //
504 // cl_main
505 //
506
507 void CL_Init (void);
508
509 void CL_EstablishConnection (char *host);
510
511 void CL_Disconnect (void);
512 void CL_Disconnect_f (void);
513
514 //
515 // cl_input
516 //
517 typedef struct
518 {
519         int             down[2];                // key nums holding it down
520         int             state;                  // low bit is down state
521 }
522 kbutton_t;
523
524 extern  kbutton_t       in_mlook, in_klook;
525 extern  kbutton_t       in_strafe;
526 extern  kbutton_t       in_speed;
527
528 void CL_InitInput (void);
529 void CL_SendCmd (void);
530 void CL_SendMove (usercmd_t *cmd);
531
532 void CL_LerpUpdate(entity_t *e);
533 void CL_ParseTEnt (void);
534 void CL_RelinkBeams (void);
535
536 void CL_ClearTempEntities (void);
537 entity_t *CL_NewTempEntity (void);
538
539 void CL_Effect(vec3_t org, int modelindex, int startframe, int framecount, float framerate);
540
541 void CL_ClearState (void);
542
543
544 int  CL_ReadFromServer (void);
545 void CL_WriteToServer (usercmd_t *cmd);
546 void CL_BaseMove (usercmd_t *cmd);
547
548
549 float CL_KeyState (kbutton_t *key);
550 char *Key_KeynumToString (int keynum);
551
552 //
553 // cl_demo.c
554 //
555 void CL_StopPlayback (void);
556 int CL_GetMessage (void);
557
558 void CL_NextDemo (void);
559 void CL_Stop_f (void);
560 void CL_Record_f (void);
561 void CL_PlayDemo_f (void);
562 void CL_TimeDemo_f (void);
563
564 //
565 // cl_parse.c
566 //
567 void CL_Parse_Init(void);
568 void CL_ParseServerMessage(void);
569 void CL_BitProfile_f(void);
570
571 //
572 // view
573 //
574 void V_StartPitchDrift (void);
575 void V_StopPitchDrift (void);
576
577 void V_Init (void);
578 float V_CalcRoll (vec3_t angles, vec3_t velocity);
579 void V_UpdateBlends (void);
580 void V_ParseDamage (void);
581
582
583 //
584 // cl_tent
585 //
586 void CL_InitTEnts (void);
587
588 //
589 // cl_part
590 //
591
592 #define PARTICLE_INVALID 0
593 #define PARTICLE_BILLBOARD 1
594 #define PARTICLE_UPRIGHT_FACING 2
595 #define PARTICLE_ORIENTED_DOUBLESIDED 3
596
597 void CL_Particles_Clear(void);
598 void CL_Particles_Init(void);
599
600 void CL_ParseParticleEffect (void);
601 void CL_RunParticleEffect (vec3_t org, vec3_t dir, int color, int count);
602 void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent);
603 void CL_RocketTrail2 (vec3_t start, vec3_t end, int color, entity_t *ent);
604 void CL_SparkShower (vec3_t org, vec3_t dir, int count);
605 void CL_PlasmaBurn (vec3_t org);
606 void CL_BloodPuff (vec3_t org, vec3_t vel, int count);
607 void CL_Stardust (vec3_t mins, vec3_t maxs, int count);
608 void CL_FlameCube (vec3_t mins, vec3_t maxs, int count);
609 void CL_Flames (vec3_t org, vec3_t vel, int count);
610 void CL_BloodShower (vec3_t mins, vec3_t maxs, float velspeed, int count);
611 void CL_ParticleCube (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int colorbase, int gravity, int randomvel);
612 void CL_ParticleRain (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int colorbase, int type);
613 void CL_EntityParticles (entity_t *ent);
614 void CL_BlobExplosion (vec3_t org);
615 void CL_ParticleExplosion (vec3_t org, int smoke);
616 void CL_ParticleExplosion2 (vec3_t org, int colorStart, int colorLength);
617 void CL_LavaSplash (vec3_t org);
618 void CL_TeleportSplash (vec3_t org);
619 void CL_MoveParticles(void);
620 void R_MoveExplosions(void);
621 void R_NewExplosion(vec3_t org);
622
623 #include "cl_screen.h"
624
625 typedef struct
626 {
627         // area to render in
628         int x, y, width, height;
629         float fov_x, fov_y;
630
631         // view point
632         vec3_t vieworg;
633         vec3_t viewangles;
634
635         // fullscreen color blend
636         float viewblend[4];
637
638         // weapon model
639         entity_render_t viewent;
640
641         entity_render_t **entities;
642         int numentities;
643         int maxentities;
644
645         qbyte *drawqueue;
646         int drawqueuesize;
647         int maxdrawqueuesize;
648 }
649 refdef_t;
650
651 refdef_t r_refdef;
652
653 extern mempool_t *cl_refdef_mempool;
654
655 #include "cgamevm.h"
656
657 #endif
658