src/d_net.c

   1 // Emacs style mode select   -*- C++ -*-
   2 //-----------------------------------------------------------------------------
   3 //
   4 // Copyright(C) 1993-1996 Id Software, Inc.
   5 // Copyright(C) 2005 Simon Howard
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License
   9 // as published by the Free Software Foundation; either version 2
  10 // of the License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20 // 02111-1307, USA.
  21 //
  22 // DESCRIPTION:
  23 //      DOOM Network game communication and protocol,
  24 //      all OS independend parts.
  25 //
  26 //-----------------------------------------------------------------------------
  27
  28
  29
  30 #include "doomfeatures.h"
  31
  32 #include "d_main.h"
  33 #include "m_argv.h"
  34 #include "m_menu.h"
  35 #include "i_system.h"
  36 #include "i_timer.h"
  37 #include "i_video.h"
  38 #include "g_game.h"
  39 #include "doomdef.h"
  40 #include "doomstat.h"
  41
  42 #include "deh_main.h"
  43
  44 #include "net_client.h"
  45 #include "net_gui.h"
  46 #include "net_io.h"
  47 #include "net_query.h"
  48 #include "net_server.h"
  49 #include "net_sdl.h"
  50 #include "net_loop.h"
  51
  52
  53 //
  54 // NETWORKING
  55 //
  56 // gametic is the tic about to (or currently being) run
  57 // maketic is the tick that hasn't had control made for it yet
  58 // nettics[] has the maketics for all players
  59 //
  60 // a gametic cannot be run until nettics[] > gametic for all players
  61 //
  62
  63 ticcmd_t        netcmds[MAXPLAYERS][BACKUPTICS];
  64 int             nettics[MAXPLAYERS];
  65
  66 int             maketic;
  67
  68 // Used for original sync code.
  69
  70 int             lastnettic;
  71 int             skiptics = 0;
  72
  73 // Reduce the bandwidth needed by sampling game input less and transmitting
  74 // less.  If ticdup is 2, sample half normal, 3 = one third normal, etc.
  75
  76 int             ticdup;
  77
  78 // Send this many extra (backup) tics in each packet.
  79
  80 int             extratics;
  81
  82 // Amount to offset the timer for game sync.
  83
  84 fixed_t         offsetms;
  85
  86 // Use new client syncronisation code
  87
  88 boolean         net_cl_new_sync = true;
  89
  90 // Connected but not participating in the game (observer)
  91
  92 boolean drone = false;
  93
  94 // 35 fps clock adjusted by offsetms milliseconds
  95
  96 static int GetAdjustedTime(void)
  97 {
  98     int time_ms;
  99
 100     time_ms = I_GetTimeMS();
 101
 102     if (net_cl_new_sync)
 103     {
 104         // Use the adjustments from net_client.c only if we are
 105         // using the new sync mode.
 106
 107         time_ms += (offsetms / FRACUNIT);
 108     }
 109
 110     return (time_ms * TICRATE) / 1000;
 111 }
 112
 113 //
 114 // NetUpdate
 115 // Builds ticcmds for console player,
 116 // sends out a packet
 117 //
 118 int      lasttime;
 119
 120 void NetUpdate (void)
 121 {
 122     int nowtime;
 123     int newtics;
 124     int i;
 125     int gameticdiv;
 126
 127     // If we are running with singletics (timing a demo), this
 128     // is all done separately.
 129
 130     if (singletics)
 131         return;
 132
 133 #ifdef FEATURE_MULTIPLAYER
 134
 135     // Run network subsystems
 136
 137     NET_CL_Run();
 138     NET_SV_Run();
 139
 140 #endif
 141
 142     // check time
 143     nowtime = GetAdjustedTime() / ticdup;
 144     newtics = nowtime - lasttime;
 145
 146     lasttime = nowtime;
 147
 148     if (skiptics <= newtics)
 149     {
 150         newtics -= skiptics;
 151         skiptics = 0;
 152     }
 153     else
 154     {
 155         skiptics -= newtics;
 156         newtics = 0;
 157     }
 158
 159     // build new ticcmds for console player
 160     gameticdiv = gametic/ticdup;
 161
 162     for (i=0 ; i<newtics ; i++)
 163     {
 164         ticcmd_t cmd;
 165
 166         I_StartTic ();
 167         D_ProcessEvents ();
 168
 169         // Always run the menu
 170
 171         M_Ticker ();
 172
 173         if (drone)
 174         {
 175             // In drone mode, do not generate any ticcmds.
 176
 177             continue;
 178         }
 179
 180         if (net_cl_new_sync)
 181         {
 182            // If playing single player, do not allow tics to buffer
 183            // up very far
 184
 185            if ((!netgame || demoplayback) && maketic - gameticdiv > 2)
 186                break;
 187
 188            // Never go more than ~200ms ahead
 189
 190            if (maketic - gameticdiv > 8)
 191                break;
 192         }
 193         else
 194         {
 195            if (maketic - gameticdiv >= 5)
 196                break;
 197         }
 198
 199         //printf ("mk:%i ",maketic);
 200         G_BuildTiccmd(&cmd);
 201
 202 #ifdef FEATURE_MULTIPLAYER
 203
 204         if (netgame && !demoplayback)
 205         {
 206             NET_CL_SendTiccmd(&cmd, maketic);
 207         }
 208
 209 #endif
 210         netcmds[consoleplayer][maketic % BACKUPTICS] = cmd;
 211
 212         ++maketic;
 213         nettics[consoleplayer] = maketic;
 214     }
 215 }
 216
 217 //
 218 // Start game loop
 219 //
 220 // Called after the screen is set but before the game starts running.
 221 //
 222
 223 void D_StartGameLoop(void)
 224 {
 225     lasttime = GetAdjustedTime() / ticdup;
 226 }
 227
 228
 229 //
 230 // D_CheckNetGame
 231 // Works out player numbers among the net participants
 232 //
 233 extern  int                     viewangleoffset;
 234
 235 void D_CheckNetGame (void)
 236 {
 237     int i;
 238     int num_players;
 239
 240     // default values for single player
 241
 242     consoleplayer = 0;
 243     netgame = false;
 244     ticdup = 1;
 245     extratics = 1;
 246     lowres_turn = false;
 247     offsetms = 0;
 248
 249     for (i=0; i<MAXPLAYERS; i++)
 250     {
 251         playeringame[i] = false;
 252         nettics[i] = 0;
 253     }
 254
 255     playeringame[0] = true;
 256
 257 #ifdef FEATURE_MULTIPLAYER
 258
 259     {
 260         net_addr_t *addr = NULL;
 261
 262         //!
 263         // @category net
 264         //
 265         // Start a multiplayer server, listening for connections.
 266         //
 267
 268         if (M_CheckParm("-server") > 0)
 269         {
 270             NET_SV_Init();
 271             NET_SV_AddModule(&net_loop_server_module);
 272             NET_SV_AddModule(&net_sdl_module);
 273
 274             net_loop_client_module.InitClient();
 275             addr = net_loop_client_module.ResolveAddress(NULL);
 276         }
 277         else
 278         {
 279             //!
 280             // @category net
 281             //
 282             // Automatically search the local LAN for a multiplayer
 283             // server and join it.
 284             //
 285
 286             i = M_CheckParm("-autojoin");
 287
 288             if (i > 0)
 289             {
 290                 addr = NET_FindLANServer();
 291
 292                 if (addr == NULL)
 293                 {
 294                     I_Error("No server found on local LAN");
 295                 }
 296             }
 297
 298             //!
 299             // @arg <address>
 300             // @category net
 301             //
 302             // Connect to a multiplayer server running on the given
 303             // address.
 304             //
 305
 306             i = M_CheckParm("-connect");
 307
 308             if (i > 0)
 309             {
 310                 net_sdl_module.InitClient();
 311                 addr = net_sdl_module.ResolveAddress(myargv[i+1]);
 312
 313                 if (addr == NULL)
 314                 {
 315                     I_Error("Unable to resolve '%s'\n", myargv[i+1]);
 316                 }
 317             }
 318         }
 319
 320         if (addr != NULL)
 321         {
 322             if (M_CheckParm("-drone") > 0)
 323             {
 324                 drone = true;
 325             }
 326
 327             //!
 328             // @category net
 329             //
 330             // Run as the left screen in three screen mode.
 331             //
 332
 333             if (M_CheckParm("-left") > 0)
 334             {
 335                 viewangleoffset = ANG90;
 336                 drone = true;
 337             }
 338
 339             //!
 340             // @category net
 341             //
 342             // Run as the right screen in three screen mode.
 343             //
 344
 345             if (M_CheckParm("-right") > 0)
 346             {
 347                 viewangleoffset = ANG270;
 348                 drone = true;
 349             }
 350
 351             if (!NET_CL_Connect(addr))
 352             {
 353                 I_Error("D_CheckNetGame: Failed to connect to %s\n",
 354                         NET_AddrToString(addr));
 355             }
 356
 357             printf("D_CheckNetGame: Connected to %s\n", NET_AddrToString(addr));
 358
 359             NET_WaitForStart();
 360         }
 361     }
 362
 363 #endif
 364
 365     num_players = 0;
 366
 367     for (i=0; i<MAXPLAYERS; ++i)
 368     {
 369         if (playeringame[i])
 370             ++num_players;
 371     }
 372
 373     DEH_printf("startskill %i  deathmatch: %i  startmap: %i  startepisode: %i\n",
 374                startskill, deathmatch, startmap, startepisode);
 375
 376     DEH_printf("player %i of %i (%i nodes)\n",
 377                consoleplayer+1, num_players, num_players);
 378
 379     // Show players here; the server might have specified a time limit
 380
 381     if (timelimit > 0)
 382     {
 383         DEH_printf("Levels will end after %d minute", timelimit);
 384         if (timelimit > 1)
 385             printf("s");
 386         printf(".\n");
 387     }
 388 }
 389
 390
 391 //
 392 // D_QuitNetGame
 393 // Called before quitting to leave a net game
 394 // without hanging the other players
 395 //
 396 void D_QuitNetGame (void)
 397 {
 398     if (debugfile)
 399         fclose (debugfile);
 400
 401 #ifdef FEATURE_MULTIPLAYER
 402
 403     NET_SV_Shutdown();
 404     NET_CL_Disconnect();
 405
 406 #endif
 407
 408 }
 409
 410 // Returns true if there are currently any players in the game.
 411
 412 static boolean PlayersInGame(void)
 413 {
 414     int i;
 415
 416     for (i=0; i<MAXPLAYERS; ++i)
 417     {
 418         if (playeringame[i])
 419         {
 420             return true;
 421         }
 422     }
 423
 424     return false;
 425 }
 426
 427 static int GetLowTic(void)
 428 {
 429     int i;
 430     int lowtic;
 431
 432 #ifdef FEATURE_MULTIPLAYER
 433     if (net_client_connected)
 434     {
 435         lowtic = INT_MAX;
 436
 437         for (i=0; i<MAXPLAYERS; ++i)
 438         {
 439             if (playeringame[i])
 440             {
 441                 if (nettics[i] < lowtic)
 442                     lowtic = nettics[i];
 443             }
 444         }
 445     }
 446     else
 447 #endif
 448     {
 449         lowtic = maketic;
 450     }
 451
 452     return lowtic;
 453 }
 454
 455 //
 456 // TryRunTics
 457 //
 458 int     oldnettics;
 459 int     frametics[4];
 460 int     frameon;
 461 int     frameskip[4];
 462 int     oldnettics;
 463
 464 extern  boolean advancedemo;
 465
 466 void TryRunTics (void)
 467 {
 468     int i;
 469     int lowtic;
 470     int entertic;
 471     static int oldentertics;
 472     int realtics;
 473     int availabletics;
 474     int counts;
 475
 476     // get real tics
 477     entertic = I_GetTime() / ticdup;
 478     realtics = entertic - oldentertics;
 479     oldentertics = entertic;
 480
 481     // get available tics
 482     NetUpdate ();
 483
 484     lowtic = GetLowTic();
 485
 486     availabletics = lowtic - gametic/ticdup;
 487
 488     // decide how many tics to run
 489
 490     if (net_cl_new_sync)
 491     {
 492         counts = availabletics;
 493     }
 494     else
 495     {
 496         // decide how many tics to run
 497         if (realtics < availabletics-1)
 498             counts = realtics+1;
 499         else if (realtics < availabletics)
 500             counts = realtics;
 501         else
 502             counts = availabletics;
 503
 504         if (counts < 1)
 505             counts = 1;
 506
 507         frameon++;
 508
 509         if (!demoplayback)
 510         {
 511             int keyplayer = -1;
 512
 513             // ideally maketic should be 1 - 3 tics above lowtic
 514             // if we are consistantly slower, speed up time
 515
 516             for (i=0 ; i<MAXPLAYERS ; i++)
 517             {
 518                 if (playeringame[i])
 519                 {
 520                     keyplayer = i;
 521                     break;
 522                 }
 523             }
 524
 525             if (keyplayer < 0)
 526             {
 527                 // If there are no players, we can never advance anyway
 528
 529                 return;
 530             }
 531
 532             if (consoleplayer == keyplayer)
 533             {
 534                 // the key player does not adapt
 535             }
 536             else
 537             {
 538                 if (maketic <= nettics[keyplayer])
 539                 {
 540                     lasttime--;
 541                     // printf ("-");
 542                 }
 543
 544                 frameskip[frameon & 3] = (oldnettics > nettics[keyplayer]);
 545                 oldnettics = maketic;
 546
 547                 if (frameskip[0] && frameskip[1] && frameskip[2] && frameskip[3])
 548                 {
 549                     skiptics = 1;
 550                     // printf ("+");
 551                 }
 552             }
 553         }
 554     }
 555
 556     if (counts < 1)
 557         counts = 1;
 558
 559     // wait for new tics if needed
 560
 561     while (!PlayersInGame() || lowtic < gametic/ticdup + counts)
 562     {
 563         NetUpdate ();
 564
 565         lowtic = GetLowTic();
 566
 567         if (lowtic < gametic/ticdup)
 568             I_Error ("TryRunTics: lowtic < gametic");
 569
 570         // Don't stay in this loop forever.  The menu is still running,
 571         // so return to update the screen
 572
 573         if (I_GetTime() / ticdup - entertic > 0)
 574         {
 575             return;
 576         }
 577
 578         I_Sleep(1);
 579     }
 580
 581     // run the count * ticdup dics
 582     while (counts--)
 583     {
 584         for (i=0 ; i<ticdup ; i++)
 585         {
 586             // check that there are players in the game.  if not, we cannot
 587             // run a tic.
 588
 589             if (!PlayersInGame())
 590             {
 591                 return;
 592             }
 593
 594             if (gametic/ticdup > lowtic)
 595                 I_Error ("gametic>lowtic");
 596             if (advancedemo)
 597                 D_DoAdvanceDemo ();
 598
 599             G_Ticker ();
 600             gametic++;
 601
 602             // modify command for duplicated tics
 603             if (i != ticdup-1)
 604             {
 605                 ticcmd_t        *cmd;
 606                 int                     buf;
 607                 int                     j;
 608
 609                 buf = (gametic/ticdup)%BACKUPTICS;
 610                 for (j=0 ; j<MAXPLAYERS ; j++)
 611                 {
 612                     cmd = &netcmds[j][buf];
 613                     cmd->chatchar = 0;
 614                     if (cmd->buttons & BT_SPECIAL)
 615                         cmd->buttons = 0;
 616                 }
 617             }
 618         }
 619         NetUpdate ();   // check for new console commands
 620     }
 621 }
 622