开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 射击游戏 > 查看源码
d_net.c
资源名称：21.rar　[点击查看]
上传用户：xuyinpeng
上传日期：2021-05-12
资源大小：455k
文件大小：19k
源码类别：

射击游戏

开发平台：

Visual C++

d_net.c：源码内容
  1. // Emacs style mode select   -*- C++ -*- 
  2. //-----------------------------------------------------------------------------
  3. //
  4. // $Id:$
  5. //
  6. // Copyright (C) 1993-1996 by id Software, Inc.
  7. //
  8. // This source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:
  20. // DOOM Network game communication and protocol,
  21. // all OS independend parts.
  22. //
  23. //-----------------------------------------------------------------------------
  26. static const char rcsid[] = "$Id: d_net.c,v 1.3 1997/02/03 22:01:47 b1 Exp $";
  28. #include <windows.h>
  30. #include "m_menu.h"
  31. #include "i_system.h"
  32. #include "i_video.h"
  33. #include "i_net.h"
  34. #include "g_game.h"
  35. #include "doomdef.h"
  36. #include "doomstat.h"
  38. #include "d_console.h"
  40. void WriteDebug(char *);
  42. #define NCMD_EXIT 0x80000000
  43. #define NCMD_RETRANSMIT 0x40000000
  44. #define NCMD_SETUP 0x20000000
  45. #define NCMD_KILL 0x10000000 // kill game
  46. #define NCMD_CHECKSUM   0x0fffffff
  48.  
  49. doomcom_t* doomcom;
  50. doomdata_t* netbuffer; // points inside doomcom
  52. char MsgText[256];
  53. void WriteDebug(char *);
  55. //
  56. // NETWORKING
  57. //
  58. // gametic is the tic about to (or currently being) run
  59. // maketic is the tick that hasn't had control made for it yet
  60. // nettics[] has the maketics for all players 
  61. //
  62. // a gametic cannot be run until nettics[] > gametic for all players
  63. //
  64. #define RESENDCOUNT 10
  65. #define PL_DRONE 0x80 // bit flag in doomdata->player
  67. ticcmd_t localcmds[BACKUPTICS];
  69. ticcmd_t        netcmds[MAXPLAYERS][BACKUPTICS];
  70. int          nettics[MAXNETNODES];
  71. boolean nodeingame[MAXNETNODES]; // set false as nodes leave game
  72. boolean remoteresend[MAXNETNODES]; // set when local needs tics
  73. int resendto[MAXNETNODES]; // set when remote needs tics
  74. int resendcount[MAXNETNODES];
  76. int nodeforplayer[MAXPLAYERS];
  78. int             maketic;
  79. int lastnettic;
  80. int skiptics;
  81. int ticdup;
  82. int maxsend; // BACKUPTICS/(2*ticdup)-1
  85. void D_ProcessEvents (void); 
  86. void G_BuildTiccmd (ticcmd_t *cmd); 
  87. void D_DoAdvanceDemo (void);
  88.  
  89. boolean reboundpacket;
  90. doomdata_t reboundstore;
  92. void  HandleKeyboard(void);
  94. //
  95. //
  96. //
  97. int NetbufferSize (void)
  98. {
  99.     return (int)&(((doomdata_t *)0)->cmds[netbuffer->numtics]); 
  100. }
  102. //
  103. // Checksum 
  104. //
  105. unsigned NetbufferChecksum (void)
  106. {
  107.     unsigned c;
  108.     int i,l;
  110.     c = 0x1234567;
  112.     // FIXME -endianess?
  113. #ifdef NORMALUNIX
  114.     return 0; // byte order problems
  115. #endif
  117.     l = (NetbufferSize () - (int)&(((doomdata_t *)0)->retransmitfrom))/4;
  118.     for (i=0 ; i<l ; i++)
  119. c += ((unsigned *)&netbuffer->retransmitfrom)[i] * (i+1);
  121.     return c & NCMD_CHECKSUM;
  122. }
  124. //
  125. //
  126. //
  127. int ExpandTics (int low)
  128. {
  129.     int delta;
  131.     delta = low - (maketic&0xff);
  133.     if (delta >= -64 && delta <= 64)
  134. return (maketic&~0xff) + low;
  135.     if (delta > 64)
  136. return (maketic&~0xff) - 256 + low;
  137.     if (delta < -64)
  138. return (maketic&~0xff) + 256 + low;
  140.     I_Error ("ExpandTics: strange value %i at maketic %i",low,maketic);
  141.     return 0;
  142. }
  146. //
  147. // HSendPacket
  148. //
  149. void HSendPacket(int node, int flags )
  150.    {
  151.     netbuffer->checksum = NetbufferChecksum () | flags;
  153.     if (!node)
  154.        {
  155.         reboundstore = *netbuffer;
  156.         reboundpacket = true;
  157.         return;
  158.        }
  160.     if (demoplayback)
  161.         return;
  163.     if (!netgame)
  164.         I_Error ("Tried to transmit to another node");
  166.     doomcom->command = CMD_SEND;
  167.     doomcom->remotenode = node;
  168.     doomcom->datalength = NetbufferSize ();
  170.     if (debugfile)
  171.     {
  172. int i;
  173. int realretrans;
  174. if (netbuffer->checksum & NCMD_RETRANSMIT)
  175.     realretrans = ExpandTics (netbuffer->retransmitfrom);
  176. else
  177.     realretrans = -1;
  179. sprintf (MsgText,"send (%i + %i, R %i) [%i] ",
  180.  ExpandTics(netbuffer->starttic),
  181.  netbuffer->numtics, realretrans, doomcom->datalength);
  182.     WriteDebug(MsgText);
  184. for (i=0 ; i<doomcom->datalength ; i++)
  185.        {
  186.     sprintf (MsgText,"%i ",((byte *)netbuffer)[i]);
  187.         WriteDebug(MsgText);
  188.        }
  190. sprintf (MsgText,"n");
  191.     WriteDebug(MsgText);
  192.     }
  194.     I_NetCmd ();
  195. }
  197. //
  198. // HGetPacket
  199. // Returns false if no packet is waiting
  200. //
  201. boolean HGetPacket (void)
  202. {
  203.     if (reboundpacket)
  204.     {
  205. *netbuffer = reboundstore;
  206. doomcom->remotenode = 0;
  207. reboundpacket = false;
  208. return true;
  209.     }
  211.     if (!netgame)
  212. return false;
  214.     if (demoplayback)
  215. return false;
  217.     doomcom->command = CMD_GET;
  218.     I_NetCmd ();
  219.     
  220.     if (doomcom->remotenode == -1)
  221. return false;
  223.     if (doomcom->datalength != NetbufferSize ())
  224.     {
  225. if (debugfile)
  226.     fprintf (debugfile,"bad packet length %in",doomcom->datalength);
  227. return false;
  228.     }
  230.     if (NetbufferChecksum () != (netbuffer->checksum&NCMD_CHECKSUM) )
  231.     {
  232. if (debugfile)
  233.     fprintf (debugfile,"bad packet checksumn");
  234. return false;
  235.     }
  237.     if (debugfile)
  238.     {
  239. int realretrans;
  240. int i;
  242. if (netbuffer->checksum & NCMD_SETUP)
  243.     fprintf (debugfile,"setup packetn");
  244. else
  245. {
  246.     if (netbuffer->checksum & NCMD_RETRANSMIT)
  247. realretrans = ExpandTics (netbuffer->retransmitfrom);
  248.     else
  249. realretrans = -1;
  250.     
  251.     fprintf (debugfile,"get %i = (%i + %i, R %i)[%i] ",
  252.      doomcom->remotenode,
  253.      ExpandTics(netbuffer->starttic),
  254.      netbuffer->numtics, realretrans, doomcom->datalength);
  256.     for (i=0 ; i<doomcom->datalength ; i++)
  257. fprintf (debugfile,"%i ",((byte *)netbuffer)[i]);
  258.     fprintf (debugfile,"n");
  259. }
  260.     }
  261.     return true;
  262. }
  265. //
  266. // GetPackets
  267. //
  268. char    exitmsg[80];
  270. void GetPackets (void)
  271. {
  272.     int netconsole;
  273.     int netnode;
  274.     ticcmd_t *src, *dest;
  275.     int realend;
  276.     int realstart;
  277.  
  278.     while ( HGetPacket() )
  279.     {
  280. if (netbuffer->checksum & NCMD_SETUP)
  281.     continue; // extra setup packet
  283. netconsole = netbuffer->player & ~PL_DRONE;
  284. netnode = doomcom->remotenode;
  286. // to save bytes, only the low byte of tic numbers are sent
  287. // Figure out what the rest of the bytes are
  288. realstart = ExpandTics (netbuffer->starttic);
  289. realend = (realstart+netbuffer->numtics);
  291. // check for exiting the game
  292. if (netbuffer->checksum & NCMD_EXIT)
  293. {
  294.     if (!nodeingame[netnode])
  295. continue;
  296.     nodeingame[netnode] = false;
  297.     playeringame[netconsole] = false;
  298.     strcpy (exitmsg, "Player 1 left the game");
  299.     exitmsg[7] += netconsole;
  300.     players[consoleplayer].message = exitmsg;
  301.     if (demorecording)
  302. G_CheckDemoStatus ();
  303.     continue;
  304. }
  306. // check for a remote game kill
  307. if (netbuffer->checksum & NCMD_KILL)
  308.     I_Error ("Killed by network driver");
  310. nodeforplayer[netconsole] = netnode;
  312. // check for retransmit request
  313. if ( resendcount[netnode] <= 0 
  314.      && (netbuffer->checksum & NCMD_RETRANSMIT) )
  315. {
  316.     resendto[netnode] = ExpandTics(netbuffer->retransmitfrom);
  317.     if (debugfile)
  318. fprintf (debugfile,"retransmit from %in", resendto[netnode]);
  319.     resendcount[netnode] = RESENDCOUNT;
  320. }
  321. else
  322.     resendcount[netnode]--;
  324. // check for out of order / duplicated packet
  325. if (realend == nettics[netnode])
  326.     continue;
  328. if (realend < nettics[netnode])
  329. {
  330.     if (debugfile)
  331. fprintf (debugfile,
  332.  "out of order packet (%i + %i)n" ,
  333.  realstart,netbuffer->numtics);
  334.     continue;
  335. }
  337. // check for a missed packet
  338. if (realstart > nettics[netnode])
  339. {
  340.     // stop processing until the other system resends the missed tics
  341.     if (debugfile)
  342. fprintf (debugfile,
  343.  "missed tics from %i (%i - %i)n",
  344.  netnode, realstart, nettics[netnode]);
  345.     remoteresend[netnode] = true;
  346.     continue;
  347. }
  349. // update command store from the packet
  350.         {
  351.     int start;
  353.     remoteresend[netnode] = false;
  355.     start = nettics[netnode] - realstart;
  356.     src = &netbuffer->cmds[start];
  358.     while (nettics[netnode] < realend)
  359.     {
  360. dest = &netcmds[netconsole][nettics[netnode]%BACKUPTICS];
  361. nettics[netnode]++;
  362. *dest = *src;
  363. src++;
  364.     }
  365. }
  366.     }
  367. }
  370. //
  371. // NetUpdate
  372. // Builds ticcmds for console player,
  373. // sends out a packet
  374. //
  375. int      gametime;
  377. void NetUpdate (void)
  378. {
  379.     int             nowtime;
  380.     int             newtics;
  381.     int i,j;
  382.     int realstart;
  383.     int gameticdiv;
  384.     
  385.     // check time
  386.     nowtime = I_GetTime ()/ticdup;
  387.     newtics = nowtime - gametime;
  388.     gametime = nowtime;
  390.     if (newtics <= 0)  // nothing new to update
  391. goto listen; 
  393.     if (skiptics <= newtics)
  394.     {
  395. newtics -= skiptics;
  396. skiptics = 0;
  397.     }
  398.     else
  399.     {
  400. skiptics -= newtics;
  401. newtics = 0;
  402.     }
  405.     netbuffer->player = consoleplayer;
  406.     
  407.     // build new ticcmds for console player
  408.     gameticdiv = gametic/ticdup;
  409.     for (i=0 ; i<newtics ; i++)
  410.     {
  411. I_StartTic ();
  412. D_ProcessEvents ();
  413. if (maketic - gameticdiv >= BACKUPTICS/2-1)
  414.     break;          // can't hold any more
  416. //printf ("mk:%i ",maketic);
  417.     //WriteDebug("NetUpdate calling G_BuildTiccmd...n");
  418. G_BuildTiccmd (&localcmds[maketic%BACKUPTICS]);
  419. maketic++;
  420.     }
  423.     if (singletics)
  424. return;         // singletic update is syncronous
  425.     
  426.     // send the packet to the other nodes
  427.     for (i=0 ; i<doomcom->numnodes ; i++)
  428. if (nodeingame[i])
  429. {
  430.     netbuffer->starttic = realstart = resendto[i];
  431.     netbuffer->numtics = maketic - realstart;
  432.     if (netbuffer->numtics > BACKUPTICS)
  433. I_Error ("NetUpdate: netbuffer->numtics > BACKUPTICS");
  435.     resendto[i] = maketic - doomcom->extratics;
  437.     for (j=0 ; j< netbuffer->numtics ; j++)
  438. netbuffer->cmds[j] = 
  439.     localcmds[(realstart+j)%BACKUPTICS];
  441.     if (remoteresend[i])
  442.     {
  443. netbuffer->retransmitfrom = nettics[i];
  444. HSendPacket (i, NCMD_RETRANSMIT);
  445.     }
  446.     else
  447.     {
  448. netbuffer->retransmitfrom = 0;
  449. HSendPacket (i, 0);
  450.     }
  451. }
  452.     
  453.     // listen for other packets
  454.   listen:
  455.     GetPackets ();
  456. }
  459. extern HACCEL ghAccel;
  460. extern BOOL bQuit;
  461. //
  462. // CheckAbort
  463. //
  464. void CheckAbort (void)
  465.    {
  466.     event_t *ev;
  467.     int stoptic;
  468.     MSG     msg;
  470.     stoptic = I_GetTime()+2; 
  471.     while (I_GetTime() < stoptic)
  472.        {
  473.         while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
  474.    {
  475.             if (msg.message == WM_QUIT)
  476.    {
  477. bQuit = TRUE;
  478.                 break;
  479.                }
  480.             if (!TranslateAccelerator(msg.hwnd, ghAccel, &msg))
  481.    {
  482.                 TranslateMessage(&msg);
  483.                 DispatchMessage(&msg);
  484.                }
  485.            }
  486.         HandleKeyboard();
  487.        I_StartTic(); 
  488.    }
  490.     I_StartTic();
  491.     for ( ; eventtail != eventhead ; eventtail = (++eventtail)&(MAXEVENTS-1)) 
  492.        { 
  493.         ev = &events[eventtail]; 
  494.         if (ev->type == ev_keydown && ev->data1 == KEY_ESCAPE)
  495.             I_Error ("Network game synchronization aborted.");
  496.        } 
  497.    }
  500. //
  501. // D_ArbitrateNetStart
  502. //
  503. void D_ArbitrateNetStart (void)
  504.    {
  505.     int i;
  506.     boolean gotinfo[MAXNETNODES];
  507.     static  int timeout = 0;
  509.     autostart = true;
  510.     memset (gotinfo,0,sizeof(gotinfo));
  512.     if (doomcom->consoleplayer)
  513.     {
  514. // listen for setup info from key player
  515. WriteDebug("listening for network start info...Consolen");
  516. while (1)
  517.    {
  518.         //timeout += I_GetTime();
  519.         //if (timeout > 8400)
  520.         //   I_Error("Network game synchronization timed out...n");
  521.     CheckAbort();
  522.     if (!HGetPacket())
  523.    continue;
  524.     if (netbuffer->checksum & NCMD_SETUP)
  525.     {
  526. if (netbuffer->player != VERSION)
  527.     I_Error ("Different DOOM versions cannot play a net game!");
  528. startskill = netbuffer->retransmitfrom & 15;
  529. deathmatch = (netbuffer->retransmitfrom & 0xc0) >> 6;
  530. nomonsters = (netbuffer->retransmitfrom & 0x20) > 0;
  531. respawnparm = (netbuffer->retransmitfrom & 0x10) > 0;
  532. startmap = netbuffer->starttic & 0x3f;
  533. startepisode = netbuffer->starttic >> 6;
  534. return;
  535.     }
  536. }
  537.     }
  538.     else
  539.     {
  540. // key player, send the setup info
  541. sprintf (MsgText,"sending network start info...n");
  542.     WriteDebug(MsgText);
  543. do
  544. {
  545.     CheckAbort ();
  546.     for (i=0 ; i<doomcom->numnodes ; i++)
  547.     {
  548. netbuffer->retransmitfrom = startskill;
  549. if (deathmatch)
  550.     netbuffer->retransmitfrom |= (deathmatch<<6);
  551. if (nomonsters)
  552.     netbuffer->retransmitfrom |= 0x20;
  553. if (respawnparm)
  554.     netbuffer->retransmitfrom |= 0x10;
  555. netbuffer->starttic = startepisode * 64 + startmap;
  556. netbuffer->player = VERSION;
  557. netbuffer->numtics = 0;
  558. HSendPacket (i, NCMD_SETUP);
  559.     }
  561. #if 1
  562.     for(i = 10 ; i  &&  HGetPacket(); --i)
  563.     {
  564. if((netbuffer->player&0x7f) < MAXNETNODES)
  565.     gotinfo[netbuffer->player&0x7f] = true;
  566.     }
  567. #else
  568.     while (HGetPacket ())
  569.     {
  570. gotinfo[netbuffer->player&0x7f] = true;
  571.     }
  572. #endif
  574.     for (i=1 ; i<doomcom->numnodes ; i++)
  575. if (!gotinfo[i])
  576.     break;
  577. } while (i < doomcom->numnodes);
  578.     }
  579. }
  581. //
  582. // D_CheckNetGame
  583. // Works out player numbers among the net participants
  584. //
  585. extern int viewangleoffset;
  587. void D_CheckNetGame (void)
  588. {
  589.     int             i;
  591.     for (i=0 ; i<MAXNETNODES ; i++)
  592.     {
  593. nodeingame[i] = false;
  594.         nettics[i] = 0;
  595. remoteresend[i] = false; // set when local needs tics
  596. resendto[i] = 0; // which tic to start sending
  597.     }
  599.     // I_InitNetwork sets doomcom and netgame
  600.     I_InitNetwork ();
  601.     if (doomcom->id != DOOMCOM_ID)
  602.     I_Error ("Doomcom buffer invalid!");
  603.     
  604.     netbuffer = &doomcom->data;
  605.     consoleplayer = displayplayer = doomcom->consoleplayer;
  606.     if (netgame)
  607.         D_ArbitrateNetStart();
  609.     //printf ("startskill %i  deathmatch: %i  startmap: %i  startepisode: %in",
  610.     sprintf (MsgText, "startskill %i  deathmatch: %i  startmap: %i  startepisode: %in",
  611.     startskill, deathmatch, startmap, startepisode);
  612.     WriteDebug(MsgText);
  614.     // read values out of doomcom
  615.     ticdup = doomcom->ticdup;
  616.     maxsend = BACKUPTICS/(2*ticdup)-1;
  617.     if (maxsend<1)
  618. maxsend = 1;
  620.     for (i=0 ; i<doomcom->numplayers ; i++)
  621. playeringame[i] = true;
  622.     for (i=0 ; i<doomcom->numnodes ; i++)
  623. nodeingame[i] = true;
  625.     //printf ("player %i of %i (%i nodes)n",
  626.     sprintf (MsgText, "player %i of %i (%i nodes)n",
  627.     consoleplayer+1, doomcom->numplayers, doomcom->numnodes);
  628.     WriteDebug(MsgText);
  629. }
  632. //
  633. // D_QuitNetGame
  634. // Called before quitting to leave a net game
  635. // without hanging the other players
  636. //
  637. void D_QuitNetGame (void)
  638.    {
  639.     int             i, j;
  641.     if (debugfile)
  642. fclose (debugfile);
  644.     if (!netgame || !usergame || consoleplayer == -1 || demoplayback)
  645. return;
  647.     // send a bunch of packets for security
  648.     netbuffer->player = consoleplayer;
  649.     netbuffer->numtics = 0;
  650.     for (i=0 ; i<4 ; i++)
  651.     {
  652. for (j=1 ; j<doomcom->numnodes ; j++)
  653.     if (nodeingame[j])
  654. HSendPacket (j, NCMD_EXIT);
  655. I_WaitVBL (1);
  656.     }
  657.     WSACleanup();
  658.    }
  662. //
  663. // TryRunTics
  664. //
  665. int frametics[4];
  666. int frameon;
  667. int frameskip[4];
  668. int oldnettics;
  670. extern boolean advancedemo;
  672. void TryRunTics (void)
  673.    {
  674.     int i;
  675.     int lowtic;
  676.     int entertic;
  677.     static int oldentertics;
  678.     int realtics;
  679.     int availabletics;
  680.     int counts;
  681.     int numplaying;
  682.     
  683.     // get real tics
  684.     entertic = I_GetTime ()/ticdup;
  685.     realtics = entertic - oldentertics;
  686.     oldentertics = entertic;
  687.     
  688.     // get available tics
  689.     //WriteDebug("NetUpdate...n");
  690.     NetUpdate ();
  692.     //WriteDebug("NetUpdate done...n");
  693.     lowtic = MAXINT;
  694.     numplaying = 0;
  695.     for (i = 0; i < doomcom->numnodes; i++)
  696.        {
  697.         if (nodeingame[i])
  698.            {
  699.             numplaying++;
  700.             if (nettics[i] < lowtic)
  701.                lowtic = nettics[i];
  702.            }
  703.        }
  704.     availabletics = lowtic - gametic/ticdup;
  705.     
  706.     // decide how many tics to run
  707.     if (realtics < availabletics-1)
  708.         counts = realtics+1;
  709.     else
  710.     if (realtics < availabletics)
  711.         counts = realtics;
  712.     else
  713.         counts = availabletics;
  714.     
  715.     if (counts < 1)
  716.         counts = 1;
  718.     frameon++;
  720.     if (debugfile)
  721.         fprintf (debugfile, "=======real: %i  avail: %i  game: %in", realtics, availabletics,counts);
  723.     if (!demoplayback)
  724.        {
  725.         // ideally nettics[0] should be 1 - 3 tics above lowtic
  726.         // if we are consistantly slower, speed up time
  727.         for (i = 0; i < MAXPLAYERS; i++)
  728.     if (playeringame[i])
  729.             break;
  730.         if (consoleplayer == i)
  731.            {
  732.             // the key player does not adapt
  733.            }
  734.         else
  735.            {
  736.             if (nettics[0] <= nettics[nodeforplayer[i]])
  737.                {
  738.                 gametime--;
  739.                 // printf ("-");
  740.                }
  741.             frameskip[frameon&3] = (oldnettics > nettics[nodeforplayer[i]]);
  742.             oldnettics = nettics[0];
  743.             if (frameskip[0] && frameskip[1] && frameskip[2] && frameskip[3])
  744.                {
  745.                 skiptics = 1;
  746.                 // printf ("+");
  747.                }
  748.            }
  749.        }// demoplayback
  751.     // wait for new tics if needed
  752.     while (lowtic < gametic/ticdup + counts)
  753.        {
  754.         NetUpdate();   
  755.         lowtic = MAXINT;
  757.         for (i = 0; i < doomcom->numnodes; i++)
  758.         if (nodeingame[i] && nettics[i] < lowtic)
  759.             lowtic = nettics[i];
  761.         if (lowtic < gametic/ticdup)
  762.             I_Error ("TryRunTics: lowtic < gametic");
  764.         // don't stay in here forever -- give the menu a chance to work
  765.         //WriteDebug("I_GetTime...n");
  766.         if (I_GetTime ()/ticdup - entertic >= 20)
  767.            {
  768.             CO_Ticker();
  769.             //WriteDebug("M_Ticker...n");
  770.             M_Ticker ();
  771.             return;
  772.            } 
  773.        }
  774.     
  775.     // run the count * ticdup dics
  776.     while (counts--)
  777.        {
  778.         for (i = 0; i < ticdup; i++)
  779.            {
  780.             if (gametic/ticdup > lowtic)
  781.                 I_Error ("gametic>lowtic");
  782.             if (advancedemo)
  783.                {
  784.                 //WriteDebug("D_DoAdvanceDemo...n");
  785.                 D_DoAdvanceDemo ();
  786.                }
  787.             CO_Ticker();
  788.             //WriteDebug("M_Ticker...n");
  789.             M_Ticker ();
  790.             //WriteDebug("G_Ticker...n");
  791.             G_Ticker ();
  792.             gametic++;
  793.     
  794.             // modify command for duplicated tics
  795.             if (i != ticdup-1)
  796.                {
  797.                 ticcmd_t   *cmd;
  798.                 int         buf;
  799.                 int         j;
  801.                 buf = (gametic/ticdup)%BACKUPTICS; 
  802.                 for (j = 0; j < MAXPLAYERS; j++)
  803.            {
  804.                     cmd = &netcmds[j][buf];
  805.                     cmd->chatchar = 0;
  806.                     if (cmd->buttons & BT_SPECIAL)
  807.                         cmd->buttons = 0;
  808.                    }
  809.                }
  810.            }
  811.         //WriteDebug("NetUpdate - 2...n");
  812.         NetUpdate(); // check for new console commands
  813.        }
  814.    }