home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2007 September / maximum-cd-2007-09.iso / Assets / data / AssaultCube_v0.93.exe / source / src / client.cpp next >
Encoding:
C/C++ Source or Header  |  2007-06-04  |  13.7 KB  |  472 lines
  1. // client.cpp, mostly network related client game code
  2.  
  3. #include "cube.h"
  4. #include "bot/bot.h"
  5.  
  6. VAR(connected, 1, 0, 0);
  7.  
  8. ENetHost *clienthost = NULL;
  9. ENetPeer *curpeer = NULL, *connpeer = NULL;
  10. int connmillis = 0, connattempts = 0, discmillis = 0;
  11. bool c2sinit = false;       // whether we need to tell the other clients our stats
  12.  
  13. int getclientnum() { return player1 ? player1->clientnum : -1; }
  14.  
  15. bool multiplayer(bool msg)
  16. {
  17.     // check not correct on listen server?
  18.     if(curpeer && msg) conoutf("operation not available in multiplayer");
  19.     return curpeer!=NULL;
  20. }
  21.  
  22. bool allowedittoggle()
  23. {
  24.     bool allow = !curpeer || gamemode==1;
  25.     if(!allow) conoutf("editing in multiplayer requires coopedit mode (1)");
  26.     return allow; 
  27. }
  28.  
  29. void setrate(int rate)
  30. {
  31.    if(!curpeer) return;
  32.    enet_host_bandwidth_limit(clienthost, rate, rate);
  33. }
  34.  
  35. VARF(rate, 0, 0, 25000, setrate(rate));
  36.  
  37. void throttle();
  38.  
  39. VARF(throttle_interval, 0, 5, 30, throttle());
  40. VARF(throttle_accel,    0, 2, 32, throttle());
  41. VARF(throttle_decel,    0, 2, 32, throttle());
  42.  
  43. void throttle()
  44. {
  45.     if(!curpeer) return;
  46.     ASSERT(ENET_PEER_PACKET_THROTTLE_SCALE==32);
  47.     enet_peer_throttle_configure(curpeer, throttle_interval*1000, throttle_accel, throttle_decel);
  48. }
  49.  
  50. string clientpassword = "";
  51.  
  52. void abortconnect()
  53. {
  54.     if(!connpeer) return;
  55.     if(connpeer->state!=ENET_PEER_STATE_DISCONNECTED) enet_peer_reset(connpeer);
  56.     connpeer = NULL;
  57.     if(curpeer) return;
  58.     enet_host_destroy(clienthost);
  59.     clienthost = NULL;
  60. }
  61.  
  62. void connects(char *servername, char *password)
  63. {   
  64.     if(connpeer)
  65.     {
  66.         conoutf("aborting connection attempt");
  67.         abortconnect();
  68.     }
  69.  
  70.     s_strcpy(clientpassword, password ? password : "");
  71.  
  72.     ENetAddress address;
  73.     address.port = CUBE_SERVER_PORT;
  74.  
  75.     if(servername)
  76.     {
  77.         addserver(servername);
  78.         conoutf("attempting to connect to %s", servername);
  79.         if(!resolverwait(servername, &address))
  80.         {
  81.             conoutf("\f3could not resolve server %s", servername);
  82.             return;
  83.         }
  84.     }
  85.     else
  86.     {
  87.         conoutf("attempting to connect over LAN");
  88.         address.host = ENET_HOST_BROADCAST;
  89.     }
  90.  
  91.     if(!clienthost) clienthost = enet_host_create(NULL, 2, rate, rate);
  92.  
  93.     if(clienthost)
  94.     {
  95.         connpeer = enet_host_connect(clienthost, &address, 3); 
  96.         enet_host_flush(clienthost);
  97.         connmillis = lastmillis;
  98.         connattempts = 0;
  99.     }
  100.     else conoutf("\f3could not connect to server");
  101. }
  102.  
  103. void connectadmin(char *servername, char *password)
  104. {
  105.     if(!password) return;
  106.     connects(servername, password);
  107.     if(clienthost) addmsg(SV_SETADMIN, "ris", 1, password); // in case the server is not private locked or pwd protected
  108. }
  109.  
  110. void lanconnect()
  111. {
  112.     connects(0);
  113. }  
  114.  
  115. void disconnect(int onlyclean, int async)
  116. {
  117.     bool cleanup = onlyclean!=0;
  118.     if(curpeer)
  119.     {
  120.         if(!discmillis)
  121.         {
  122.             enet_peer_disconnect(curpeer, DISC_NONE);
  123.             enet_host_flush(clienthost);
  124.             discmillis = lastmillis;
  125.         }
  126.         if(curpeer->state!=ENET_PEER_STATE_DISCONNECTED)
  127.         {
  128.             if(async) return;
  129.             enet_peer_reset(curpeer);
  130.         }
  131.         curpeer = NULL;
  132.         discmillis = 0;
  133.         connected = 0;
  134.         conoutf("disconnected");
  135.         cleanup = true;
  136.     }
  137.     else if(demoplayback)
  138.     {
  139.         // todo: additional cleanups
  140.         cleanup = true;
  141.     }
  142.  
  143.     if(cleanup)
  144.     {
  145.         stop();
  146.         c2sinit = false;
  147.         player1->clientnum = -1;
  148.         player1->lifesequence = 0;
  149.         player1->clientrole = CR_DEFAULT;
  150.         if(m_botmode) BotManager.EndMap();
  151.         loopv(players) zapplayer(players[i]);
  152.         localdisconnect();
  153.     }
  154.     if(!connpeer && clienthost)
  155.     {
  156.         enet_host_destroy(clienthost);
  157.         clienthost = NULL;
  158.     }
  159.     if(!onlyclean) localconnect();
  160. }
  161.  
  162. void trydisconnect()
  163. {
  164.     if(connpeer)
  165.     {
  166.         conoutf("aborting connection attempt");
  167.         abortconnect();
  168.         return;
  169.     }
  170.     if(!curpeer)
  171.     {
  172.         conoutf("not connected");
  173.         return;
  174.     }
  175.     conoutf("attempting to disconnect...");
  176.     disconnect(0, !discmillis);
  177. }
  178.  
  179. void toserver(char *text) 
  180. { 
  181.     bool toteam = text && text[0] == '%';
  182.     if(toteam) text++;
  183.     conoutf("%s:\f%d %s", colorname(player1), toteam ? 1 : 0, text);
  184.     addmsg(toteam ? SV_TEAMTEXT : SV_TEXT, "rs", text);
  185. }
  186.  
  187. void echo(char *text) { conoutf("%s", text); }
  188.  
  189. COMMAND(echo, ARG_VARI);
  190. COMMANDN(say, toserver, ARG_VARI);
  191. COMMANDN(connect, connects, ARG_2STR);
  192. COMMAND(connectadmin, ARG_2STR);
  193. COMMAND(lanconnect, ARG_NONE);
  194. COMMANDN(disconnect, trydisconnect, ARG_NONE);
  195.  
  196. // collect c2s messages conveniently
  197.  
  198. vector<uchar> messages;
  199.  
  200. void addmsg(int type, const char *fmt, ...)
  201. {
  202.     if(demoplayback) return;
  203.     static uchar buf[MAXTRANS];
  204.     ucharbuf p(buf, MAXTRANS);
  205.     putint(p, type);
  206.     int numi = 1, nums = 0;
  207.     bool reliable = false;
  208.     if(fmt)
  209.     {
  210.         va_list args;
  211.         va_start(args, fmt);
  212.         while(*fmt) switch(*fmt++)
  213.         {
  214.             case 'r': reliable = true; break;
  215.             case 'i':
  216.             {
  217.                 int n = isdigit(*fmt) ? *fmt++-'0' : 1;
  218.                 loopi(n) putint(p, va_arg(args, int));
  219.                 numi += n;
  220.                 break;
  221.             }
  222.             case 's': sendstring(va_arg(args, const char *), p); nums++; break;
  223.         }
  224.         va_end(args);
  225.     }
  226.     int num = nums?0:numi;
  227.     if(num!=msgsizelookup(type)) { s_sprintfd(s)("inconsistant msg size for %d (%d != %d)", type, num, msgsizelookup(type)); fatal(s); }
  228.     int len = p.length();
  229.     messages.add(len&0xFF);
  230.     messages.add((len>>8)|(reliable ? 0x80 : 0));
  231.     loopi(len) messages.add(buf[i]);
  232. }
  233.  
  234. static int lastupdate = 0, lastping = 0, laststate = -1;
  235. bool senditemstoserver = false;     // after a map change, since server doesn't have map data
  236.  
  237. void sendpackettoserv(int chan, ENetPacket *packet)
  238. {
  239.     if(curpeer) enet_peer_send(curpeer, chan, packet);
  240.     else localclienttoserver(chan, packet);
  241. }
  242.  
  243. void c2skeepalive()
  244. {
  245.     if(clienthost) enet_host_service(clienthost, NULL, 0);
  246. }
  247.  
  248. extern string masterpwd;
  249.  
  250. void c2sinfo(playerent *d)                  // send update to the server
  251. {
  252.     if(d->clientnum<0) return;              // we haven't had a welcome message from the server yet
  253.     if(lastmillis-lastupdate<40) return;    // don't update faster than 25fps
  254.     
  255.     bool hasmsg = gun_changed || senditemstoserver || !c2sinit || messages.length() || lastmillis-lastping>250;
  256.     // limit updates for dead players to the ping rate of 4fps, as above
  257.     if(!hasmsg && laststate==CS_DEAD && player1->state==CS_DEAD) return;
  258.     
  259.     laststate = player1->state;
  260.  
  261.     ENetPacket *packet = enet_packet_create(NULL, 100, 0);
  262.     ucharbuf q(packet->data, packet->dataLength);
  263.  
  264.     putint(q, SV_POS);
  265.     putint(q, d->clientnum);
  266.     putuint(q, (int)(d->o.x*DMF));       // quantize coordinates to 1/16th of a cube, between 1 and 3 bytes
  267.     putuint(q, (int)(d->o.y*DMF));
  268.     putuint(q, (int)(d->o.z*DMF));
  269.     putuint(q, (int)(d->yaw*DAF));
  270.     putint(q, (int)(d->pitch*DAF));
  271.     putint(q, (int)(d->roll*DAF));
  272.     putint(q, (int)(d->vel.x*DVF));     // quantize to 1/100, almost always 1 byte
  273.     putint(q, (int)(d->vel.y*DVF));
  274.     putint(q, (int)(d->vel.z*DVF));
  275.     // pack rest in 1 int: strafe:2, move:2, onfloor:1, state:3, onladder: 1
  276.     putint(q, (d->strafe&3) | ((d->move&3)<<2) | (((int)d->onfloor)<<4) | ((editmode ? CS_EDITING : d->state)<<5) | (((int)d->onladder)<<8) );
  277.  
  278.     enet_packet_resize(packet, q.length());
  279.     incomingdemodata(0, q.buf, q.length(), true);
  280.     sendpackettoserv(0, packet);
  281.  
  282.     bool serveriteminitdone = false;
  283.     if(hasmsg)
  284.     {
  285.         packet = enet_packet_create (NULL, MAXTRANS, 0);
  286.         ucharbuf p(packet->data, packet->dataLength);
  287.     
  288.         if(!c2sinit)    // tell other clients who I am
  289.         {
  290.             packet->flags = ENET_PACKET_FLAG_RELIABLE;
  291.             c2sinit = true;
  292.             if(clientpassword[0])
  293.             {
  294.                 putint(p, SV_PWD);
  295.                 sendstring(clientpassword, p);
  296.                 clientpassword[0] = 0;
  297.             }
  298.             putint(p, SV_INITC2S);
  299.             sendstring(player1->name, p);
  300.             sendstring(player1->team, p);
  301.             putint(p, player1->skin);
  302.             putint(p, player1->lifesequence);
  303.         }
  304.         if(gun_changed)
  305.         {
  306.             packet->flags = ENET_PACKET_FLAG_RELIABLE;
  307.             putint(p, SV_WEAPCHANGE);
  308.             putint(p, player1->gunselect);
  309.             gun_changed = false;       
  310.         }
  311.         if(senditemstoserver)
  312.         {
  313.             packet->flags = ENET_PACKET_FLAG_RELIABLE;
  314.             putint(p, SV_ITEMLIST);
  315.             if(!m_noitems) putitems(p);
  316.             putint(p, -1);
  317.             senditemstoserver = false;
  318.             serveriteminitdone = true;
  319.         }
  320.         int i = 0;
  321.         while(i < messages.length()) // send messages collected during the previous frames
  322.         {
  323.             int len = messages[i] | ((messages[i+1]&0x7F)<<8);
  324.             if(p.remaining() < len) break;
  325.             if(messages[i+1]&0x80) packet->flags = ENET_PACKET_FLAG_RELIABLE;
  326.             p.put(&messages[i+2], len);
  327.             i += 2 + len;
  328.         }
  329.         messages.remove(0, i);
  330.         if(lastmillis-lastping>250)
  331.         {
  332.             putint(p, SV_PING);
  333.             putint(p, lastmillis);
  334.             lastping = lastmillis;
  335.         }
  336.         if(!p.length()) enet_packet_destroy(packet);
  337.         else
  338.         {
  339.             enet_packet_resize(packet, p.length());
  340.             incomingdemodata(42, p.buf, p.length());
  341.             sendpackettoserv(1, packet);
  342.         }
  343.     }
  344.     if(clienthost) enet_host_flush(clienthost);
  345.     lastupdate = lastmillis;
  346.     if(serveriteminitdone) loadgamerest();  // hack
  347. }
  348.  
  349. void gets2c()           // get updates from the server
  350. {
  351.     ENetEvent event;
  352.     if(!clienthost) return;
  353.     if(connpeer && lastmillis/3000 > connmillis/3000)
  354.     {
  355.         conoutf("attempting to connect...");
  356.         connmillis = lastmillis;
  357.         ++connattempts;
  358.         if(connattempts > 3)
  359.         {
  360.             conoutf("\f3could not connect to server");
  361.             abortconnect();
  362.             return;
  363.         }
  364.     }
  365.     while(clienthost!=NULL && enet_host_service(clienthost, &event, 0)>0)
  366.     switch(event.type)
  367.     {
  368.         case ENET_EVENT_TYPE_CONNECT:
  369.             disconnect(1);
  370.             curpeer = connpeer;
  371.             connpeer = NULL;
  372.             connected = 1;
  373.             conoutf("connected to server");
  374.             throttle();
  375.             if(rate) setrate(rate);
  376.             if(editmode) toggleedit();
  377.             break;
  378.          
  379.         case ENET_EVENT_TYPE_RECEIVE:
  380.             if(discmillis) conoutf("attempting to disconnect...");
  381.             else localservertoclient(event.channelID, event.packet->data, (int)event.packet->dataLength);
  382.             enet_packet_destroy(event.packet);
  383.             break;
  384.  
  385.         case ENET_EVENT_TYPE_DISCONNECT:
  386.             extern const char *disc_reason(int reason);
  387.             if(event.data>=DISC_NUM) event.data = DISC_NONE;
  388.             if(event.peer==connpeer)
  389.             {
  390.                 conoutf("\f3could not connect to server");
  391.                 abortconnect();
  392.             }
  393.             else
  394.             {
  395.                 if(!discmillis || event.data) conoutf("\f3server network error, disconnecting (%s) ...", disc_reason(event.data));
  396.                 disconnect();
  397.             }
  398.             return;
  399.  
  400.         default:
  401.             break;
  402.     }
  403. }
  404.  
  405. // sendmap/getmap commands, should be replaced by more intuitive map downloading
  406.  
  407. cvector securemaps;
  408.  
  409. void clearsecuremaps() { securemaps.deletecontentsa(); }
  410. void securemap(char *map) { if(map) securemaps.add(newstring(map)); }
  411. bool securemapcheck(char *map)
  412. {
  413.     if(strstr(map, "maps/")==map || strstr(map, "maps\\")==map) map += strlen("maps/");
  414.     loopv(securemaps) if(!strcmp(securemaps[i], map))
  415.     {
  416.         conoutf("\f3map %s is secured, you can not send or overwrite it", map);
  417.         return true;
  418.     }
  419.     return false;
  420. }
  421.  
  422.  
  423. void sendmap(char *mapname)
  424. {
  425.     if(*mapname)
  426.     {
  427.         save_world(mapname);
  428.         changemap(mapname);
  429.     }    
  430.     mapname = getclientmap();
  431.     if(securemapcheck(mapname)) return;
  432.     int mapsize;
  433.     uchar *mapdata = readmap(mapname, &mapsize); 
  434.     if(!mapdata) return;
  435.     ENetPacket *packet = enet_packet_create(NULL, MAXTRANS + mapsize, ENET_PACKET_FLAG_RELIABLE);
  436.     ucharbuf p(packet->data, packet->dataLength);
  437.     putint(p, SV_SENDMAP);
  438.     sendstring(mapname, p);
  439.     putint(p, mapsize);
  440.     if(65535 - p.length() < mapsize)
  441.     {
  442.         conoutf("map %s is too large to send", mapname);
  443.         delete[] mapdata;
  444.         enet_packet_destroy(packet);
  445.         return;
  446.     }
  447.     p.put(mapdata, mapsize);
  448.     delete[] mapdata; 
  449.     enet_packet_resize(packet, p.length());
  450.     sendpackettoserv(2, packet);
  451.     conoutf("sending map %s to server...", mapname);
  452.     s_sprintfd(msg)("[map %s uploaded to server, \"getmap\" to receive it]", mapname);
  453.     toserver(msg);
  454. }
  455.  
  456. void getmap()
  457. {
  458.     if(securemapcheck(getclientmap())) return;
  459.     ENetPacket *packet = enet_packet_create(NULL, MAXTRANS, ENET_PACKET_FLAG_RELIABLE);
  460.     ucharbuf p(packet->data, packet->dataLength);
  461.     putint(p, SV_RECVMAP);
  462.     enet_packet_resize(packet, p.length());
  463.     sendpackettoserv(2, packet);
  464.     conoutf("requesting map from server...");
  465. }
  466.  
  467. COMMAND(sendmap, ARG_1STR);
  468. COMMAND(getmap, ARG_NONE);
  469. COMMAND(clearsecuremaps, ARG_NONE);
  470. COMMAND(securemap, ARG_1STR);
  471.  
  472.