?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Initial sauer
[SauerbratenRemote.git] / src / fpsgame / capture.h
bloba9c30cff82dfaa0249cba85add1c98d701af98f2
1 // capture.h: client and server state for capture gamemode
2
3 struct capturestate
4 {
5 static const int CAPTURERADIUS = 64;
6 static const int CAPTUREHEIGHT = 24;
7 static const int OCCUPYPOINTS = 15;
8 static const int OCCUPYLIMIT = 100;
9 static const int CAPTURESCORE = 1;
10 static const int SCORESECS = 10;
11 static const int AMMOSECS = 15;
12 static const int REGENSECS = 1;
13 static const int REGENHEALTH = 10;
14 static const int REGENARMOUR = 10;
15 static const int REGENAMMO = 20;
16 static const int MAXAMMO = 5;
17 static const int REPAMMODIST = 32;
18 static const int RESPAWNSECS = 10;
19
20 struct baseinfo
21 {
22 vec o;
23 string owner, enemy;
24 #ifndef CAPTURESERV
25 string name, info;
26 extentity *ent;
27 #endif
28 int ammotype, ammo, owners, enemies, converted, capturetime;
29
30 baseinfo() { reset(); }
31
32 void noenemy()
33 {
34 enemy[0] = '\0';
35 enemies = 0;
36 converted = 0;
37 }
38
39 void reset()
40 {
41 noenemy();
42 owner[0] = '\0';
43 capturetime = -1;
44 ammotype = 0;
45 ammo = 0;
46 owners = 0;
47 }
48
49 bool enter(const char *team)
50 {
51 if(!strcmp(owner, team))
52 {
53 owners++;
54 return false;
55 }
56 if(!enemies)
57 {
58 if(strcmp(enemy, team))
59 {
60 converted = 0;
61 s_strcpy(enemy, team);
62 }
63 enemies++;
64 return true;
65 }
66 else if(strcmp(enemy, team)) return false;
67 else enemies++;
68 return false;
69 }
70
71 bool steal(const char *team)
72 {
73 return !enemies && strcmp(owner, team);
74 }
75
76 bool leave(const char *team)
77 {
78 if(!strcmp(owner, team))
79 {
80 owners--;
81 return false;
82 }
83 if(strcmp(enemy, team)) return false;
84 enemies--;
85 return !enemies;
86 }
87
88 int occupy(const char *team, int units)
89 {
90 if(strcmp(enemy, team)) return -1;
91 converted += units;
92 if(units<0)
93 {
94 if(converted<=0) noenemy();
95 return -1;
96 }
97 else if(converted<(owner[0] ? 2 : 1)*OCCUPYLIMIT) return -1;
98 if(owner[0]) { owner[0] = '\0'; converted = 0; s_strcpy(enemy, team); return 0; }
99 else { s_strcpy(owner, team); ammo = 0; capturetime = 0; owners = enemies; noenemy(); return 1; }
100 }
101
102 bool addammo(int i)
103 {
104 if(ammo>=MAXAMMO) return false;
105 ammo = min(ammo+i, MAXAMMO);
106 return true;
107 }
108
109 bool takeammo(const char *team)
110 {
111 if(strcmp(owner, team) || ammo<=0) return false;
112 ammo--;
113 return true;
114 }
115 };
116
117 vector<baseinfo> bases;
118
119 struct score
120 {
121 string team;
122 int total;
123 };
124
125 vector<score> scores;
126
127 int captures;
128
129 capturestate() : captures(0) {}
130
131 void reset()
132 {
133 bases.setsize(0);
134 scores.setsize(0);
135 captures = 0;
136 }
137
138 score &findscore(const char *team)
139 {
140 loopv(scores)
141 {
142 score &cs = scores[i];
143 if(!strcmp(cs.team, team)) return cs;
144 }
145 score &cs = scores.add();
146 s_strcpy(cs.team, team);
147 cs.total = 0;
148 return cs;
149 }
150
151 void addbase(int ammotype, const vec &o)
152 {
153 baseinfo &b = bases.add();
154 b.ammotype = ammotype ? ammotype : rnd(5)+1;
155 b.o = o;
156 }
157
158 void initbase(int i, int ammotype, const char *owner, const char *enemy, int converted, int ammo)
159 {
160 if(!bases.inrange(i)) return;
161 baseinfo &b = bases[i];
162 b.ammotype = ammotype;
163 s_strcpy(b.owner, owner);
164 s_strcpy(b.enemy, enemy);
165 b.converted = converted;
166 b.ammo = ammo;
167 }
168
169 bool hasbases(const char *team)
170 {
171 loopv(bases)
172 {
173 baseinfo &b = bases[i];
174 if(b.owner[0] && !strcmp(b.owner, team)) return true;
175 }
176 return false;
177 }
178
179 float disttoenemy(baseinfo &b)
180 {
181 float dist = 1e10f;
182 loopv(bases)
183 {
184 baseinfo &e = bases[i];
185 if(e.owner[0] && strcmp(b.owner, e.owner))
186 dist = min(dist, b.o.dist(e.o));
187 }
188 return dist;
189 }
190
191 bool insidebase(const baseinfo &b, const vec &o)
192 {
193 float dx = (b.o.x-o.x), dy = (b.o.y-o.y), dz = (b.o.z-o.z+14);
194 return dx*dx + dy*dy <= CAPTURERADIUS*CAPTURERADIUS && fabs(dz) <= CAPTUREHEIGHT;
195 }
196 };
197
198 #ifndef CAPTURESERV
199
200 struct captureclient : capturestate
201 {
202 fpsclient &cl;
203 float radarscale;
204
205 captureclient(fpsclient &cl) : cl(cl), radarscale(0)
206 {
207 CCOMMAND(repammo, "", (captureclient *self), self->replenishammo());
208 }
209
210 void replenishammo()
211 {
212 int gamemode = cl.gamemode;
213 if(m_noitems) return;
214 loopv(bases)
215 {
216 baseinfo &b = bases[i];
217 if(b.ammotype>0 && b.ammotype<=I_CARTRIDGES-I_SHELLS+1 && insidebase(b, cl.player1->o) && cl.player1->hasmaxammo(b.ammotype-1+I_SHELLS)) return;
218 }
219 cl.cc.addmsg(SV_REPAMMO, "r");
220 }
221
222 void receiveammo(int type)
223 {
224 type += I_SHELLS-1;
225 if(type<I_SHELLS || type>I_CARTRIDGES) return;
226 cl.et.repammo(cl.player1, type);
227 }
228
229 void renderbases()
230 {
231 int gamemode = cl.gamemode;
232 loopv(bases)
233 {
234 baseinfo &b = bases[i];
235 const char *flagname = b.owner[0] ? (strcmp(b.owner, cl.player1->team) ? "flags/red" : "flags/blue") : "flags/neutral";
236 rendermodel(b.ent->color, b.ent->dir, flagname, ANIM_MAPMODEL|ANIM_LOOP, 0, 0, b.o, 0, 0, 0, 0, NULL, MDL_SHADOW | MDL_CULL_VFC | MDL_CULL_OCCLUDED);
237 if(b.ammotype>0 && b.ammotype<=I_CARTRIDGES-I_SHELLS+1) loopi(m_noitemsrail ? 0 : (m_noitems ? 1 : b.ammo))
238 {
239 float angle = 2*M_PI*(cl.lastmillis/4000.0f + i/float(MAXAMMO));
240 vec p(b.o);
241 p.x += 10*cosf(angle);
242 p.y += 10*sinf(angle);
243 p.z += 4;
244 rendermodel(b.ent->color, b.ent->dir, cl.et.entmdlname(I_SHELLS+b.ammotype-1), ANIM_MAPMODEL|ANIM_LOOP, 0, 0, p, 0, 0, 0, 0, NULL, MDL_SHADOW | MDL_CULL_VFC | MDL_CULL_OCCLUDED);
245 }
246 int ttype = 11, mtype = -1;
247 if(b.owner[0])
248 {
249 bool isowner = !strcmp(b.owner, cl.player1->team);
250 if(b.enemy[0])
251 {
252 s_sprintf(b.info)("\f%d%s \f0vs. \f%d%s", isowner ? 3 : 1, b.enemy, isowner ? 1 : 3, b.owner);
253 mtype = isowner ? 19 : 20;
254 }
255 else { s_sprintf(b.info)("%s", b.owner); ttype = isowner ? 16 : 13; }
256 }
257 else if(b.enemy[0])
258 {
259 s_sprintf(b.info)("%s", b.enemy);
260 if(strcmp(b.enemy, cl.player1->team)) { ttype = 13; mtype = 17; }
261 else { ttype = 16; mtype = 18; }
262 }
263 else b.info[0] = '\0';
264 vec above(b.o);
265 abovemodel(above, flagname);
266 above.z += 2.0f;
267 particle_text(above, b.info, ttype, 1);
268 if(mtype>=0)
269 {
270 above.z += 3.0f;
271 particle_meter(above, b.converted/float((b.owner[0] ? 2 : 1) * OCCUPYLIMIT), mtype, 1);
272 }
273 }
274 }
275
276 void drawradar(float x, float y, float s)
277 {
278 glTexCoord2f(0.0f, 0.0f); glVertex2f(x, y);
279 glTexCoord2f(1.0f, 0.0f); glVertex2f(x+s, y);
280 glTexCoord2f(1.0f, 1.0f); glVertex2f(x+s, y+s);
281 glTexCoord2f(0.0f, 1.0f); glVertex2f(x, y+s);
282 }
283
284 void drawblips(int x, int y, int s, int type, bool skipenemy = false)
285 {
286 const char *textures[3] = {"data/blip_red.png", "data/blip_grey.png", "data/blip_blue.png"};
287 settexture(textures[max(type+1, 0)]);
288 glBegin(GL_QUADS);
289 float scale = radarscale<=0 || radarscale>cl.maxradarscale() ? cl.maxradarscale() : radarscale;
290 loopv(bases)
291 {
292 baseinfo &b = bases[i];
293 if(skipenemy && b.enemy[0]) continue;
294 switch(type)
295 {
296 case 1: if(!b.owner[0] || strcmp(b.owner, cl.player1->team)) continue; break;
297 case 0: if(b.owner[0]) continue; break;
298 case -1: if(!b.owner[0] || !strcmp(b.owner, cl.player1->team)) continue; break;
299 case -2: if(!b.enemy[0] || !strcmp(b.enemy, cl.player1->team)) continue; break;
300 }
301 vec dir(b.o);
302 dir.sub(cl.player1->o);
303 dir.z = 0.0f;
304 float dist = dir.magnitude();
305 if(dist >= scale) dir.mul(scale/dist);
306 dir.rotate_around_z(-cl.player1->yaw*RAD);
307 drawradar(x + s*0.5f*0.95f*(1.0f+dir.x/scale), y + s*0.5f*0.95f*(1.0f+dir.y/scale), 0.05f*s);
308 }
309 glEnd();
310 }
311
312 int respawnwait()
313 {
314 int gamemode = cl.gamemode;
315 if(m_regencapture) return -1;
316 return max(0, (m_noitemsrail ? RESPAWNSECS/2 : RESPAWNSECS)-(cl.lastmillis-cl.player1->lastpain)/1000);
317 }
318
319 void capturehud(int w, int h)
320 {
321 glEnable(GL_BLEND);
322 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
323 int x = 1800*w/h*34/40, y = 1800*1/40, s = 1800*w/h*5/40;
324 glColor3f(1, 1, 1);
325 settexture("data/radar.png");
326 glBegin(GL_QUADS);
327 drawradar(float(x), float(y), float(s));
328 glEnd();
329 bool showenemies = cl.lastmillis%1000 >= 500;
330 drawblips(x, y, s, 1, showenemies);
331 drawblips(x, y, s, 0, showenemies);
332 drawblips(x, y, s, -1, showenemies);
333 if(showenemies) drawblips(x, y, s, -2);
334 if(cl.player1->state == CS_DEAD)
335 {
336 int wait = respawnwait();
337 if(wait>=0)
338 {
339 glPushMatrix();
340 glLoadIdentity();
341 glOrtho(0, w*900/h, 900, 0, -1, 1);
342 draw_textf("%d", (x+s/2)/2-(wait>=10 ? 28 : 16), (y+s/2)/2-32, wait);
343 glPopMatrix();
344 }
345 }
346 glDisable(GL_BLEND);
347 }
348
349 void setupbases()
350 {
351 reset();
352 loopv(cl.et.ents)
353 {
354 extentity *e = cl.et.ents[i];
355 if(e->type!=BASE) continue;
356 baseinfo &b = bases.add();
357 b.o = e->o;
358 b.ammotype = e->attr1;
359 s_sprintfd(alias)("base_%d", e->attr2);
360 const char *name = getalias(alias);
361 if(name[0]) s_strcpy(b.name, name); else s_sprintf(b.name)("base %d", bases.length());
362 b.ent = e;
363 }
364 vec center(0, 0, 0);
365 loopv(bases) center.add(bases[i].o);
366 center.div(bases.length());
367 radarscale = 0;
368 loopv(bases) radarscale = max(radarscale, 2*center.dist(bases[i].o));
369 }
370
371 void sendbases(ucharbuf &p)
372 {
373 putint(p, SV_BASES);
374 loopv(bases)
375 {
376 baseinfo &b = bases[i];
377 putint(p, max(b.ammotype, 0));
378 putint(p, int(b.o.x*DMF));
379 putint(p, int(b.o.y*DMF));
380 putint(p, int(b.o.z*DMF));
381 }
382 putint(p, -1);
383 }
384
385 void updatebase(int i, const char *owner, const char *enemy, int converted, int ammo)
386 {
387 if(!bases.inrange(i)) return;
388 baseinfo &b = bases[i];
389 if(owner[0])
390 {
391 if(strcmp(b.owner, owner))
392 {
393 conoutf("\f2%s captured %s", owner, b.name);
394 if(!strcmp(owner, cl.player1->team)) playsound(S_V_BASECAP);
395 }
396 }
397 else if(b.owner[0])
398 {
399 conoutf("\f2%s lost %s", b.owner, b.name);
400 if(!strcmp(b.owner, cl.player1->team)) playsound(S_V_BASELOST);
401 }
402 s_strcpy(b.owner, owner);
403 s_strcpy(b.enemy, enemy);
404 b.converted = converted;
405 if(ammo>b.ammo) playsound(S_ITEMSPAWN, &b.o);
406 b.ammo = ammo;
407 }
408
409 void setscore(const char *team, int total)
410 {
411 findscore(team).total = total;
412 if(total>=10000) conoutf("team %s captured all bases", team);
413 }
414
415 int closesttoenemy(const char *team, bool noattacked = false, bool farthest = false)
416 {
417 float bestdist = farthest ? -1e10f : 1e10f;
418 int best = -1;
419 int attackers = INT_MAX, attacked = -1;
420 loopv(bases)
421 {
422 baseinfo &b = bases[i];
423 if(!b.owner[0] || strcmp(b.owner, team)) continue;
424 if(noattacked && b.enemy[0]) continue;
425 float dist = disttoenemy(b);
426 if(farthest ? dist > bestdist : dist < bestdist)
427 {
428 best = i;
429 bestdist = dist;
430 }
431 else if(b.enemy[0] && b.enemies < attackers)
432 {
433 attacked = i;
434 attackers = b.enemies;
435 }
436 }
437 if(best < 0) return attacked;
438 return best;
439 }
440
441 int pickspawn(const char *team)
442 {
443 int gamemode = cl.gamemode, closest = closesttoenemy(team, true, m_regencapture);
444 if(!m_regencapture && closest < 0) closest = closesttoenemy(team, false);
445 if(closest < 0) return -1;
446 baseinfo &b = bases[closest];
447
448 float bestdist = 1e10f, altdist = 1e10f;
449 int best = -1, alt = -1;
450 loopv(cl.et.ents)
451 {
452 extentity *e = cl.et.ents[i];
453 if(e->type!=PLAYERSTART) continue;
454 float dist = e->o.dist(b.o);
455 if(dist < bestdist)
456 {
457 alt = best;
458 altdist = bestdist;
459 best = i;
460 bestdist = dist;
461 }
462 else if(dist < altdist)
463 {
464 alt = i;
465 altdist = dist;
466 }
467 }
468 return rnd(2) ? best : alt;
469 }
470 };
471
472 #else
473
474 struct captureservmode : capturestate, servmode
475 {
476 int scoresec;
477 bool notgotbases;
478
479 captureservmode(fpsserver &sv) : servmode(sv), scoresec(0), notgotbases(false) {}
480
481 void reset(bool empty)
482 {
483 capturestate::reset();
484 scoresec = 0;
485 notgotbases = !empty;
486 }
487
488 void stealbase(int n, const char *team)
489 {
490 baseinfo &b = bases[n];
491 loopv(sv.clients)
492 {
493 fpsserver::clientinfo *ci = sv.clients[i];
494 if(!ci->spectator && ci->state.state==CS_ALIVE && ci->team[0] && !strcmp(ci->team, team) && insidebase(b, ci->state.o))
495 b.enter(ci->team);
496 }
497 sendbaseinfo(n);
498 }
499
500 void replenishammo(clientinfo *ci)
501 {
502 int gamemode = sv.gamemode;
503 if(m_noitems || notgotbases || ci->state.state!=CS_ALIVE || !ci->team[0]) return;
504 loopv(bases)
505 {
506 baseinfo &b = bases[i];
507 if(b.ammotype>0 && b.ammotype<=I_CARTRIDGES-I_SHELLS+1 && insidebase(b, ci->state.o) && !ci->state.hasmaxammo(b.ammotype-1+I_SHELLS) && b.takeammo(ci->team))
508 {
509 sendbaseinfo(i);
510 sendf(ci->clientnum, 1, "rii", SV_REPAMMO, b.ammotype);
511 ci->state.addammo(b.ammotype);
512 break;
513 }
514 }
515 }
516
517 void movebases(const char *team, const vec &oldpos, const vec &newpos)
518 {
519 if(!team[0] || sv.minremain<0) return;
520 loopv(bases)
521 {
522 baseinfo &b = bases[i];
523 bool leave = insidebase(b, oldpos),
524 enter = insidebase(b, newpos);
525 if(leave && !enter && b.leave(team)) sendbaseinfo(i);
526 else if(enter && !leave && b.enter(team)) sendbaseinfo(i);
527 else if(leave && enter && b.steal(team)) stealbase(i, team);
528 }
529 }
530
531 void leavebases(const char *team, const vec &o)
532 {
533 movebases(team, o, vec(-1e10f, -1e10f, -1e10f));
534 }
535
536 void enterbases(const char *team, const vec &o)
537 {
538 movebases(team, vec(-1e10f, -1e10f, -1e10f), o);
539 }
540
541 void addscore(const char *team, int n)
542 {
543 if(!n) return;
544 score &cs = findscore(team);
545 cs.total += n;
546 sendf(-1, 1, "risi", SV_TEAMSCORE, team, cs.total);
547 }
548
549 void regenowners(baseinfo &b, int ticks)
550 {
551 loopv(sv.clients)
552 {
553 fpsserver::clientinfo *ci = sv.clients[i];
554 if(!ci->spectator && ci->state.state==CS_ALIVE && ci->team[0] && !strcmp(ci->team, b.owner) && insidebase(b, ci->state.o))
555 {
556 bool notify = false;
557 if(ci->state.health < ci->state.maxhealth)
558 {
559 ci->state.health = min(ci->state.health + ticks*REGENHEALTH, ci->state.maxhealth);
560 notify = true;
561 }
562 if(ci->state.armour < itemstats[I_GREENARMOUR-I_SHELLS].max)
563 {
564 ci->state.armour = min(ci->state.armour + ticks*REGENARMOUR, itemstats[I_GREENARMOUR-I_SHELLS].max);
565 notify = true;
566 }
567 if(b.ammotype>0)
568 {
569 int ammotype = b.ammotype-1+I_SHELLS;
570 if(ammotype<=I_CARTRIDGES && !ci->state.hasmaxammo(ammotype))
571 {
572 ci->state.addammo(b.ammotype, ticks*REGENAMMO, 100);
573 notify = true;
574 }
575 }
576 if(notify)
577 sendf(ci->clientnum, 1, "ri5", SV_BASEREGEN, ci->state.health, ci->state.armour, b.ammotype, b.ammotype>0 ? ci->state.ammo[b.ammotype] : 0);
578 }
579 }
580 }
581
582 void update()
583 {
584 if(sv.minremain<0) return;
585 endcheck();
586 int t = sv.gamemillis/1000 - (sv.gamemillis-sv.curtime)/1000;
587 if(t<1) return;
588 int gamemode = sv.gamemode;
589 loopv(bases)
590 {
591 baseinfo &b = bases[i];
592 if(b.enemy[0])
593 {
594 if((!b.owners || !b.enemies) && b.occupy(b.enemy, (m_noitemsrail ? OCCUPYPOINTS*2 : OCCUPYPOINTS)*(b.enemies ? b.enemies : -(1+b.owners))*t)==1) addscore(b.owner, CAPTURESCORE);
595 sendbaseinfo(i);
596 }
597 else if(b.owner[0])
598 {
599 b.capturetime += t;
600 int score = b.capturetime/SCORESECS - (b.capturetime-t)/SCORESECS;
601 if(score) addscore(b.owner, score);
602 if(m_noitems)
603 {
604 if(!m_noitemsrail)
605 {
606 int regen = b.capturetime/REGENSECS - (b.capturetime-t)/REGENSECS;
607 if(regen) regenowners(b, regen);
608 }
609 }
610 else
611 {
612 int ammo = b.capturetime/AMMOSECS - (b.capturetime-t)/AMMOSECS;
613 if(ammo && b.addammo(ammo)) sendbaseinfo(i);
614 }
615 }
616 }
617 }
618
619 void sendbaseinfo(int i)
620 {
621 baseinfo &b = bases[i];
622 sendf(-1, 1, "riissii", SV_BASEINFO, i, b.owner, b.enemy, b.enemy[0] ? b.converted : 0, b.owner[0] ? b.ammo : 0);
623 }
624
625 void sendbases()
626 {
627 ENetPacket *packet = enet_packet_create(NULL, MAXTRANS, ENET_PACKET_FLAG_RELIABLE);
628 ucharbuf p(packet->data, packet->dataLength);
629 initclient(NULL, p, false);
630 enet_packet_resize(packet, p.length());
631 sendpacket(-1, 1, packet);
632 if(!packet->referenceCount) enet_packet_destroy(packet);
633 }
634
635 void initclient(clientinfo *ci, ucharbuf &p, bool connecting)
636 {
637 if(connecting) loopv(scores)
638 {
639 score &cs = scores[i];
640 putint(p, SV_TEAMSCORE);
641 sendstring(cs.team, p);
642 putint(p, cs.total);
643 }
644 putint(p, SV_BASES);
645 loopv(bases)
646 {
647 baseinfo &b = bases[i];
648 putint(p, min(max(b.ammotype, 1), I_CARTRIDGES+1));
649 sendstring(b.owner, p);
650 sendstring(b.enemy, p);
651 putint(p, b.converted);
652 putint(p, b.ammo);
653 }
654 putint(p, -1);
655 }
656
657 void endcheck()
658 {
659 const char *lastteam = NULL;
660
661 loopv(bases)
662 {
663 baseinfo &b = bases[i];
664 if(b.owner[0])
665 {
666 if(!lastteam) lastteam = b.owner;
667 else if(strcmp(lastteam, b.owner))
668 {
669 lastteam = false;
670 break;
671 }
672 }
673 else
674 {
675 lastteam = false;
676 break;
677 }
678 }
679
680 if(!lastteam) return;
681 findscore(lastteam).total = 10000;
682 sendf(-1, 1, "risi", SV_TEAMSCORE, lastteam, 10000);
683 sv.startintermission();
684 }
685
686 void entergame(clientinfo *ci)
687 {
688 if(notgotbases || ci->state.state!=CS_ALIVE) return;
689 enterbases(ci->team, ci->state.o);
690 }
691
692 void spawned(clientinfo *ci)
693 {
694 if(notgotbases) return;
695 enterbases(ci->team, ci->state.o);
696 }
697
698 void leavegame(clientinfo *ci, bool disconnecting = false)
699 {
700 if(notgotbases || ci->state.state!=CS_ALIVE) return;
701 leavebases(ci->team, ci->state.o);
702 }
703
704 void died(clientinfo *ci, clientinfo *actor)
705 {
706 if(notgotbases) return;
707 leavebases(ci->team, ci->state.o);
708 }
709
710 void moved(clientinfo *ci, const vec &oldpos, const vec &newpos)
711 {
712 if(notgotbases) return;
713 movebases(ci->team, oldpos, newpos);
714 }
715
716 void changeteam(clientinfo *ci, const char *oldteam, const char *newteam)
717 {
718 if(notgotbases) return;
719 leavebases(oldteam, ci->state.o);
720 enterbases(newteam, ci->state.o);
721 }
722
723 void parsebases(ucharbuf &p)
724 {
725 int ammotype;
726 while((ammotype = getint(p))>=0)
727 {
728 vec o;
729 o.x = getint(p)/DMF;
730 o.y = getint(p)/DMF;
731 o.z = getint(p)/DMF;
732 if(notgotbases) addbase(ammotype>=GUN_SG && ammotype<=GUN_PISTOL ? ammotype : 0, o);
733 }
734 if(notgotbases)
735 {
736 notgotbases = false;
737 sendbases();
738 loopv(sv.clients) if(sv.clients[i]->state.state==CS_ALIVE) entergame(sv.clients[i]);
739 }
740 }
741 };
742
743 #endif
744
Remote scripting for Sauerbraten