netbuffer->player = consoleplayer;
    
    // build new ticcmds for console player
    gameticdiv = gametic/ticdup;
    for (i=0 ; i<newtics && bInGame/*DQ*/; i++)
    {
	I_StartTic ();
	D_ProcessEvents ();
	if (maketic - gameticdiv >= BACKUPTICS/2-1)
	    break;          // can't hold any more
	
	//printf ("mk:%i ",maketic);
    //WriteDebug("NetUpdate calling G_BuildTiccmd...\n");
	G_BuildTiccmd (&localcmds[maketic%BACKUPTICS]);
	maketic++;
    }


    if (singletics)
	return;         // singletic update is syncronous
    
    // send the packet to the other nodes
    for (i=0 ; i<doomcom->numnodes ; i++)
	if (nodeingame[i])
	{
	    netbuffer->starttic = realstart = resendto[i];
	    netbuffer->numtics = maketic - realstart;
	    if (netbuffer->numtics > BACKUPTICS)
		I_Error ("NetUpdate: netbuffer->numtics > BACKUPTICS");

	    resendto[i] = maketic - doomcom->extratics;

	    for (j=0 ; j< netbuffer->numtics ; j++)
		netbuffer->cmds[j] = 
		    localcmds[(realstart+j)%BACKUPTICS];
					
	    if (remoteresend[i])
	    {
		netbuffer->retransmitfrom = nettics[i];
		HSendPacket (i, NCMD_RETRANSMIT);
	    }
	    else
	    {
		netbuffer->retransmitfrom = 0;
		HSendPacket (i, 0);
	    }
	}
    
    // listen for other packets
  listen:
    GetPackets ();
}


extern HACCEL ghAccel;
extern BOOL bQuit;
//
// CheckAbort
//
void CheckAbort (void)
   {
    event_t *ev;
    int		stoptic;
    MSG     msg;
	
    stoptic = I_GetTime()+2; 
    while (I_GetTime() < stoptic)
       {
        while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
		   {
            if (msg.message == WM_QUIT)
			   {
				bQuit = TRUE;
                break;
               }
            if (!TranslateAccelerator(msg.hwnd, ghAccel, &msg))
			   {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
               }
           }
        HandleKeyboard();
       I_StartTic(); 
   }
	
    I_StartTic();
    for ( ; eventtail != eventhead ; eventtail = (++eventtail)&(MAXEVENTS-1)) 
       { 
        ev = &events[eventtail]; 
        if (ev->type == ev_keydown && ev->data1 == KEY_ESCAPE)
            I_Error ("Network game synchronization aborted.");
       } 
   }


//
// D_ArbitrateNetStart
//
void D_ArbitrateNetStart (void)
   {
    int		i;
    boolean	gotinfo[MAXNETNODES];
    static  int timeout = 0;
	
    autostart = true;
    memset (gotinfo,0,sizeof(gotinfo));
	
    if (doomcom->consoleplayer)
    {
	// listen for setup info from key player
	WriteDebug("listening for network start info...Console\n");
	while (1)
	   {
        //timeout += I_GetTime();
        //if (timeout > 8400)
        //   I_Error("Network game synchronization timed out...\n");
	    CheckAbort();
	    if (!HGetPacket())
		   continue;
	    if (netbuffer->checksum & NCMD_SETUP)
	    {
		if (netbuffer->player != VERSION)
		    I_Error ("Different DOOM versions cannot play a net game!");
		startskill = netbuffer->retransmitfrom & 15;
		deathmatch = (netbuffer->retransmitfrom & 0xc0) >> 6;
		nomonsters = (netbuffer->retransmitfrom & 0x20) > 0;
		respawnparm = (netbuffer->retransmitfrom & 0x10) > 0;
		startmap = netbuffer->starttic & 0x3f;
		startepisode = netbuffer->starttic >> 6;
		return;
	    }
	}
    }
    else
    {
	// key player, send the setup info
	sprintf (MsgText,"sending network start info...\n");
    WriteDebug(MsgText);
	do
	{
	    CheckAbort ();
	    for (i=0 ; i<doomcom->numnodes ; i++)
	    {
		netbuffer->retransmitfrom = startskill;
		if (deathmatch)
		    netbuffer->retransmitfrom |= (deathmatch<<6);
		if (nomonsters)
		    netbuffer->retransmitfrom |= 0x20;
		if (respawnparm)
		    netbuffer->retransmitfrom |= 0x10;
		netbuffer->starttic = startepisode * 64 + startmap;
		netbuffer->player = VERSION;
		netbuffer->numtics = 0;
		HSendPacket (i, NCMD_SETUP);
	    }

#if 1
	    for(i = 10 ; i  &&  HGetPacket(); --i)
	    {
		if((netbuffer->player&0x7f) < MAXNETNODES)
		    gotinfo[netbuffer->player&0x7f] = true;
	    }
#else
	    while (HGetPacket ())
	    {
		gotinfo[netbuffer->player&0x7f] = true;
	    }
#endif

	    for (i=1 ; i<doomcom->numnodes ; i++)
		if (!gotinfo[i])
		    break;
	} while (i < doomcom->numnodes);
    }
}

//
// D_CheckNetGame
// Works out player numbers among the net participants
//
extern	int			viewangleoffset;

void D_CheckNetGame (void)
{
    int             i;
	
    for (i=0 ; i<MAXNETNODES ; i++)
    {
	nodeingame[i] = false;
       	nettics[i] = 0;
	remoteresend[i] = false;	// set when local needs tics
	resendto[i] = 0;		// which tic to start sending
    }
	
    // I_InitNetwork sets doomcom and netgame
    I_InitNetwork ();
    if (doomcom->id != DOOMCOM_ID)
	    I_Error ("Doomcom buffer invalid!");
    
    netbuffer = &doomcom->data;
    consoleplayer = displayplayer = doomcom->consoleplayer;
    if (netgame)
        D_ArbitrateNetStart();

    //printf ("startskill %i  deathmatch: %i  startmap: %i  startepisode: %i\n",
    sprintf (MsgText, "startskill %i  deathmatch: %i  startmap: %i  startepisode: %i\n",
	    startskill, deathmatch, startmap, startepisode);
    WriteDebug(MsgText);

    // read values out of doomcom
    ticdup = doomcom->ticdup;
    maxsend = BACKUPTICS/(2*ticdup)-1;
    if (maxsend<1)
	maxsend = 1;
			
    for (i=0 ; i<doomcom->numplayers ; i++)
	playeringame[i] = true;
    for (i=0 ; i<doomcom->numnodes ; i++)
	nodeingame[i] = true;
	
    //printf ("player %i of %i (%i nodes)\n",
    sprintf (MsgText, "player %i of %i (%i nodes)\n",
	    consoleplayer+1, doomcom->numplayers, doomcom->numnodes);
    WriteDebug(MsgText);
}


//
// D_QuitNetGame
// Called before quitting to leave a net game
// without hanging the other players
//
void D_QuitNetGame (void)
   {
    int             i, j;
	
    if (debugfile)
	fclose (debugfile);
		
    if (!netgame || !usergame || consoleplayer == -1 || demoplayback)
	return;
	
    // send a bunch of packets for security
    netbuffer->player = consoleplayer;
    netbuffer->numtics = 0;
    for (i=0 ; i<4 ; i++)
    {
	for (j=1 ; j<doomcom->numnodes ; j++)
	    if (nodeingame[j])
		HSendPacket (j, NCMD_EXIT);
	I_WaitVBL (1);
    }
    WSACleanup();
   }



//
// TryRunTics
//
int	frametics[4];
int	frameon;
int	frameskip[4];
int	oldnettics;

extern	boolean	advancedemo;

void TryRunTics (void)
   {
    int		i;
    int		lowtic;
    int		entertic;
    static int	oldentertics;
    int		realtics;
    int		availabletics;
    int		counts;
    int		numplaying;
    
    // get real tics		
    entertic = I_GetTime ()/ticdup;
    realtics = entertic - oldentertics;
    oldentertics = entertic;
    
    // get available tics
    //WriteDebug("NetUpdate...\n");
    NetUpdate ();
	
    //WriteDebug("NetUpdate done...\n");
    lowtic = MAXINT;
    numplaying = 0;
    for (i = 0; i < doomcom->numnodes; i++)
       {
        if (nodeingame[i])
           {
            numplaying++;
            if (nettics[i] < lowtic)
               lowtic = nettics[i];
           }
       }
    availabletics = lowtic - gametic/ticdup;
    
    // decide how many tics to run
    if (realtics < availabletics-1)
        counts = realtics+1;
    else
    if (realtics < availabletics)
        counts = realtics;
    else
        counts = availabletics;
    
    if (counts < 1)
        counts = 1;
		
    frameon++;

    if (debugfile)
        fprintf (debugfile, "=======real: %i  avail: %i  game: %i\n", realtics, availabletics,counts);

    if (!demoplayback)
       {	
        // ideally nettics[0] should be 1 - 3 tics above lowtic
        // if we are consistantly slower, speed up time
        for (i = 0; i < MAXPLAYERS; i++)
	    if (playeringame[i])
            break;
        if (consoleplayer == i)
           {
            // the key player does not adapt
           }
        else
           {
            if (nettics[0] <= nettics[nodeforplayer[i]])
               {
                gametime--;
                // printf ("-");
               }
            frameskip[frameon&3] = (oldnettics > nettics[nodeforplayer[i]]);
            oldnettics = nettics[0];
            if (frameskip[0] && frameskip[1] && frameskip[2] && frameskip[3])
               {
                skiptics = 1;
                // printf ("+");
               }
           }
       }// demoplayback
	
    // wait for new tics if needed
    while (lowtic < gametic/ticdup + counts)	
       {
        NetUpdate();   
        lowtic = MAXINT;

        for (i = 0; i < doomcom->numnodes; i++)
        if (nodeingame[i] && nettics[i] < lowtic)
            lowtic = nettics[i];

        if (lowtic < gametic/ticdup)
            I_Error ("TryRunTics: lowtic < gametic");
				
        // don't stay in here forever -- give the menu a chance to work
        //WriteDebug("I_GetTime...\n");
        if (I_GetTime ()/ticdup - entertic >= 20)
           {
            CO_Ticker();
            //WriteDebug("M_Ticker...\n");
            M_Ticker ();
            return;
           } 
       }
    
    // run the count * ticdup dics
    while (counts--)
       {
        for (i = 0; i < ticdup; i++)
           {
            if (gametic/ticdup > lowtic)
                I_Error ("gametic>lowtic");
            if (advancedemo)
               {
                //WriteDebug("D_DoAdvanceDemo...\n");
                D_DoAdvanceDemo ();
               }
            CO_Ticker();
            //WriteDebug("M_Ticker...\n");
            M_Ticker ();
            //WriteDebug("G_Ticker...\n");
            G_Ticker ();
            gametic++;
	    
            // modify command for duplicated tics
            if (i != ticdup-1)
               {
                ticcmd_t   *cmd;
                int         buf;
                int         j;
				
                buf = (gametic/ticdup)%BACKUPTICS; 
                for (j = 0; j < MAXPLAYERS; j++)
		           {
                    cmd = &netcmds[j][buf];
                    cmd->chatchar = 0;
                    if (cmd->buttons & BT_SPECIAL)
                        cmd->buttons = 0;
                   }
               }
           }
        //WriteDebug("NetUpdate - 2...\n");
        NetUpdate();	// check for new console commands
       }
   }