home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2007 September / maximum-cd-2007-09.iso / Assets / data / AssaultCube_v0.93.exe / source / src / clientgame.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2007-06-05  |  18.5 KB  |  674 lines
  1. // clientgame.cpp: core game related stuff
  2.  
  3. #include "cube.h"
  4. #include "bot/bot.h"
  5.  
  6. int nextmode = 0;         // nextmode becomes gamemode after next map load
  7. VAR(gamemode, 1, 0, 0);
  8.  
  9. flaginfo flaginfos[2];
  10.  
  11. void mode(int n) 
  12. {
  13.     if(m_mp(n) || !multiplayer()) addmsg(SV_GAMEMODE, "ri", nextmode = n); 
  14. }
  15. COMMAND(mode, ARG_1INT);
  16.  
  17. bool intermission = false;
  18. bool autoteambalance = false;
  19.  
  20. playerent *player1 = newplayerent();          // our client
  21. vector<playerent *> players;                        // other clients
  22.  
  23. int lastmillis = 0;
  24. int curtime;
  25. string clientmap;
  26.  
  27. extern int framesinmap;
  28.  
  29. char *getclientmap() { return clientmap; }
  30.  
  31. extern bool c2sinit, senditemstoserver;
  32. extern int dblend;
  33.  
  34. void setskin(playerent *pl, uint skin)
  35. { 
  36.     if(!pl) return;
  37.     if(pl == player1) c2sinit=false;
  38.     const int maxskin[2] = { 3, 5 };
  39.     pl->skin = skin % (maxskin[team_int(pl->team)]+1);
  40. }
  41.  
  42. bool duplicatename(playerent *d, char *name = NULL)
  43. {
  44.     if(!name) name = d->name;
  45.     if(d!=player1 && !strcmp(name, player1->name)) return true;
  46.     loopv(players) if(players[i] && d!=players[i] && !strcmp(name, players[i]->name)) return true;
  47.     return false;
  48. }
  49.  
  50. char *colorname(playerent *d, int num, char *name, char *prefix)
  51. {
  52.     if(!name) name = d->name;
  53.     if(name[0] && !duplicatename(d, name)) return name;
  54.     static string cname[4];
  55.     s_sprintf(cname[num])("%s%s \fs\f6(%d)\fr", prefix, name, d->clientnum);
  56.     return cname[num];
  57. }
  58.  
  59. void newname(char *name) 
  60. {
  61.     if(name[0])
  62.     {
  63.         c2sinit = false; 
  64.         filtertext(player1->name, name, false, MAXNAMELEN);
  65.         if(!player1->name[0]) s_strcpy(player1->name, "unarmed");
  66.     }
  67.     else conoutf("your name is: %s", player1->name);
  68. }   
  69.     
  70. int smallerteam()
  71. {
  72.     int teamsize[2] = {0, 0};
  73.     loopv(players) if(players[i]) teamsize[team_int(players[i]->team)]++;
  74.     teamsize[team_int(player1->team)]++;
  75.     if(teamsize[0] == teamsize[1]) return -1;
  76.     return teamsize[0] < teamsize[1] ? 0 : 1;
  77. }
  78.     
  79. void changeteam(int team) // force team and respawn
  80. {
  81.     c2sinit = false;
  82.     if(m_ctf) tryflagdrop(NULL);
  83.     filtertext(player1->team, team_string(team), false, MAXTEAMLEN);
  84.     deathstate(player1);
  85. }
  86.  
  87. void newteam(char *name)
  88. {
  89.     if(name[0])
  90.     {
  91.         if(m_teammode)
  92.         {
  93.             if(!strcmp(name, player1->team)) return; // same team
  94.             if(!team_valid(name)) { conoutf("\f3\"%s\" is not a valid team name (try CLA or RVSF)", name); return; }
  95.  
  96.             bool checkteamsize =  autoteambalance && players.length() >= 1 && !m_botmode;
  97.             int freeteam = smallerteam();
  98.  
  99.             if(team_valid(name))
  100.             {
  101.                 int team = team_int(name);
  102.                 if(checkteamsize && team != freeteam)
  103.                 {
  104.                     conoutf("\f3the %s team is already full", name);
  105.                     return;
  106.                 }
  107.                 changeteam(team);
  108.             }
  109.             else changeteam(checkteamsize ? (uint)freeteam : rnd(2)); // random assignement
  110.         }
  111.     }
  112.     else conoutf("your team is: %s", player1->team);
  113. }
  114.  
  115. void newskin(int skin) { player1->nextskin = skin; }
  116.  
  117. COMMANDN(team, newteam, ARG_1STR);
  118. COMMANDN(name, newname, ARG_1STR);
  119. COMMANDN(skin, newskin, ARG_1INT);
  120.  
  121. extern void thrownade(playerent *d, const vec &vel, bounceent *p);
  122.  
  123. void deathstate(playerent *pl)
  124. {
  125.     pl->lastaction = lastmillis;
  126.     pl->attacking = false;
  127.     pl->state = CS_DEAD;
  128.     pl->pitch = 0;
  129.     pl->roll = 60;
  130.     pl->strafe = 0;
  131.     dblend = 0;
  132.     if(pl == player1 && pl->inhandnade) thrownade(pl, vec(0,0,0), pl->inhandnade);
  133. }
  134.  
  135. void spawnstate(playerent *d)              // reset player state not persistent accross spawns
  136. {
  137.     d->respawn();
  138.     //d->lastaction = lastmillis;
  139.     if(d==player1) 
  140.     {
  141.         gun_changed = true;
  142.         if(player1->skin!=player1->nextskin) setskin(player1, player1->nextskin);
  143.         setscope(false);
  144.     }
  145.     equip(d);
  146.     if(m_osok) d->health = 1;
  147. }
  148.     
  149. playerent *newplayerent()                 // create a new blank player
  150. {
  151.     playerent *d = new playerent;
  152.     d->lastupdate = lastmillis;
  153.     setskin(d, rnd(6));
  154.     spawnstate(d);
  155.     return d;
  156. }
  157.  
  158. botent *newbotent()                 // create a new blank player
  159. {
  160.     botent *d = new botent;
  161.     d->lastupdate = lastmillis;
  162.     setskin(d, rnd(6));
  163.     spawnstate(d);
  164.     loopv(players) if(i!=getclientnum() && !players[i])
  165.     {
  166.         players[i] = d;
  167.         d->clientnum = i;
  168.         return d;
  169.     }
  170.     if(players.length()==getclientnum()) players.add(NULL);
  171.     d->clientnum = players.length();
  172.     players.add(d);
  173.     return d;
  174. }
  175.  
  176. void freebotent(botent *d)
  177. {
  178.     loopv(players) if(players[i]==d)
  179.     {
  180.         DELETEP(players[i]);
  181.     }
  182. }
  183.  
  184.  
  185.  
  186. void respawnself()
  187. {
  188.     spawnplayer(player1);
  189.     showscores(false);
  190. }
  191.  
  192. void respawn()
  193. {
  194.     if(player1->state==CS_DEAD && lastmillis>player1->lastpain+(m_ctf ? 5000 : 2000))
  195.     { 
  196.         player1->attacking = false;
  197.         if(m_arena) { conoutf("waiting for new round to start..."); return; }
  198.         respawnself();
  199.         weaponswitch(player1->primary);
  200.         player1->lastaction -= WEAPONCHANGE_TIME/2;
  201.     }
  202. }
  203.  
  204. void arenacount(playerent *d, int &alive, int &dead, char *&lastteam, char *&lastname, bool &oneteam)
  205. {
  206.     if(d->state!=CS_DEAD)
  207.     {
  208.         alive++;
  209.         if(lastteam && strcmp(lastteam, d->team)) oneteam = false;
  210.         lastteam = d->team;
  211.         lastname = d->name;
  212.     }
  213.     else
  214.     {
  215.         dead++;
  216.     }
  217. }
  218.  
  219. void checkakimbo()
  220. {
  221.     if(player1->akimbo && player1->akimbomillis && player1->akimbomillis<=lastmillis)
  222.     {
  223.         player1->akimbo = 0;
  224.         player1->akimbomillis = 0;
  225.         player1->mag[GUN_PISTOL] = min(magsize(GUN_PISTOL), player1->mag[GUN_PISTOL]);
  226.         if(player1->gunselect==GUN_PISTOL) weaponswitch(GUN_PISTOL);
  227.         playsoundc(S_PUPOUT);
  228.     }
  229. }
  230.  
  231. void zapplayer(playerent *&d)
  232. {
  233.     DELETEP(d);
  234. }
  235.  
  236. extern int democlientnum;
  237.  
  238. void otherplayers()
  239. {
  240.     loopv(players) if(players[i] && players[i]->type==ENT_PLAYER && players[i]->state==CS_ALIVE)
  241.     {
  242.         const int lagtime = lastmillis-players[i]->lastupdate;
  243.         if(lagtime>1000)
  244.         {
  245.             players[i]->state = CS_LAGGED;
  246.             continue;
  247.         }
  248.         else if(!lagtime || intermission) continue;
  249.         if(!demoplayback || i!=democlientnum) moveplayer(players[i], 2, false);   // use physics to extrapolate player position
  250.     }
  251. }
  252.  
  253. struct scriptsleep { int wait; char *cmd; };
  254. vector<scriptsleep> sleeps;
  255.  
  256. void addsleep(char *msec, char *cmd) 
  257. { 
  258.     scriptsleep &s = sleeps.add();
  259.     s.wait = atoi(msec)+lastmillis;
  260.     s.cmd = newstring(cmd);
  261. }
  262.  
  263. COMMANDN(sleep, addsleep, ARG_2STR);
  264.  
  265. void updateworld(int curtime, int lastmillis)        // main game update loop
  266. {
  267.     loopv(sleeps) 
  268.     {
  269.         if(sleeps[i].wait && lastmillis > sleeps[i].wait) 
  270.         {
  271.             execute(sleeps[i].cmd);
  272.             delete[] sleeps[i].cmd;
  273.             sleeps.remove(i--); 
  274.         }
  275.     }
  276.     physicsframe();
  277.     checkakimbo();
  278.     checkweaponswitch();
  279.     //if(m_arena) arenarespawn();
  280.     //arenarespawn();
  281.     moveprojectiles((float)curtime);
  282.     demoplaybackstep();
  283.     if(!demoplayback)
  284.     {
  285.         if(getclientnum()>=0) shoot(player1, worldpos);     // only shoot when connected to server
  286.         gets2c();           // do this first, so we have most accurate information when our player moves
  287.     }
  288.     movebounceents();
  289.     otherplayers();
  290.     if(!demoplayback)
  291.     {
  292.         //monsterthink();
  293.         
  294.         // Added by Rick: let bots think
  295.         if(m_botmode) BotManager.Think();            
  296.         
  297.         //put game mode extra call here
  298.         if(player1->state==CS_DEAD)
  299.         {
  300.             if(lastmillis-player1->lastaction<2000)
  301.             {
  302.                 player1->move = player1->strafe = 0;
  303.                 moveplayer(player1, 10, false);
  304.             }
  305.         }
  306.         else if(!intermission)
  307.         {
  308.             moveplayer(player1, 20, true);
  309.             checkitems(player1);
  310.         }
  311.         c2sinfo(player1);   // do this last, to reduce the effective frame lag
  312.     }
  313. }
  314.  
  315. #define SECURESPAWNDIST 15
  316. int spawncycle = -1;
  317. int fixspawn = 2;
  318.  
  319. // returns -2 for a free place, else dist to the nearest enemy
  320. float nearestenemy(vec place, char *team)
  321. {
  322.     float nearestenemydist = -1;
  323.     loopv(players)
  324.     {
  325.         playerent *other = players[i];
  326.         if(!other || isteam(team, other->team)) continue;
  327.         float dist = place.dist(other->o);
  328.         if(dist < nearestenemydist || nearestenemydist == -1) nearestenemydist = dist;
  329.     }
  330.     if(nearestenemydist >= SECURESPAWNDIST || nearestenemydist == -1) return -2;
  331.     else return nearestenemydist;
  332. }
  333.  
  334. int findplayerstart(playerent *d)
  335. {
  336.     int r = fixspawn-->0 ? 4 : rnd(10)+1;
  337.  
  338.     if(m_teammode) loopi(r) spawncycle = findentity(PLAYERSTART, spawncycle+1, team_int(d->team));
  339.     else if(m_arena) loopi(r) spawncycle = findentity(PLAYERSTART, spawncycle+1, 100);
  340.     else
  341.     {
  342.         int bestent = -1;
  343.         float bestdist = -1;
  344.  
  345.         loopi(r)
  346.         {
  347.             spawncycle = findentity(PLAYERSTART, spawncycle+1);
  348.             if(spawncycle < 0 || spawncycle >= ents.length()) continue;
  349.             float dist = nearestenemy(vec(ents[spawncycle].x, ents[spawncycle].y, ents[spawncycle].z), d->team);
  350.             if(dist == -2 || (bestdist != -2 && dist > bestdist) || bestent == -1) { bestent = spawncycle; bestdist = dist; }
  351.         }
  352.  
  353.         return bestent;
  354.     }
  355.     return spawncycle;
  356. }
  357.  
  358. void spawnplayer(playerent *d)   // place at random spawn
  359. {
  360.     int e = findplayerstart(d);
  361.     if(e!=-1)
  362.     {
  363.         d->o.x = ents[e].x;
  364.         d->o.y = ents[e].y;
  365.         d->o.z = ents[e].z;
  366.         d->yaw = ents[e].attr1;
  367.         d->pitch = 0;
  368.         d->roll = 0;
  369.     }
  370.     else
  371.     {
  372.         d->o.x = d->o.y = (float)ssize/2;
  373.         d->o.z = 4;
  374.     }
  375.  
  376.     entinmap(d);
  377.     spawnstate(d);
  378.     d->state = CS_ALIVE;
  379. }
  380.  
  381. void showteamkill() { player1->lastteamkill = lastmillis; }
  382.  
  383. // damage arriving from the network, monsters, yourself, all ends up here.
  384.  
  385. void dodamage(int damage, int actor, playerent *act, bool gib, playerent *pl)
  386. {   
  387.     if(!act) return;
  388.     if(pl->state!=CS_ALIVE || editmode || intermission) return;
  389.     if(pl==player1)
  390.     {
  391.         damageblend(damage);
  392.         demoblend(damage);
  393.     }
  394.     pl->lastpain = lastmillis;
  395.     int ad = damage*30/100; // let armour absorb when possible
  396.     if(ad>pl->armour) ad = pl->armour;
  397.     pl->armour -= ad;
  398.     damage -= ad;
  399.     float droll = damage/0.5f;
  400.     pl->roll += pl->roll>0 ? droll : (pl->roll<0 ? -droll : (rnd(2) ? droll : -droll));  // give player a kick depending on amount of damage
  401.     if((pl->health -= damage)<=0)
  402.     {
  403.         s_sprintfd(death)("%s", gib ? "gibbed" : "fragged");
  404.         if(pl->type==ENT_BOT)
  405.         {
  406.             if(pl==act) 
  407.             { 
  408.                 --pl->frags; 
  409.                 conoutf("\f2%s suicided", colorname(pl)); 
  410.             }
  411.             else if(isteam(pl->team, act->team))
  412.             {
  413.                 --act->frags; 
  414.                 conoutf("\f2%s %s %s teammate (%s)", act==player1 ? "you" : colorname(act, 0), death, act==player1 ? "a" : "his", colorname(pl, 1));
  415.                 if(act==player1) showteamkill();
  416.             }
  417.             else
  418.             {
  419.                 act->frags += gib ? 2 : 1;
  420.                 conoutf("\f2%s %s %s", act==player1 ? "you" : colorname(act, 0), death, colorname(pl, 1));
  421.             }
  422.         }
  423.         else if(act==pl)
  424.         {
  425.             actor = getclientnum();
  426.             conoutf("\f2you suicided!");
  427.             addmsg(SV_FRAGS, "ri", --pl->frags);
  428.         }
  429.         else if(act)
  430.         {
  431.             if(isteam(act->team, player1->team)) conoutf("\f2you got %s by a teammate (%s)", death, colorname(act));
  432.             else conoutf("\f2you got %s by %s", death, colorname(act));
  433.         }
  434.         if(pl==player1) 
  435.         {
  436.             showscores(true);
  437.             setscope(false);
  438.             addmsg(gib ? SV_GIBDIED : SV_DIED, "ri", actor);
  439.             if(m_ctf) tryflagdrop(act && isteam(act->team, player1->team));
  440.         }
  441.         deathstate(pl);
  442.         pl->lifesequence++;
  443.         playsound(S_DIE1+rnd(2), pl!=player1 ? &pl->o : NULL);
  444.         if(act && act->gunselect == GUN_SNIPER && gib) playsound(S_HEADSHOT);
  445.         if(gib) addgib(pl);
  446.         if(pl!=player1 || act->type==ENT_BOT) act->frags += gib ? 2 : 1;
  447.     }
  448.     else
  449.     {
  450.         playsound(S_PAIN6, pl!=player1 ? &pl->o : NULL);
  451.     }
  452. }
  453.  
  454. VAR(minutesremaining, 1, 0, 0);
  455.  
  456. void timeupdate(int timeremain)
  457. {
  458.     minutesremaining = timeremain;
  459.     if(!timeremain)
  460.     {
  461.         intermission = true;
  462.         player1->attacking = false;
  463.         conoutf("intermission:");
  464.         conoutf("game has ended!");
  465.         showscores(true);
  466.         execute("start_intermission");
  467.     }
  468.     else
  469.     {
  470.         conoutf("time remaining: %d minutes", timeremain);
  471.     }
  472. }
  473.  
  474. playerent *newclient(int cn)   // ensure valid entity
  475. {
  476.     if(cn<0 || cn>=MAXCLIENTS)
  477.     {
  478.         neterr("clientnum");
  479.         return NULL;
  480.     }
  481.     while(cn>=players.length()) players.add(NULL);
  482.     playerent *d = players[cn];
  483.     if(d) return d;
  484.     d = newplayerent();
  485.     players[cn] = d;
  486.     d->clientnum = cn;
  487.     return d;
  488. }
  489.  
  490. playerent *getclient(int cn)   // ensure valid entity
  491. {
  492.     return players.inrange(cn) ? players[cn] : NULL;
  493. }
  494.  
  495. void initclient()
  496. {
  497.     clientmap[0] = 0;
  498.     newname("unnarmed");
  499.     changeteam(rnd(2));
  500. }
  501.  
  502. entity flagdummies[2]; // in case the map does not provide flags
  503.  
  504. void preparectf(bool cleanonly=false)
  505. {
  506.     loopi(2) flaginfos[i].flag = &flagdummies[i];
  507.     if(!cleanonly)
  508.     {
  509.         loopv(ents)
  510.         {
  511.             entity &e = ents[i];
  512.             if(e.type==CTF_FLAG) 
  513.             {
  514.                 e.spawned = true;
  515.                 if(e.attr2>2) { conoutf("\f3invalid ctf-flag entity (%i)", i); e.attr2 = 0; }
  516.                 flaginfo &f = flaginfos[e.attr2];
  517.                 f.team = e.attr2;
  518.                 f.flag = &e;
  519.                 f.state = CTFF_INBASE;
  520.                 f.originalpos.x = (float) e.x;
  521.                 f.originalpos.y = (float) e.y;
  522.                 f.originalpos.z = (float) e.z;
  523.             }
  524.         }
  525.     }
  526. }
  527.  
  528. void startmap(char *name)   // called just after a map load
  529. {
  530.     clearminimap();
  531.     //if(netmapstart()) { gamemode = 0;}  //needs fixed to switch modes?
  532.     senditemstoserver = true;
  533.     //monsterclear();
  534.     // Added by Rick
  535.     if(m_botmode) BotManager.BeginMap(name);
  536.     else kickallbots();
  537.     // End add by Rick            
  538.     projreset();
  539.     resetspawns();
  540.     if(m_ctf) preparectf();
  541.     particlereset();
  542.     spawncycle = -1;
  543.     spawnplayer(player1);
  544.     player1->frags = player1->flagscore = player1->lifesequence = 0;
  545.     loopv(players) if(players[i]) players[i]->frags = players[i]->flagscore = players[i]->lifesequence = 0;
  546.     s_strcpy(clientmap, name);
  547.     if(editmode) toggleedit();
  548.     setvar("gamespeed", 100);
  549.     setvar("fog", 180);
  550.     setvar("fogcolour", 0x8099B3);
  551.     showscores(false);
  552.     intermission = false;
  553.     if(*clientmap) conoutf("game mode is \"%s\"", modestr(gamemode));
  554.     clearbounceents();
  555. }
  556.  
  557. COMMANDN(map, changemap, ARG_1STR);
  558.  
  559. void suicide()
  560. {
  561.     if(player1->state==CS_DEAD) return;
  562.     dodamage(1000, -1, player1);
  563.     demodamage(1000, player1->o);
  564. }
  565.  
  566. COMMAND(suicide, ARG_NONE);
  567.  
  568. // console and audio feedback
  569.  
  570. void flagmsg(int flag, int action) 
  571. {
  572.     flaginfo &f = flaginfos[flag];
  573.     if(!f.actor || !f.ack) return;
  574.     bool own = flag == team_int(player1->team);
  575.     switch(action)
  576.     {
  577.         case SV_FLAGPICKUP:
  578.         {
  579.             playsound(S_FLAGPICKUP);
  580.             if(f.actor==player1) conoutf("\f2you got the enemy flag");
  581.             else conoutf("\f2%s got %s flag", colorname(f.actor), (own ? "your": "the enemy"));
  582.             break;
  583.         }
  584.         case SV_FLAGDROP:
  585.         {
  586.             playsound(S_FLAGDROP);
  587.             if(f.actor==player1) conoutf("\f2you lost the flag");
  588.             else conoutf("\f2%s lost %s flag", colorname(f.actor), (own ? "your" : "the enemy"));
  589.             break;
  590.         }
  591.         case SV_FLAGRETURN:
  592.         {
  593.             playsound(S_FLAGRETURN);
  594.             if(f.actor==player1) conoutf("\f2you returned your flag");
  595.             else conoutf("\f2%s returned %s flag", colorname(f.actor), (own ? "your" : "the enemy"));
  596.             break;
  597.         }
  598.         case SV_FLAGSCORE:
  599.         {
  600.             playsound(S_FLAGSCORE);
  601.             if(f.actor==player1) 
  602.             {
  603.                 conoutf("\f2you scored");
  604.                 addmsg(SV_FLAGS, "ri", ++player1->flagscore);
  605.             }
  606.             else conoutf("\f2%s scored for %s team", colorname(f.actor), (own ? "the enemy" : "your"));
  607.             break;
  608.         }
  609.         case SV_FLAGRESET:
  610.         {
  611.             playsound(S_FLAGRETURN);
  612.             conoutf("the server reset the flag");
  613.             break;
  614.         }
  615.         default: break;
  616.     }
  617. }
  618.  
  619. // server administration
  620.  
  621. void setmaster(int claim)
  622. {
  623.     addmsg(SV_SETMASTER, "ri", claim != 0 ? 1 : 0);
  624. }
  625.  
  626. void setadmin(char *claim, char *password)
  627. {
  628.     if(!claim) return;
  629.     if(strlen(password) > 15) { conoutf("the admin password has a maximum length of 15 characters"); return; }
  630.     else addmsg(SV_SETADMIN, "ris", atoi(claim) != 0 ? 1 : 0, password);
  631. }
  632.  
  633. void serveropcommand(int cmd, int a) // one of MCMD_*
  634. {
  635.     addmsg(SV_SERVOPCMD, "rii", cmd, a);
  636. }
  637.  
  638. void kick(int player) { serveropcommand(SOPCMD_KICK, player); }
  639. void ban(int player) { serveropcommand(SOPCMD_BAN, player); }
  640. void removebans() { serveropcommand(SOPCMD_REMBANS, 0); }
  641. void autoteam(int enable) { serveropcommand(SOPCMD_AUTOTEAM, enable); }
  642. void mastermode(int mode) { serveropcommand(SOPCMD_MASTERMODE, mode); }
  643. void forceteam(int player) { serveropcommand(SOPCMD_FORCETEAM, player); }
  644. void givemaster(int player) { serveropcommand(SOPCMD_GIVEMASTER, player); }
  645.  
  646. COMMAND(setmaster, ARG_1INT);
  647. COMMAND(setadmin, ARG_2STR);
  648. COMMAND(kick, ARG_1INT);
  649. COMMAND(ban, ARG_1INT);
  650. COMMAND(removebans, ARG_NONE);
  651. COMMAND(autoteam, ARG_1INT);
  652. COMMAND(mastermode, ARG_1INT);
  653. COMMAND(forceteam, ARG_1INT);
  654. COMMAND(givemaster, ARG_1INT);
  655.  
  656. struct mline { string name, cmd; };
  657. static vector<mline> mlines;
  658.  
  659. void *kickmenu = NULL, *banmenu = NULL, *forceteammenu = NULL, *givemastermenu = NULL;
  660.  
  661. void refreshsopmenu(void *menu, bool init)
  662. {
  663.     int item = 0;
  664.     mlines.setsize(0);
  665.     loopv(players) if(players[i])
  666.     {
  667.         mline &m = mlines.add();
  668.         s_strcpy(m.name, colorname(players[i]));
  669.         s_sprintf(m.cmd)("%s %d", menu==kickmenu ? "kick" : (menu==banmenu ? "ban" : (menu==forceteammenu ? "forceteam" : "givemaster")), i);
  670.         menumanual(menu, item++, m.name, m.cmd);
  671.     }
  672. }
  673.  
  674.