Ensure a consistent view of time in multiplayer games

Ignore-this: 6c5f44255ecd2d5e98c1bf7f421edf52

darcs-hash:20110704223446-99289-130ee76c45bb3673da4964794551a4cd57f7d8b7

Author: Alex Smith

include/extern.h

@@ -2067,6 +2067,7 @@ E boolean FDECL(obj_is_local, (struct obj *));
 E void FDECL(save_timers, (int,int,int));
 E void FDECL(restore_timers, (int,int,BOOLEAN_P,long));
 E void FDECL(relink_timers, (BOOLEAN_P));
+E void FDECL(adjust_nonlocal_timers, (long));
 #ifdef WIZARD
 E int NDECL(wiz_timeout_queue);
 E void NDECL(timer_sanity_check);

src/allmain.c

@@ -823,16 +823,20 @@ found_game_to_attach_to: ;
            right down the pipe. */
         restore_dungeon(mpcfd);
 
-        /* A bit of a weird dependency issue here. We have to uncheckpoint
-           before placing the player on the stairs, or we don't know where
-           the stairs are. But we have to place the player on the stairs
-           before uncheckpointing, or the game tries to move the cursor
-           off the map, leading to an infinite loop. The solution is to
-           get the coordinates from the other game. */
+        /* A bit of a weird dependency issue here. We have to
+           uncheckpoint before placing the player on the stairs, or we
+           don't know where the stairs are. But we have to place the
+           player on the stairs before uncheckpointing, or the game
+           tries to move the cursor off the map, leading to an
+           infinite loop. The solution is to get the coordinates from
+           the other game. We also get the current time from the other
+           game, because the timings must be approximately in sync. */
         if (read(mpcfd, &u.ux, sizeof(u.ux)) <= 0 ||
-            read(mpcfd, &u.uy, sizeof(u.uy)) <= 0) {
+            read(mpcfd, &u.uy, sizeof(u.uy)) <= 0 ||
+            read(mpcfd, &monstermoves, sizeof(monstermoves)) <= 0) {
           panic("Multiplayer control pipe read failure");
         }
+        moves = monstermoves;
 
         /* Remove watchdog timer. */
         alarm(0);

src/apply.c

@@ -1,6 +1,6 @@
 /*	SCCS Id: @(#)apply.c	3.4	2003/11/18	*/
 /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
-/* Modified 19 Aug 2011 by Alex Smith */
+/* Modified 16 Jun 2011 by Alex Smith */
 /* NetHack may be freely redistributed.  See license for details. */
 
 #include "hack.h"
@@ -422,6 +422,10 @@ struct obj *obj;
 	register struct monst *mtmp;
 	int spotmon;
 
+        if(iflags.multiplayer) {
+                pline("Leashes do not work in multiplayer games.");
+                return;
+        }
 	if(!obj->leashmon && number_leashed() >= MAXLEASHED) {
 		You("cannot leash any more pets.");
 		return;

src/cmd.c

@@ -567,16 +567,29 @@ doinvite()
   }
 
   /* Avoid multiplayer-unsafe or yield-unsafe circumstances. */
+  if (iflags.multiplayer && strcmp(iflags.mp_lock_name, mplock))
+  { /* would garble lockfiles, and is anyway best from a game management
+       point of view */
+    pline("All invitations into a game must be done by the same person.");
+    return 0;
+  }
   if (u.usteed)
-  {
+  { /* multiplayer-unsafe (pointer from lockfile 0 to other lockfiles) */
     You_cant("ride a steed in multiplayer.");
     return 0;
   }
   if (u.ustuck)
-  {
+  { /* yield-unsafe */
     You_cant("invite a player while %s has you trapped!", a_monnam(u.ustuck));
     return 0;
   }
+  /* This limitation is not because it would crash the program, but because
+     it effectively leashes the pet to all players on the level at once,
+     which is not at all what people expect. */
+  if (number_leashed()) {
+    You_cant("leash pets in multiplayer. Unleash them before inviting.");
+    return 0;
+  }
 
   /* This leaks a tiny bit of information. Oh well... */
   if ((mtmp = m_at(sstairs.sx,sstairs.sy))) {
@@ -634,10 +647,12 @@ doinvite()
     save_dungeon(fd, TRUE, FALSE);
     /* It needs to know the player's coordinates, too, to do things
        in the right order. x and y are the same size as u.ux and
-       u.uy, or this wouldn't work. */
+       u.uy, or this wouldn't work. Likewise, we need to ensure that
+       the games have a consistent view of time. */
     x = sstairs.sx; y = sstairs.sy;
     if (write(fd, &x, sizeof(u.ux)) <= 0 ||
-        write(fd, &y, sizeof(u.uy)) <= 0) {
+        write(fd, &y, sizeof(u.uy)) <= 0 ||
+        write(fd, &monstermoves, sizeof(monstermoves)) <= 0) {
       panic("Multiplayer control pipe write failure");
     }
     /* Now the other end has control, and we're just waiting on a

src/do.c

@@ -1091,6 +1091,7 @@ checkpoint_level()
   mtmp->female = poly_gender();
   initedog(mtmp); /* mark as tame */
   mtmp->mtame = 127;
+  mtmp->mlstmv = monstermoves; /* indicate what this level's "local time" is */
   /* Setting the movement value is very important, so that the other
      games know whether they should yield to us this turn. */
   mtmp->movement = youmonst.movement;
@@ -1157,6 +1158,123 @@ uncheckpoint_level()
   return 0; /* successful */
 }
 
+/* Looks at the current level, to deduce what its local time is.  We
+   rely on the facts that a) nothing on the level can be dated in the
+   future, and b) any other players on the level are flagged with
+   their current times, so that if there are other players there, the
+   times will line up exactly (to within a turn, anyway). */
+static long
+calculate_objchain_local_time(ochain)
+struct obj *ochain;
+{
+  struct obj *otmp;
+  long localtime = 0L;
+  for (otmp = ochain; otmp; otmp = otmp->nobj) {
+    if (age_is_relative(otmp)) continue;
+    if (otmp->age > localtime) localtime = otmp->age;
+    /* Age has a different meaning inside ice boxes. */
+    if (Has_contents(otmp) && otmp->otyp != ICE_BOX) {
+      long t = calculate_objchain_local_time(otmp->cobj);
+      if (t > localtime) localtime = t;
+    }
+  }
+  return localtime;
+}
+static long
+calculate_level_local_time()
+{
+  struct monst *mtmp;
+  long localtime = -1L;
+  long t;
+
+  for (mtmp = fmon; mtmp; mtmp = mtmp->nmon) {
+    if (DEADMONSTER(mtmp)) continue;
+    if (mtmp->mlstmv > localtime) localtime = mtmp->mlstmv;
+    if (mtmp->minvent) {
+      t = calculate_objchain_local_time(mtmp->minvent);
+      if (t > localtime) localtime = t;
+    }
+    if (mtmp->mw && mtmp->mw->age > localtime) localtime = mtmp->mw->age;
+  }
+  t = calculate_objchain_local_time(fobj);
+  if (t > localtime) localtime = t;
+  t = calculate_objchain_local_time(level.buriedobjlist, FALSE);
+  if (t > localtime) localtime = t;
+  if (localtime == -1) {
+    /* no monsters or items on the level; this is rather unlikely, but
+       theoretically possible, and in this case we can choose the time
+       we like for the level's local time, so set it to our own local
+       time */
+    localtime = monstermoves;
+  }
+  return localtime;
+}
+
+static void
+time_dilate_objchain(ochain, dtime)
+struct obj *ochain;
+long dtime;
+{
+  struct obj *otmp;
+  for (otmp = ochain; otmp; otmp = otmp->nobj) {
+    if (age_is_relative(otmp)) continue;
+    otmp->age += dtime;
+    /* Age has a different meaning inside ice boxes. */
+    if (Has_contents(otmp) && otmp->otyp != ICE_BOX)
+      time_dilate_objchain(otmp->cobj, dtime);
+  }
+}
+static void
+time_dilate_monchain(mchain, dtime)
+struct monst *mchain;
+long dtime;
+{
+  struct monst *mtmp;
+  for (mtmp = mchain; mtmp; mtmp = mtmp->nmon) {
+    if (DEADMONSTER(mtmp)) continue;
+    mtmp->mlstmv += dtime;
+    if (mtmp->minvent) time_dilate_objchain(mtmp->minvent, dtime);
+    /* Assume monsters don't wield containers. */
+    if (mtmp->mw && !age_is_relative(mtmp->mw)) mtmp->mw->age += dtime;
+  }
+}
+
+/* Adjusts all timestamps saved in lockfile 0 by the given amount. */
+static void
+time_dilation(dtime)
+long dtime;
+{
+    /* nothing relevant in flags */
+    /* timestamps in struct you */
+    u.ucleansed += dtime;
+    u.usleep += dtime;
+    /* timers */
+    adjust_nonlocal_timers(dtime);
+    /* nothing relevant in light sources */
+    /* inventory */
+    time_dilate_objchain(invent, dtime);
+    /* migration */
+    time_dilate_objchain(migrating_objs, dtime);
+    time_dilate_monchain(migrating_mons, dtime);
+    /* nothing relevant in monster statistics */
+    /* nothing relevant in dungeons or level chains */
+    /* time handling */
+    moves += dtime;
+    monstermoves += dtime;
+    /* nothing relevant in quest status */
+    /* nothing relevant in spells (perhaps surprisingly, spell
+       knowledge is relative not absolute) */
+    /* nothing relevant in artifacts */
+    /* nothing relevant in oracularities */
+    /* stuck/steed are not multiplayer-safe, so needn't be adjusted */
+    /* nothing relevant in tutorial flags (TODO: the tutorial is currently
+       based on local time, when it should be based on character time,
+       but we can't fix that here) */
+    /* nothing relevant in character name */
+    /* nothing relevant in fruitnames */
+    /* nothing relevant in Plane of Water status */
+}
+
 #ifdef INSURANCE
 void
 save_currentstate()
@@ -1504,16 +1622,20 @@ boolean at_stairs, falling, portal;
 		(void) close(fd);
 	}
 
-        /* We must release the lock before anything that could print
-           messages, to avoid panicking other processes; the error
-           on level file removal above is OK, though, because it can
-           only happen if someone's gone around deleting files while
-           we have them locked, which would crash those processes
-           anyway. */
         if (iflags.multiplayer) {
+          /* We must release the lock before anything that could print
+             messages, to avoid panicking other processes; the error
+             on level file removal above is OK, though, because it can
+             only happen if someone's gone around deleting files while
+             we have them locked, which would crash those processes
+             anyway. */
           Strcpy(lock, iflags.mp_lock_name);
           set_levelfile_name(lock, new_ledger);
           unlock_file(lock);
+
+          /* We also need to adjust for local time, before doing
+             anything that might depend on timers. */
+          time_dilation(calculate_level_local_time() - monstermoves);
         }
 
 	/* do this prior to level-change pline messages */

src/timeout.c

@@ -1,6 +1,6 @@
 /*	SCCS Id: @(#)timeout.c	3.4	2002/12/17	*/
 /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
-/* Modified 3 Jan 2011 by Alex Smith */
+/* Modified 4 Jul 2011 by Alex Smith */
 /* NetHack may be freely redistributed.  See license for details. */
 
 #include "hack.h"
@@ -1868,6 +1868,35 @@ relink_timers(ghostly)
     }
 }
 
+/* change the timeout time of all nonlocal timers by the given delta */
+void
+adjust_nonlocal_timers(dtime)
+long dtime;
+{
+    timer_element *prev, *curr, *ttmp, *nonlocals = 0;
+
+    /* unchain all nonlocal timers from the existing chain, and adjust
+       their timeouts */
+    for (prev = 0, curr = timer_base; curr; prev = curr, curr = curr->next) {
+      while (curr && !timer_is_local(curr)) {
+        if (!prev) timer_base = curr->next;
+        else prev->next = curr->next;
+        ttmp = curr;
+        curr = curr->next;
+        ttmp->next = nonlocals;
+        ttmp->timeout += dtime;
+        nonlocals = ttmp;
+      }
+      if (!curr) break;
+    }
+
+    /* then add them back to the original chain */
+    for (curr = nonlocals; curr; curr = ttmp) {
+      ttmp = curr->next;
+      insert_timer(curr);
+    }
+}
+
 #endif /* OVL0 */
 
 /*timeout.c*/