Games/Doom/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 // Revision 1.1  2000/02/29 18:21:04  stegerg
  19 // Doom port based on ADoomPPC. Read README.AROS!
  20 //
  21 //
  22 // DESCRIPTION:
  23 //      DOOM Network game communication and protocol,
  24 //      all OS independend parts.
  25 //
  26 //-----------------------------------------------------------------------------
  27
  28
  29 static const char rcsid[] = "$Id$";
  30
  31 #include <stdlib.h>
  32 #ifdef __SASC
  33 #include <dos.h>
  34 #endif
  35 #ifdef AROS
  36 #include <proto/exec.h>
  37 #endif
  38
  39 #include "m_menu.h"
  40 #include "i_system.h"
  41 #include "i_video.h"
  42 #include "i_net.h"
  43 #include "g_game.h"
  44 #include "doomdef.h"
  45 #include "doomstat.h"
  46 #include "m_argv.h"
  47 #ifdef __BIG_ENDIAN__
  48 #include "m_swap.h"
  49 #endif
  50
  51 #define NCMD_EXIT               0x80000000
  52 #define NCMD_RETRANSMIT         0x40000000
  53 #define NCMD_SETUP              0x20000000
  54 #define NCMD_KILL               0x10000000      // kill game
  55 #define NCMD_CHECKSUM           0x0fffffff
  56
  57
  58 doomcom_t*      doomcom;
  59 doomdata_t*     netbuffer;              // points inside doomcom
  60
  61
  62 //
  63 // NETWORKING
  64 //
  65 // gametic is the tic about to (or currently being) run
  66 // maketic is the tick that hasn't had control made for it yet
  67 // nettics[] has the maketics for all players
  68 //
  69 // a gametic cannot be run until nettics[] > gametic for all players
  70 //
  71 #define RESENDCOUNT     10
  72 #define PL_DRONE        0x80    // bit flag in doomdata->player
  73
  74 ticcmd_t        localcmds[BACKUPTICS];
  75
  76 ticcmd_t        netcmds[MAXPLAYERS][BACKUPTICS];
  77 int             nettics[MAXNETNODES];
  78 boolean         nodeingame[MAXNETNODES];                // set false as nodes leave game
  79 boolean         remoteresend[MAXNETNODES];              // set when local needs tics
  80 int             resendto[MAXNETNODES];                  // set when remote needs tics
  81 int             resendcount[MAXNETNODES];
  82
  83 int             nodeforplayer[MAXPLAYERS];
  84
  85 int             maketic;
  86 int             lastnettic;
  87 int             skiptics;
  88 int             ticdup;
  89 int             maxsend;        // BACKUPTICS/(2*ticdup)-1
  90
  91
  92 void D_ProcessEvents (void);
  93 void G_BuildTiccmd (ticcmd_t *cmd);
  94 void D_DoAdvanceDemo (void);
  95
  96 boolean         reboundpacket;
  97 doomdata_t      reboundstore;
  98
  99 static int use_pcchecksum = 0;
 100
 101
 102 //
 103 //
 104 //
 105 int NetbufferSize (void)
 106 {
 107     return (int)&(((doomdata_t *)0)->cmds[netbuffer->numtics]);
 108 }
 109
 110 //
 111 // Checksum
 112 //
 113 unsigned NetbufferChecksum (void)
 114 {
 115     unsigned            c;
 116     int         i;
 117 #ifdef AROS
 118     int         l;
 119 #endif
 120 #ifdef __BIG_ENDIAN__
 121     ticcmd_t *t;
 122 #endif
 123
 124     c = 0x1234567;
 125
 126     // FIXME -endianess?
 127 #ifdef NORMALUNIX
 128     if (!use_pcchecksum)
 129       return 0;                 // byte order problems
 130 #endif
 131
 132 #ifdef __BIG_ENDIAN__
 133     c += SWAPLONG(*(unsigned *)&netbuffer->retransmitfrom);
 134     for (i = 0; i < netbuffer->numtics; i++) {
 135       t = &netbuffer->cmds[i];
 136       c += ((i << 1) + 2) * (((unsigned char)t->forwardmove) +
 137                              (((unsigned char)t->sidemove) << 8) +
 138                              (((unsigned short)t->angleturn) << 16));
 139       c += ((i << 1) + 3) * (((unsigned short)t->consistancy) +
 140                              (((unsigned char)t->chatchar) << 16) +
 141                              (((unsigned char)t->buttons) << 24));
 142     }
 143     return c & NCMD_CHECKSUM;
 144 #else
 145
 146     l = (NetbufferSize () - (int)&(((doomdata_t *)0)->retransmitfrom))/4;
 147     for (i=0 ; i<l ; i++)
 148         c += ((unsigned *)&netbuffer->retransmitfrom)[i] * (i+1);
 149
 150     return c & NCMD_CHECKSUM;
 151 #endif
 152 }
 153
 154 //
 155 //
 156 //
 157 int ExpandTics (int low)
 158 {
 159     int delta;
 160
 161     delta = low - (maketic&0xff);
 162
 163     if (delta >= -64 && delta <= 64)
 164         return (maketic&~0xff) + low;
 165     if (delta > 64)
 166         return (maketic&~0xff) - 256 + low;
 167     if (delta < -64)
 168         return (maketic&~0xff) + 256 + low;
 169
 170     I_Error ("ExpandTics: strange value %i at maketic %i",low,maketic);
 171     return 0;
 172 }
 173
 174
 175
 176 //
 177 // HSendPacket
 178 //
 179 void
 180 HSendPacket
 181  (int   node,
 182   int   flags )
 183 {
 184     netbuffer->checksum = NetbufferChecksum () | flags;
 185
 186     if (!node)
 187     {
 188         reboundstore = *netbuffer;
 189         reboundpacket = true;
 190         return;
 191     }
 192
 193     if (demoplayback)
 194         return;
 195
 196     if (!netgame)
 197         I_Error ("Tried to transmit to another node");
 198
 199     doomcom->command = CMD_SEND;
 200     doomcom->remotenode = node;
 201     doomcom->datalength = NetbufferSize ();
 202
 203     if (debugfile)
 204     {
 205         int             i;
 206         int             realretrans;
 207         if (netbuffer->checksum & NCMD_RETRANSMIT)
 208             realretrans = ExpandTics (netbuffer->retransmitfrom);
 209         else
 210             realretrans = -1;
 211
 212         fprintf (debugfile,"send (%i + %i, R %i) [%i] ",
 213                  ExpandTics(netbuffer->starttic),
 214                  netbuffer->numtics, realretrans, doomcom->datalength);
 215
 216         for (i=0 ; i<doomcom->datalength ; i++)
 217             fprintf (debugfile,"%i ",((byte *)netbuffer)[i]);
 218
 219         fprintf (debugfile,"\n");
 220     }
 221
 222     I_NetCmd ();
 223 }
 224
 225 //
 226 // HGetPacket
 227 // Returns false if no packet is waiting
 228 //
 229 boolean HGetPacket (void)
 230 {
 231     if (reboundpacket)
 232     {
 233         *netbuffer = reboundstore;
 234         doomcom->remotenode = 0;
 235         reboundpacket = false;
 236         return true;
 237     }
 238
 239     if (!netgame)
 240         return false;
 241
 242     if (demoplayback)
 243         return false;
 244
 245     doomcom->command = CMD_GET;
 246     I_NetCmd ();
 247
 248     if (doomcom->remotenode == -1)
 249         return false;
 250
 251     if (doomcom->datalength != NetbufferSize ())
 252     {
 253         if (debugfile)
 254             fprintf (debugfile,"bad packet length %i\n",doomcom->datalength);
 255         return false;
 256     }
 257
 258     if (NetbufferChecksum () != (netbuffer->checksum&NCMD_CHECKSUM) )
 259     {
 260         int i;
 261
 262         if (debugfile)
 263             fprintf (debugfile,"bad packet checksum\n");
 264         fprintf (stderr, "Net Packet Checksum error, %08x != %08x\n",
 265                  NetbufferChecksum(),
 266                  netbuffer->checksum&NCMD_CHECKSUM);
 267         fprintf (stderr, "%08x",
 268                  ((int *)&netbuffer->retransmitfrom)[0]);
 269         for (i = 0; i < netbuffer->numtics; i++)
 270           fprintf (stderr, " %08x %08x",
 271                    ((int *)&netbuffer->cmds[0])[2*i],
 272                    ((int *)&netbuffer->cmds[0])[2*i+1]);
 273         fprintf (stderr, "\n");
 274         return false;
 275     }
 276
 277     if (debugfile)
 278     {
 279         int             realretrans;
 280         int     i;
 281
 282         if (netbuffer->checksum & NCMD_SETUP)
 283             fprintf (debugfile,"setup packet\n");
 284         else
 285         {
 286             if (netbuffer->checksum & NCMD_RETRANSMIT)
 287                 realretrans = ExpandTics (netbuffer->retransmitfrom);
 288             else
 289                 realretrans = -1;
 290
 291             fprintf (debugfile,"get %i = (%i + %i, R %i)[%i] ",
 292                      doomcom->remotenode,
 293                      ExpandTics(netbuffer->starttic),
 294                      netbuffer->numtics, realretrans, doomcom->datalength);
 295
 296             for (i=0 ; i<doomcom->datalength ; i++)
 297                 fprintf (debugfile,"%i ",((byte *)netbuffer)[i]);
 298             fprintf (debugfile,"\n");
 299         }
 300     }
 301     return true;
 302 }
 303
 304
 305 //
 306 // GetPackets
 307 //
 308 char    exitmsg[80];
 309
 310 void GetPackets (void)
 311 {
 312     int         netconsole;
 313     int         netnode;
 314     ticcmd_t    *src, *dest;
 315     int         realend;
 316     int         realstart;
 317
 318     while ( HGetPacket() )
 319     {
 320         if (netbuffer->checksum & NCMD_SETUP)
 321             continue;           // extra setup packet
 322
 323         netconsole = netbuffer->player & ~PL_DRONE;
 324         netnode = doomcom->remotenode;
 325
 326         // to save bytes, only the low byte of tic numbers are sent
 327         // Figure out what the rest of the bytes are
 328         realstart = ExpandTics (netbuffer->starttic);
 329         realend = (realstart+netbuffer->numtics);
 330
 331         // check for exiting the game
 332         if (netbuffer->checksum & NCMD_EXIT)
 333         {
 334             if (!nodeingame[netnode])
 335                 continue;
 336             nodeingame[netnode] = false;
 337             playeringame[netconsole] = false;
 338             strcpy (exitmsg, "Player 1 left the game");
 339             exitmsg[7] += netconsole;
 340             players[consoleplayer].message = exitmsg;
 341             if (demorecording)
 342                 G_CheckDemoStatus ();
 343             continue;
 344         }
 345
 346         // check for a remote game kill
 347         if (netbuffer->checksum & NCMD_KILL)
 348             I_Error ("Killed by network driver");
 349
 350         nodeforplayer[netconsole] = netnode;
 351
 352         // check for retransmit request
 353         if ( resendcount[netnode] <= 0
 354              && (netbuffer->checksum & NCMD_RETRANSMIT) )
 355         {
 356             resendto[netnode] = ExpandTics(netbuffer->retransmitfrom);
 357             if (debugfile)
 358                 fprintf (debugfile,"retransmit from %i\n", resendto[netnode]);
 359             resendcount[netnode] = RESENDCOUNT;
 360         }
 361         else
 362             resendcount[netnode]--;
 363
 364         // check for out of order / duplicated packet
 365         if (realend == nettics[netnode])
 366             continue;
 367
 368         if (realend < nettics[netnode])
 369         {
 370             if (debugfile)
 371                 fprintf (debugfile,
 372                          "out of order packet (%i + %i)\n" ,
 373                          realstart,netbuffer->numtics);
 374             continue;
 375         }
 376
 377         // check for a missed packet
 378         if (realstart > nettics[netnode])
 379         {
 380             // stop processing until the other system resends the missed tics
 381             if (debugfile)
 382                 fprintf (debugfile,
 383                          "missed tics from %i (%i - %i)\n",
 384                          netnode, realstart, nettics[netnode]);
 385             remoteresend[netnode] = true;
 386             continue;
 387         }
 388
 389         // update command store from the packet
 390         {
 391             int         start;
 392
 393             remoteresend[netnode] = false;
 394
 395             start = nettics[netnode] - realstart;
 396             src = &netbuffer->cmds[start];
 397
 398             while (nettics[netnode] < realend)
 399             {
 400                 dest = &netcmds[netconsole][nettics[netnode]%BACKUPTICS];
 401                 nettics[netnode]++;
 402                 *dest = *src;
 403                 src++;
 404             }
 405         }
 406     }
 407 }
 408
 409
 410 //
 411 // NetUpdate
 412 // Builds ticcmds for console player,
 413 // sends out a packet
 414 //
 415 int      gametime;
 416
 417 void NetUpdate (void)
 418 {
 419     int             nowtime;
 420     int             newtics;
 421     int                         i,j;
 422     int                         realstart;
 423     int                         gameticdiv;
 424
 425     // check time
 426     nowtime = I_GetTime ()/ticdup;
 427     newtics = nowtime - gametime;
 428     gametime = nowtime;
 429
 430     if (newtics <= 0)   // nothing new to update
 431         goto listen;
 432
 433     if (skiptics <= newtics)
 434     {
 435         newtics -= skiptics;
 436         skiptics = 0;
 437     }
 438     else
 439     {
 440         skiptics -= newtics;
 441         newtics = 0;
 442     }
 443
 444
 445     netbuffer->player = consoleplayer;
 446
 447     // build new ticcmds for console player
 448     gameticdiv = gametic/ticdup;
 449     for (i=0 ; i<newtics ; i++)
 450     {
 451         I_StartTic ();
 452         D_ProcessEvents ();
 453         if (maketic - gameticdiv >= BACKUPTICS/2-1)
 454             break;          // can't hold any more
 455
 456         //printf ("mk:%i ",maketic);
 457         G_BuildTiccmd (&localcmds[maketic%BACKUPTICS]);
 458         maketic++;
 459     }
 460
 461
 462     if (singletics)
 463         return;         // singletic update is syncronous
 464
 465     // send the packet to the other nodes
 466     for (i=0 ; i<doomcom->numnodes ; i++)
 467         if (nodeingame[i])
 468         {
 469             netbuffer->starttic = realstart = resendto[i];
 470             netbuffer->numtics = maketic - realstart;
 471             if (netbuffer->numtics > BACKUPTICS)
 472                 I_Error ("NetUpdate: netbuffer->numtics > BACKUPTICS");
 473
 474             resendto[i] = maketic - doomcom->extratics;
 475
 476             for (j=0 ; j< netbuffer->numtics ; j++)
 477                 netbuffer->cmds[j] =
 478                     localcmds[(realstart+j)%BACKUPTICS];
 479
 480             if (remoteresend[i])
 481             {
 482                 netbuffer->retransmitfrom = nettics[i];
 483                 HSendPacket (i, NCMD_RETRANSMIT);
 484             }
 485             else
 486             {
 487                 netbuffer->retransmitfrom = 0;
 488                 HSendPacket (i, 0);
 489             }
 490         }
 491
 492     // listen for other packets
 493   listen:
 494     GetPackets ();
 495 }
 496
 497
 498
 499 //
 500 // CheckAbort
 501 //
 502 void CheckAbort (void)
 503 {
 504     event_t *ev;
 505     int         stoptic;
 506
 507     stoptic = I_GetTime () + 2;
 508     while (I_GetTime() < stoptic)
 509         I_StartTic ();
 510
 511     I_StartTic ();
 512     for ( ; eventtail != eventhead
 513               ; eventtail++, eventtail = (eventtail)&(MAXEVENTS-1) )
 514     {
 515         ev = &events[eventtail];
 516         if (ev->type == ev_keydown && ev->data1 == KEY_ESCAPE)
 517             I_Error ("Network game synchronization aborted.");
 518     }
 519 #ifdef __SASC
 520     chkabort ();
 521 #endif
 522 }
 523
 524
 525 //
 526 // D_ArbitrateNetStart
 527 //
 528 void D_ArbitrateNetStart (void)
 529 {
 530     int         i;
 531     boolean     gotinfo[MAXNETNODES];
 532
 533     autostart = true;
 534     memset (gotinfo,0,sizeof(gotinfo));
 535
 536     if (doomcom->consoleplayer)
 537     {
 538         // listen for setup info from key player
 539         printf ("listening for network start info...\n");
 540         while (1)
 541         {
 542 #ifdef AROS
 543             SetTaskPri(FindTask(NULL), -1);
 544             SetTaskPri(FindTask(NULL), 0);
 545 #endif
 546             CheckAbort ();
 547             if (!HGetPacket ())
 548                 continue;
 549             if (netbuffer->checksum & NCMD_SETUP)
 550             {
 551                 if (netbuffer->player != VERSION)
 552                     I_Error ("Different DOOM versions cannot play a net game!");
 553                 startskill = netbuffer->retransmitfrom & 15;
 554                 deathmatch = (netbuffer->retransmitfrom & 0xc0) >> 6;
 555                 nomonsters = (netbuffer->retransmitfrom & 0x20) > 0;
 556                 respawnparm = (netbuffer->retransmitfrom & 0x10) > 0;
 557                 startmap = netbuffer->starttic & 0x3f;
 558                 startepisode = netbuffer->starttic >> 6;
 559                 return;
 560             }
 561         }
 562     }
 563     else
 564     {
 565         // key player, send the setup info
 566         printf ("sending network start info...\n");
 567         do
 568         {
 569             CheckAbort ();
 570
 571             //printf("network start info loop: sending packets \n");
 572             for (i=0 ; i<doomcom->numnodes ; i++)
 573             {
 574                 netbuffer->retransmitfrom = startskill;
 575                 if (deathmatch)
 576                     netbuffer->retransmitfrom |= (deathmatch<<6);
 577                 if (nomonsters)
 578                     netbuffer->retransmitfrom |= 0x20;
 579                 if (respawnparm)
 580                     netbuffer->retransmitfrom |= 0x10;
 581                 netbuffer->starttic = startepisode * 64 + startmap;
 582                 netbuffer->player = VERSION;
 583                 netbuffer->numtics = 0;
 584                 HSendPacket (i, NCMD_SETUP);
 585             }
 586
 587             //printf("network start info loop: getting packets \n");
 588
 589 #if 1
 590             for(i = 10 ; i  &&  HGetPacket(); --i)
 591             {
 592                 if((netbuffer->player&0x7f) < MAXNETNODES)
 593                 {
 594                    //printf("Got Info from Player %d\n",netbuffer->player&0x7f);
 595                    gotinfo[netbuffer->player&0x7f] = true;
 596                 } else {;
 597                    //printf("Bad Info from Player %d\n",netbuffer->player&0x7f);
 598                 }
 599             }
 600 #else
 601             while (HGetPacket ())
 602             {
 603                 gotinfo[netbuffer->player&0x7f] = true;
 604             }
 605 #endif
 606
 607             for (i=1 ; i<doomcom->numnodes ; i++)
 608                 if (!gotinfo[i])
 609                     break;
 610
 611 #ifdef AROS
 612             SetTaskPri(FindTask(NULL), -1);
 613             SetTaskPri(FindTask(NULL), 0);
 614 #endif
 615         } while (i < doomcom->numnodes);
 616
 617         //printf("network start info okay for all nodes\n");
 618
 619     }
 620 }
 621
 622 //
 623 // D_CheckNetGame
 624 // Works out player numbers among the net participants
 625 //
 626 extern  int                     viewangleoffset;
 627
 628 void D_CheckNetGame (void)
 629 {
 630     int             i;
 631
 632     use_pcchecksum = M_CheckParm ("-pcchecksum");
 633
 634     for (i=0 ; i<MAXNETNODES ; i++)
 635     {
 636         nodeingame[i] = false;
 637         nettics[i] = 0;
 638         remoteresend[i] = false;        // set when local needs tics
 639         resendto[i] = 0;                // which tic to start sending
 640     }
 641
 642     // I_InitNetwork sets doomcom and netgame
 643     I_InitNetwork ();
 644     if (doomcom->id != DOOMCOM_ID)
 645         I_Error ("Doomcom buffer invalid!");
 646
 647     netbuffer = &doomcom->data;
 648     consoleplayer = displayplayer = doomcom->consoleplayer;
 649     if (netgame)
 650         D_ArbitrateNetStart ();
 651
 652     printf ("startskill %i  deathmatch: %i  startmap: %i  startepisode: %i\n",
 653             startskill, deathmatch, startmap, startepisode);
 654
 655     // read values out of doomcom
 656     ticdup = doomcom->ticdup;
 657     maxsend = BACKUPTICS/(2*ticdup)-1;
 658     if (maxsend<1)
 659         maxsend = 1;
 660
 661     for (i=0 ; i<doomcom->numplayers ; i++)
 662         playeringame[i] = true;
 663     for (i=0 ; i<doomcom->numnodes ; i++)
 664         nodeingame[i] = true;
 665
 666     printf ("player %i of %i (%i nodes)\n",
 667             consoleplayer+1, doomcom->numplayers, doomcom->numnodes);
 668
 669 }
 670
 671
 672 //
 673 // D_QuitNetGame
 674 // Called before quitting to leave a net game
 675 // without hanging the other players
 676 //
 677 void D_QuitNetGame (void)
 678 {
 679     int             i, j;
 680
 681     if (debugfile)
 682         fclose (debugfile);
 683
 684     if (!netgame || !usergame || consoleplayer == -1 || demoplayback)
 685         return;
 686
 687     // send a bunch of packets for security
 688     netbuffer->player = consoleplayer;
 689     netbuffer->numtics = 0;
 690     for (i=0 ; i<4 ; i++)
 691     {
 692         for (j=1 ; j<doomcom->numnodes ; j++)
 693             if (nodeingame[j])
 694                 HSendPacket (j, NCMD_EXIT);
 695         I_WaitVBL (1);
 696     }
 697 }
 698
 699
 700
 701 //
 702 // TryRunTics
 703 //
 704 int     frametics[4];
 705 int     frameon;
 706 int     frameskip[4];
 707 int     oldnettics;
 708
 709 extern  boolean advancedemo;
 710
 711 void TryRunTics (void)
 712 {
 713     int         i;
 714     int         lowtic;
 715     int         entertic;
 716     static int  oldentertics;
 717     int         realtics;
 718     int         availabletics;
 719     int         counts;
 720     int         numplaying;
 721
 722     // get real tics
 723     entertic = I_GetTime ()/ticdup;
 724     realtics = entertic - oldentertics;
 725     oldentertics = entertic;
 726
 727     // get available tics
 728     NetUpdate ();
 729
 730     lowtic = MAXINT;
 731     numplaying = 0;
 732     for (i=0 ; i<doomcom->numnodes ; i++)
 733     {
 734         if (nodeingame[i])
 735         {
 736             numplaying++;
 737             if (nettics[i] < lowtic)
 738                 lowtic = nettics[i];
 739         }
 740     }
 741     availabletics = lowtic - gametic/ticdup;
 742
 743     // decide how many tics to run
 744     if (realtics < availabletics-1)
 745         counts = realtics+1;
 746     else if (realtics < availabletics)
 747         counts = realtics;
 748     else
 749         counts = availabletics;
 750
 751     if (counts < 1)
 752         counts = 1;
 753
 754     frameon++;
 755
 756     if (debugfile)
 757         fprintf (debugfile,
 758                  "=======real: %i  avail: %i  game: %i\n",
 759                  realtics, availabletics,counts);
 760
 761     if (!demoplayback)
 762     {
 763         // ideally nettics[0] should be 1 - 3 tics above lowtic
 764         // if we are consistantly slower, speed up time
 765         for (i=0 ; i<MAXPLAYERS ; i++)
 766             if (playeringame[i])
 767                 break;
 768         if (consoleplayer == i)
 769         {
 770             // the key player does not adapt
 771         }
 772         else
 773         {
 774             if (nettics[0] <= nettics[nodeforplayer[i]])
 775             {
 776                 gametime--;
 777                 // printf ("-");
 778             }
 779             frameskip[frameon&3] = (oldnettics > nettics[nodeforplayer[i]]);
 780             oldnettics = nettics[0];
 781             if (frameskip[0] && frameskip[1] && frameskip[2] && frameskip[3])
 782             {
 783                 skiptics = 1;
 784                 // printf ("+");
 785             }
 786         }
 787     }// demoplayback
 788
 789     // wait for new tics if needed
 790     while (lowtic < gametic/ticdup + counts)
 791     {
 792         NetUpdate ();
 793         lowtic = MAXINT;
 794
 795         for (i=0 ; i<doomcom->numnodes ; i++)
 796             if (nodeingame[i] && nettics[i] < lowtic)
 797                 lowtic = nettics[i];
 798
 799         if (lowtic < gametic/ticdup)
 800             I_Error ("TryRunTics: lowtic < gametic");
 801
 802         // don't stay in here forever -- give the menu a chance to work
 803         if (I_GetTime ()/ticdup - entertic >= 20)
 804         {
 805             M_Ticker ();
 806             return;
 807         }
 808     }
 809
 810     // run the count * ticdup dics
 811     while (counts--)
 812     {
 813         for (i=0 ; i<ticdup ; i++)
 814         {
 815             if (gametic/ticdup > lowtic)
 816                 I_Error ("gametic>lowtic");
 817             if (advancedemo)
 818                 D_DoAdvanceDemo ();
 819             M_Ticker ();
 820             G_Ticker ();
 821             gametic++;
 822
 823             // modify command for duplicated tics
 824             if (i != ticdup-1)
 825             {
 826                 ticcmd_t        *cmd;
 827                 int                     buf;
 828                 int                     j;
 829
 830                 buf = (gametic/ticdup)%BACKUPTICS;
 831                 for (j=0 ; j<MAXPLAYERS ; j++)
 832                 {
 833                     cmd = &netcmds[j][buf];
 834                     cmd->chatchar = 0;
 835                     if (cmd->buttons & BT_SPECIAL)
 836                         cmd->buttons = 0;
 837                 }
 838             }
 839         }
 840         NetUpdate ();   // check for new console commands
 841     }
 842 }