diff options
Diffstat (limited to 'apps/plugins/sdl/progs/quake/cl_main.c')
-rw-r--r-- | apps/plugins/sdl/progs/quake/cl_main.c | 757 |
1 files changed, 757 insertions, 0 deletions
diff --git a/apps/plugins/sdl/progs/quake/cl_main.c b/apps/plugins/sdl/progs/quake/cl_main.c new file mode 100644 index 0000000000..58121434bc --- /dev/null +++ b/apps/plugins/sdl/progs/quake/cl_main.c | |||
@@ -0,0 +1,757 @@ | |||
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 | // cl_main.c -- client main loop | ||
21 | |||
22 | #include "quakedef.h" | ||
23 | |||
24 | // we need to declare some mouse variables here, because the menu system | ||
25 | // references them even when on a unix system. | ||
26 | |||
27 | // these two are not intended to be set directly | ||
28 | cvar_t cl_name = {"_cl_name", "player", true}; | ||
29 | cvar_t cl_color = {"_cl_color", "0", true}; | ||
30 | |||
31 | cvar_t cl_shownet = {"cl_shownet","0"}; // can be 0, 1, or 2 | ||
32 | cvar_t cl_nolerp = {"cl_nolerp","0"}; | ||
33 | |||
34 | cvar_t lookspring = {"lookspring","0", true}; | ||
35 | cvar_t lookstrafe = {"lookstrafe","0", true}; | ||
36 | cvar_t sensitivity = {"sensitivity","3", true}; | ||
37 | |||
38 | cvar_t m_pitch = {"m_pitch","0.022", true}; | ||
39 | cvar_t m_yaw = {"m_yaw","0.022", true}; | ||
40 | cvar_t m_forward = {"m_forward","1", true}; | ||
41 | cvar_t m_side = {"m_side","0.8", true}; | ||
42 | |||
43 | |||
44 | client_static_t cls; | ||
45 | client_state_t cl; | ||
46 | // FIXME: put these on hunk? | ||
47 | efrag_t cl_efrags[MAX_EFRAGS]; | ||
48 | entity_t cl_entities[MAX_EDICTS]; | ||
49 | entity_t cl_static_entities[MAX_STATIC_ENTITIES]; | ||
50 | lightstyle_t cl_lightstyle[MAX_LIGHTSTYLES]; | ||
51 | dlight_t cl_dlights[MAX_DLIGHTS]; | ||
52 | |||
53 | int cl_numvisedicts; | ||
54 | entity_t *cl_visedicts[MAX_VISEDICTS]; | ||
55 | |||
56 | /* | ||
57 | ===================== | ||
58 | CL_ClearState | ||
59 | |||
60 | ===================== | ||
61 | */ | ||
62 | void CL_ClearState (void) | ||
63 | { | ||
64 | int i; | ||
65 | |||
66 | if (!sv.active) | ||
67 | Host_ClearMemory (); | ||
68 | |||
69 | // wipe the entire cl structure | ||
70 | memset (&cl, 0, sizeof(cl)); | ||
71 | |||
72 | SZ_Clear (&cls.message); | ||
73 | |||
74 | // clear other arrays | ||
75 | memset (cl_efrags, 0, sizeof(cl_efrags)); | ||
76 | memset (cl_entities, 0, sizeof(cl_entities)); | ||
77 | memset (cl_dlights, 0, sizeof(cl_dlights)); | ||
78 | memset (cl_lightstyle, 0, sizeof(cl_lightstyle)); | ||
79 | memset (cl_temp_entities, 0, sizeof(cl_temp_entities)); | ||
80 | memset (cl_beams, 0, sizeof(cl_beams)); | ||
81 | |||
82 | // | ||
83 | // allocate the efrags and chain together into a free list | ||
84 | // | ||
85 | cl.free_efrags = cl_efrags; | ||
86 | for (i=0 ; i<MAX_EFRAGS-1 ; i++) | ||
87 | cl.free_efrags[i].entnext = &cl.free_efrags[i+1]; | ||
88 | cl.free_efrags[i].entnext = NULL; | ||
89 | } | ||
90 | |||
91 | /* | ||
92 | ===================== | ||
93 | CL_Disconnect | ||
94 | |||
95 | Sends a disconnect message to the server | ||
96 | This is also called on Host_Error, so it shouldn't cause any errors | ||
97 | ===================== | ||
98 | */ | ||
99 | void CL_Disconnect (void) | ||
100 | { | ||
101 | // stop sounds (especially looping!) | ||
102 | S_StopAllSounds (true); | ||
103 | |||
104 | // bring the console down and fade the colors back to normal | ||
105 | // SCR_BringDownConsole (); | ||
106 | |||
107 | // if running a local server, shut it down | ||
108 | if (cls.demoplayback) | ||
109 | CL_StopPlayback (); | ||
110 | else if (cls.state == ca_connected) | ||
111 | { | ||
112 | if (cls.demorecording) | ||
113 | CL_Stop_f (); | ||
114 | |||
115 | Con_DPrintf ("Sending clc_disconnect\n"); | ||
116 | SZ_Clear (&cls.message); | ||
117 | MSG_WriteByte (&cls.message, clc_disconnect); | ||
118 | NET_SendUnreliableMessage (cls.netcon, &cls.message); | ||
119 | SZ_Clear (&cls.message); | ||
120 | NET_Close (cls.netcon); | ||
121 | |||
122 | cls.state = ca_disconnected; | ||
123 | if (sv.active) | ||
124 | Host_ShutdownServer(false); | ||
125 | } | ||
126 | |||
127 | cls.demoplayback = cls.timedemo = false; | ||
128 | cls.signon = 0; | ||
129 | } | ||
130 | |||
131 | void CL_Disconnect_f (void) | ||
132 | { | ||
133 | CL_Disconnect (); | ||
134 | if (sv.active) | ||
135 | Host_ShutdownServer (false); | ||
136 | } | ||
137 | |||
138 | |||
139 | |||
140 | |||
141 | /* | ||
142 | ===================== | ||
143 | CL_EstablishConnection | ||
144 | |||
145 | Host should be either "local" or a net address to be passed on | ||
146 | ===================== | ||
147 | */ | ||
148 | void CL_EstablishConnection (char *host) | ||
149 | { | ||
150 | if (cls.state == ca_dedicated) | ||
151 | return; | ||
152 | |||
153 | if (cls.demoplayback) | ||
154 | return; | ||
155 | |||
156 | CL_Disconnect (); | ||
157 | |||
158 | cls.netcon = NET_Connect (host); | ||
159 | if (!cls.netcon) | ||
160 | Host_Error ("CL_Connect: connect failed\n"); | ||
161 | Con_DPrintf ("CL_EstablishConnection: connected to %s\n", host); | ||
162 | |||
163 | cls.demonum = -1; // not in the demo loop now | ||
164 | cls.state = ca_connected; | ||
165 | cls.signon = 0; // need all the signon messages before playing | ||
166 | } | ||
167 | |||
168 | /* | ||
169 | ===================== | ||
170 | CL_SignonReply | ||
171 | |||
172 | An svc_signonnum has been received, perform a client side setup | ||
173 | ===================== | ||
174 | */ | ||
175 | void CL_SignonReply (void) | ||
176 | { | ||
177 | char str[8192]; | ||
178 | |||
179 | Con_DPrintf ("CL_SignonReply: %i\n", cls.signon); | ||
180 | |||
181 | switch (cls.signon) | ||
182 | { | ||
183 | case 1: | ||
184 | MSG_WriteByte (&cls.message, clc_stringcmd); | ||
185 | MSG_WriteString (&cls.message, "prespawn"); | ||
186 | break; | ||
187 | |||
188 | case 2: | ||
189 | MSG_WriteByte (&cls.message, clc_stringcmd); | ||
190 | MSG_WriteString (&cls.message, va("name \"%s\"\n", cl_name.string)); | ||
191 | |||
192 | MSG_WriteByte (&cls.message, clc_stringcmd); | ||
193 | MSG_WriteString (&cls.message, va("color %i %i\n", ((int)cl_color.value)>>4, ((int)cl_color.value)&15)); | ||
194 | |||
195 | MSG_WriteByte (&cls.message, clc_stringcmd); | ||
196 | sprintf (str, "spawn %s", cls.spawnparms); | ||
197 | MSG_WriteString (&cls.message, str); | ||
198 | break; | ||
199 | |||
200 | case 3: | ||
201 | MSG_WriteByte (&cls.message, clc_stringcmd); | ||
202 | MSG_WriteString (&cls.message, "begin"); | ||
203 | Cache_Report (); // print remaining memory | ||
204 | break; | ||
205 | |||
206 | case 4: | ||
207 | SCR_EndLoadingPlaque (); // allow normal screen updates | ||
208 | break; | ||
209 | } | ||
210 | } | ||
211 | |||
212 | /* | ||
213 | ===================== | ||
214 | CL_NextDemo | ||
215 | |||
216 | Called to play the next demo in the demo loop | ||
217 | ===================== | ||
218 | */ | ||
219 | void CL_NextDemo (void) | ||
220 | { | ||
221 | char str[1024]; | ||
222 | |||
223 | if (cls.demonum == -1) | ||
224 | return; // don't play demos | ||
225 | |||
226 | SCR_BeginLoadingPlaque (); | ||
227 | |||
228 | if (!cls.demos[cls.demonum][0] || cls.demonum == MAX_DEMOS) | ||
229 | { | ||
230 | cls.demonum = 0; | ||
231 | if (!cls.demos[cls.demonum][0]) | ||
232 | { | ||
233 | Con_Printf ("No demos listed with startdemos\n"); | ||
234 | cls.demonum = -1; | ||
235 | return; | ||
236 | } | ||
237 | } | ||
238 | |||
239 | sprintf (str,"playdemo %s\n", cls.demos[cls.demonum]); | ||
240 | Cbuf_InsertText (str); | ||
241 | cls.demonum++; | ||
242 | } | ||
243 | |||
244 | /* | ||
245 | ============== | ||
246 | CL_PrintEntities_f | ||
247 | ============== | ||
248 | */ | ||
249 | void CL_PrintEntities_f (void) | ||
250 | { | ||
251 | entity_t *ent; | ||
252 | int i; | ||
253 | |||
254 | for (i=0,ent=cl_entities ; i<cl.num_entities ; i++,ent++) | ||
255 | { | ||
256 | Con_Printf ("%3i:",i); | ||
257 | if (!ent->model) | ||
258 | { | ||
259 | Con_Printf ("EMPTY\n"); | ||
260 | continue; | ||
261 | } | ||
262 | Con_Printf ("%s:%2i (%5.1f,%5.1f,%5.1f) [%5.1f %5.1f %5.1f]\n" | ||
263 | ,ent->model->name,ent->frame, ent->origin[0], ent->origin[1], ent->origin[2], ent->angles[0], ent->angles[1], ent->angles[2]); | ||
264 | } | ||
265 | } | ||
266 | |||
267 | |||
268 | /* | ||
269 | =============== | ||
270 | SetPal | ||
271 | |||
272 | Debugging tool, just flashes the screen | ||
273 | =============== | ||
274 | */ | ||
275 | void SetPal (int i) | ||
276 | { | ||
277 | #if 0 | ||
278 | static int old; | ||
279 | byte pal[768]; | ||
280 | int c; | ||
281 | |||
282 | if (i == old) | ||
283 | return; | ||
284 | old = i; | ||
285 | |||
286 | if (i==0) | ||
287 | VID_SetPalette (host_basepal); | ||
288 | else if (i==1) | ||
289 | { | ||
290 | for (c=0 ; c<768 ; c+=3) | ||
291 | { | ||
292 | pal[c] = 0; | ||
293 | pal[c+1] = 255; | ||
294 | pal[c+2] = 0; | ||
295 | } | ||
296 | VID_SetPalette (pal); | ||
297 | } | ||
298 | else | ||
299 | { | ||
300 | for (c=0 ; c<768 ; c+=3) | ||
301 | { | ||
302 | pal[c] = 0; | ||
303 | pal[c+1] = 0; | ||
304 | pal[c+2] = 255; | ||
305 | } | ||
306 | VID_SetPalette (pal); | ||
307 | } | ||
308 | #endif | ||
309 | } | ||
310 | |||
311 | /* | ||
312 | =============== | ||
313 | CL_AllocDlight | ||
314 | |||
315 | =============== | ||
316 | */ | ||
317 | dlight_t *CL_AllocDlight (int key) | ||
318 | { | ||
319 | int i; | ||
320 | dlight_t *dl; | ||
321 | |||
322 | // first look for an exact key match | ||
323 | if (key) | ||
324 | { | ||
325 | dl = cl_dlights; | ||
326 | for (i=0 ; i<MAX_DLIGHTS ; i++, dl++) | ||
327 | { | ||
328 | if (dl->key == key) | ||
329 | { | ||
330 | memset (dl, 0, sizeof(*dl)); | ||
331 | dl->key = key; | ||
332 | return dl; | ||
333 | } | ||
334 | } | ||
335 | } | ||
336 | |||
337 | // then look for anything else | ||
338 | dl = cl_dlights; | ||
339 | for (i=0 ; i<MAX_DLIGHTS ; i++, dl++) | ||
340 | { | ||
341 | if (dl->die < cl.time) | ||
342 | { | ||
343 | memset (dl, 0, sizeof(*dl)); | ||
344 | dl->key = key; | ||
345 | return dl; | ||
346 | } | ||
347 | } | ||
348 | |||
349 | dl = &cl_dlights[0]; | ||
350 | memset (dl, 0, sizeof(*dl)); | ||
351 | dl->key = key; | ||
352 | return dl; | ||
353 | } | ||
354 | |||
355 | |||
356 | /* | ||
357 | =============== | ||
358 | CL_DecayLights | ||
359 | |||
360 | =============== | ||
361 | */ | ||
362 | void CL_DecayLights (void) | ||
363 | { | ||
364 | int i; | ||
365 | dlight_t *dl; | ||
366 | float time; | ||
367 | |||
368 | time = cl.time - cl.oldtime; | ||
369 | |||
370 | dl = cl_dlights; | ||
371 | for (i=0 ; i<MAX_DLIGHTS ; i++, dl++) | ||
372 | { | ||
373 | if (dl->die < cl.time || !dl->radius) | ||
374 | continue; | ||
375 | |||
376 | dl->radius -= time*dl->decay; | ||
377 | if (dl->radius < 0) | ||
378 | dl->radius = 0; | ||
379 | } | ||
380 | } | ||
381 | |||
382 | |||
383 | /* | ||
384 | =============== | ||
385 | CL_LerpPoint | ||
386 | |||
387 | Determines the fraction between the last two messages that the objects | ||
388 | should be put at. | ||
389 | =============== | ||
390 | */ | ||
391 | float CL_LerpPoint (void) | ||
392 | { | ||
393 | float f, frac; | ||
394 | |||
395 | f = cl.mtime[0] - cl.mtime[1]; | ||
396 | |||
397 | if (!f || cl_nolerp.value || cls.timedemo || sv.active) | ||
398 | { | ||
399 | cl.time = cl.mtime[0]; | ||
400 | return 1; | ||
401 | } | ||
402 | |||
403 | if (f > 0.1) | ||
404 | { // dropped packet, or start of demo | ||
405 | cl.mtime[1] = cl.mtime[0] - 0.1; | ||
406 | f = 0.1; | ||
407 | } | ||
408 | frac = (cl.time - cl.mtime[1]) / f; | ||
409 | //Con_Printf ("frac: %f\n",frac); | ||
410 | if (frac < 0) | ||
411 | { | ||
412 | if (frac < -0.01) | ||
413 | { | ||
414 | SetPal(1); | ||
415 | cl.time = cl.mtime[1]; | ||
416 | // Con_Printf ("low frac\n"); | ||
417 | } | ||
418 | frac = 0; | ||
419 | } | ||
420 | else if (frac > 1) | ||
421 | { | ||
422 | if (frac > 1.01) | ||
423 | { | ||
424 | SetPal(2); | ||
425 | cl.time = cl.mtime[0]; | ||
426 | // Con_Printf ("high frac\n"); | ||
427 | } | ||
428 | frac = 1; | ||
429 | } | ||
430 | else | ||
431 | SetPal(0); | ||
432 | |||
433 | return frac; | ||
434 | } | ||
435 | |||
436 | |||
437 | /* | ||
438 | =============== | ||
439 | CL_RelinkEntities | ||
440 | =============== | ||
441 | */ | ||
442 | void CL_RelinkEntities (void) | ||
443 | { | ||
444 | entity_t *ent; | ||
445 | int i, j; | ||
446 | float frac, f, d; | ||
447 | vec3_t delta; | ||
448 | float bobjrotate; | ||
449 | vec3_t oldorg; | ||
450 | dlight_t *dl; | ||
451 | |||
452 | // determine partial update time | ||
453 | frac = CL_LerpPoint (); | ||
454 | |||
455 | cl_numvisedicts = 0; | ||
456 | |||
457 | // | ||
458 | // interpolate player info | ||
459 | // | ||
460 | for (i=0 ; i<3 ; i++) | ||
461 | cl.velocity[i] = cl.mvelocity[1][i] + | ||
462 | frac * (cl.mvelocity[0][i] - cl.mvelocity[1][i]); | ||
463 | |||
464 | if (cls.demoplayback) | ||
465 | { | ||
466 | // interpolate the angles | ||
467 | for (j=0 ; j<3 ; j++) | ||
468 | { | ||
469 | d = cl.mviewangles[0][j] - cl.mviewangles[1][j]; | ||
470 | if (d > 180) | ||
471 | d -= 360; | ||
472 | else if (d < -180) | ||
473 | d += 360; | ||
474 | cl.viewangles[j] = cl.mviewangles[1][j] + frac*d; | ||
475 | } | ||
476 | } | ||
477 | |||
478 | bobjrotate = anglemod(100*cl.time); | ||
479 | |||
480 | // start on the entity after the world | ||
481 | for (i=1,ent=cl_entities+1 ; i<cl.num_entities ; i++,ent++) | ||
482 | { | ||
483 | if (!ent->model) | ||
484 | { // empty slot | ||
485 | if (ent->forcelink) | ||
486 | R_RemoveEfrags (ent); // just became empty | ||
487 | continue; | ||
488 | } | ||
489 | |||
490 | // if the object wasn't included in the last packet, remove it | ||
491 | if (ent->msgtime != cl.mtime[0]) | ||
492 | { | ||
493 | ent->model = NULL; | ||
494 | continue; | ||
495 | } | ||
496 | |||
497 | VectorCopy (ent->origin, oldorg); | ||
498 | |||
499 | if (ent->forcelink) | ||
500 | { // the entity was not updated in the last message | ||
501 | // so move to the final spot | ||
502 | VectorCopy (ent->msg_origins[0], ent->origin); | ||
503 | VectorCopy (ent->msg_angles[0], ent->angles); | ||
504 | } | ||
505 | else | ||
506 | { // if the delta is large, assume a teleport and don't lerp | ||
507 | f = frac; | ||
508 | for (j=0 ; j<3 ; j++) | ||
509 | { | ||
510 | delta[j] = ent->msg_origins[0][j] - ent->msg_origins[1][j]; | ||
511 | if (delta[j] > 100 || delta[j] < -100) | ||
512 | f = 1; // assume a teleportation, not a motion | ||
513 | } | ||
514 | |||
515 | // interpolate the origin and angles | ||
516 | for (j=0 ; j<3 ; j++) | ||
517 | { | ||
518 | ent->origin[j] = ent->msg_origins[1][j] + f*delta[j]; | ||
519 | |||
520 | d = ent->msg_angles[0][j] - ent->msg_angles[1][j]; | ||
521 | if (d > 180) | ||
522 | d -= 360; | ||
523 | else if (d < -180) | ||
524 | d += 360; | ||
525 | ent->angles[j] = ent->msg_angles[1][j] + f*d; | ||
526 | } | ||
527 | |||
528 | } | ||
529 | |||
530 | // rotate binary objects locally | ||
531 | if (ent->model->flags & EF_ROTATE) | ||
532 | ent->angles[1] = bobjrotate; | ||
533 | |||
534 | if (ent->effects & EF_BRIGHTFIELD) | ||
535 | R_EntityParticles (ent); | ||
536 | #ifdef QUAKE2 | ||
537 | if (ent->effects & EF_DARKFIELD) | ||
538 | R_DarkFieldParticles (ent); | ||
539 | #endif | ||
540 | if (ent->effects & EF_MUZZLEFLASH) | ||
541 | { | ||
542 | vec3_t fv, rv, uv; | ||
543 | |||
544 | dl = CL_AllocDlight (i); | ||
545 | VectorCopy (ent->origin, dl->origin); | ||
546 | dl->origin[2] += 16; | ||
547 | AngleVectors (ent->angles, fv, rv, uv); | ||
548 | |||
549 | VectorMA (dl->origin, 18, fv, dl->origin); | ||
550 | dl->radius = 200 + (rand()&31); | ||
551 | dl->minlight = 32; | ||
552 | dl->die = cl.time + 0.1; | ||
553 | } | ||
554 | if (ent->effects & EF_BRIGHTLIGHT) | ||
555 | { | ||
556 | dl = CL_AllocDlight (i); | ||
557 | VectorCopy (ent->origin, dl->origin); | ||
558 | dl->origin[2] += 16; | ||
559 | dl->radius = 400 + (rand()&31); | ||
560 | dl->die = cl.time + 0.001; | ||
561 | } | ||
562 | if (ent->effects & EF_DIMLIGHT) | ||
563 | { | ||
564 | dl = CL_AllocDlight (i); | ||
565 | VectorCopy (ent->origin, dl->origin); | ||
566 | dl->radius = 200 + (rand()&31); | ||
567 | dl->die = cl.time + 0.001; | ||
568 | } | ||
569 | #ifdef QUAKE2 | ||
570 | if (ent->effects & EF_DARKLIGHT) | ||
571 | { | ||
572 | dl = CL_AllocDlight (i); | ||
573 | VectorCopy (ent->origin, dl->origin); | ||
574 | dl->radius = 200.0 + (rand()&31); | ||
575 | dl->die = cl.time + 0.001; | ||
576 | dl->dark = true; | ||
577 | } | ||
578 | if (ent->effects & EF_LIGHT) | ||
579 | { | ||
580 | dl = CL_AllocDlight (i); | ||
581 | VectorCopy (ent->origin, dl->origin); | ||
582 | dl->radius = 200; | ||
583 | dl->die = cl.time + 0.001; | ||
584 | } | ||
585 | #endif | ||
586 | |||
587 | if (ent->model->flags & EF_GIB) | ||
588 | R_RocketTrail (oldorg, ent->origin, 2); | ||
589 | else if (ent->model->flags & EF_ZOMGIB) | ||
590 | R_RocketTrail (oldorg, ent->origin, 4); | ||
591 | else if (ent->model->flags & EF_TRACER) | ||
592 | R_RocketTrail (oldorg, ent->origin, 3); | ||
593 | else if (ent->model->flags & EF_TRACER2) | ||
594 | R_RocketTrail (oldorg, ent->origin, 5); | ||
595 | else if (ent->model->flags & EF_ROCKET) | ||
596 | { | ||
597 | R_RocketTrail (oldorg, ent->origin, 0); | ||
598 | dl = CL_AllocDlight (i); | ||
599 | VectorCopy (ent->origin, dl->origin); | ||
600 | dl->radius = 200; | ||
601 | dl->die = cl.time + 0.01; | ||
602 | } | ||
603 | else if (ent->model->flags & EF_GRENADE) | ||
604 | R_RocketTrail (oldorg, ent->origin, 1); | ||
605 | else if (ent->model->flags & EF_TRACER3) | ||
606 | R_RocketTrail (oldorg, ent->origin, 6); | ||
607 | |||
608 | ent->forcelink = false; | ||
609 | |||
610 | if (i == cl.viewentity && !chase_active.value) | ||
611 | continue; | ||
612 | |||
613 | #ifdef QUAKE2 | ||
614 | if ( ent->effects & EF_NODRAW ) | ||
615 | continue; | ||
616 | #endif | ||
617 | if (cl_numvisedicts < MAX_VISEDICTS) | ||
618 | { | ||
619 | cl_visedicts[cl_numvisedicts] = ent; | ||
620 | cl_numvisedicts++; | ||
621 | } | ||
622 | } | ||
623 | |||
624 | } | ||
625 | |||
626 | |||
627 | /* | ||
628 | =============== | ||
629 | CL_ReadFromServer | ||
630 | |||
631 | Read all incoming data from the server | ||
632 | =============== | ||
633 | */ | ||
634 | int CL_ReadFromServer (void) | ||
635 | { | ||
636 | int ret; | ||
637 | |||
638 | cl.oldtime = cl.time; | ||
639 | cl.time += host_frametime; | ||
640 | |||
641 | do | ||
642 | { | ||
643 | ret = CL_GetMessage (); | ||
644 | if (ret == -1) | ||
645 | Host_Error ("CL_ReadFromServer: lost server connection"); | ||
646 | if (!ret) | ||
647 | break; | ||
648 | |||
649 | cl.last_received_message = realtime; | ||
650 | CL_ParseServerMessage (); | ||
651 | } while (ret && cls.state == ca_connected); | ||
652 | |||
653 | if (cl_shownet.value) | ||
654 | Con_Printf ("\n"); | ||
655 | |||
656 | CL_RelinkEntities (); | ||
657 | CL_UpdateTEnts (); | ||
658 | |||
659 | // | ||
660 | // bring the links up to date | ||
661 | // | ||
662 | return 0; | ||
663 | } | ||
664 | |||
665 | /* | ||
666 | ================= | ||
667 | CL_SendCmd | ||
668 | ================= | ||
669 | */ | ||
670 | void CL_SendCmd (void) | ||
671 | { | ||
672 | usercmd_t cmd; | ||
673 | |||
674 | if (cls.state != ca_connected) | ||
675 | return; | ||
676 | |||
677 | if (cls.signon == SIGNONS) | ||
678 | { | ||
679 | // get basic movement from keyboard | ||
680 | CL_BaseMove (&cmd); | ||
681 | |||
682 | // allow mice or other external controllers to add to the move | ||
683 | IN_Move (&cmd); | ||
684 | |||
685 | // send the unreliable message | ||
686 | CL_SendMove (&cmd); | ||
687 | |||
688 | } | ||
689 | |||
690 | if (cls.demoplayback) | ||
691 | { | ||
692 | SZ_Clear (&cls.message); | ||
693 | return; | ||
694 | } | ||
695 | |||
696 | // send the reliable message | ||
697 | if (!cls.message.cursize) | ||
698 | return; // no message at all | ||
699 | |||
700 | if (!NET_CanSendMessage (cls.netcon)) | ||
701 | { | ||
702 | Con_DPrintf ("CL_WriteToServer: can't send\n"); | ||
703 | return; | ||
704 | } | ||
705 | |||
706 | if (NET_SendMessage (cls.netcon, &cls.message) == -1) | ||
707 | Host_Error ("CL_WriteToServer: lost server connection"); | ||
708 | |||
709 | SZ_Clear (&cls.message); | ||
710 | } | ||
711 | |||
712 | /* | ||
713 | ================= | ||
714 | CL_Init | ||
715 | ================= | ||
716 | */ | ||
717 | void CL_Init (void) | ||
718 | { | ||
719 | SZ_Alloc (&cls.message, 1024); | ||
720 | |||
721 | CL_InitInput (); | ||
722 | CL_InitTEnts (); | ||
723 | |||
724 | // | ||
725 | // register our commands | ||
726 | // | ||
727 | Cvar_RegisterVariable (&cl_name); | ||
728 | Cvar_RegisterVariable (&cl_color); | ||
729 | Cvar_RegisterVariable (&cl_upspeed); | ||
730 | Cvar_RegisterVariable (&cl_forwardspeed); | ||
731 | Cvar_RegisterVariable (&cl_backspeed); | ||
732 | Cvar_RegisterVariable (&cl_sidespeed); | ||
733 | Cvar_RegisterVariable (&cl_movespeedkey); | ||
734 | Cvar_RegisterVariable (&cl_yawspeed); | ||
735 | Cvar_RegisterVariable (&cl_pitchspeed); | ||
736 | Cvar_RegisterVariable (&cl_anglespeedkey); | ||
737 | Cvar_RegisterVariable (&cl_shownet); | ||
738 | Cvar_RegisterVariable (&cl_nolerp); | ||
739 | Cvar_RegisterVariable (&lookspring); | ||
740 | Cvar_RegisterVariable (&lookstrafe); | ||
741 | Cvar_RegisterVariable (&sensitivity); | ||
742 | |||
743 | Cvar_RegisterVariable (&m_pitch); | ||
744 | Cvar_RegisterVariable (&m_yaw); | ||
745 | Cvar_RegisterVariable (&m_forward); | ||
746 | Cvar_RegisterVariable (&m_side); | ||
747 | |||
748 | // Cvar_RegisterVariable (&cl_autofire); | ||
749 | |||
750 | Cmd_AddCommand ("entities", CL_PrintEntities_f); | ||
751 | Cmd_AddCommand ("disconnect", CL_Disconnect_f); | ||
752 | Cmd_AddCommand ("record", CL_Record_f); | ||
753 | Cmd_AddCommand ("stop", CL_Stop_f); | ||
754 | Cmd_AddCommand ("playdemo", CL_PlayDemo_f); | ||
755 | Cmd_AddCommand ("timedemo", CL_TimeDemo_f); | ||
756 | } | ||
757 | |||