---

rules.c

Go to the documentation of this file.

/**********************************************************************
*       FILE:   rules.c
*       AUTHOR: Evan H. B
*       DATE:   29-30 April, 1993
*       PURPOSE: Makes sure the game doesn't screw up.
**********************************************************************/

#include "map.h"
#include "rules.h"
#include "players.h"
#include "random.h"
#include <time.h>       // Shoot your seed into the random number generator

bool Rules::DetectivesTrapped (void)
  {
   int counter;
   MoveList *steinBrenner;       // YOU got a better name?

   for (counter = 1; counter < NumPlayers; counter++)
     {
      steinBrenner = GetLegalMoves (*thePlayers [counter]);
      if (steinBrenner->Length ()) return False;
     }
   return True;
  }

int Rules::SpyCaught (void)
  {
   PosType spyPos, sleuthPos;
   int counter;

   spyPos = thePlayers [theSpy] -> GetPosition ();
   for (counter = 1; counter < NumPlayers; counter++)
     {
      sleuthPos = thePlayers [counter] -> GetPosition ();
      if (spyPos == sleuthPos) return counter;
     }
   return False;
  }

PosType Rules::RandomPos (void)
  {
   static playPosition [MAXPLAYERS];
   static int nextPlayer = 0;
   int min, max, counter, ok = False;
   PosType randPos;

   max = theMap.num_nodes ();
   while (!ok)
     {
      randPos = (Random * max) + 1;
      ok = True;
      while ((ok) && (counter < nextPlayer))
  if (randPos == playPosition [counter++]) ok = False;
      if (ok) playPosition [nextPlayer++] = randPos;
     }
   return randPos;
  }

int Rules::StartingTokens (TokenType identity)
  {
   switch (identity)
     {
      case Subway: return NUM_SUBWAY_TOKENS;
      case Taxi: return NUM_TAXI_TOKENS;
      case Bus: return NUM_BUS_TOKENS;
      default : return 0;   // F---ing compiler!!!!!!!!!
     }
  }

Move *Rules::CanGo (int taxi, int bus, int subway,
        PosType source, PosType dest)
  {
   Move *nextMove;
   int byTaxi, byBus, bySubway;        // We're bullish on the future (buy)
   PosType nextNode;

   byBus = theMap.bus (source, dest);   // Can we get there from here?
   byTaxi = theMap.taxi (source, dest);
   bySubway = theMap.subway (source, dest);

   byBus *= bus;                        // Can we pay for it?
   byTaxi *= taxi;                      // Confucius say -
   bySubway *= subway;                  // No tokie, no tickee!

   if (! (byBus | byTaxi | bySubway)) return NULL;      // Yer stuck!

   nextMove = new Move;                                 // Hungry hippoes

   if (byBus) nextMove -> Trans |= BusMask;             // Transporstation
   if (byTaxi) nextMove -> Trans |= TaxiMask;           // Transcendental
   if (bySubway) nextMove -> Trans |= SubwayMask;       // Transitive

   nextMove -> Source = source;
   nextMove -> Node = dest;
   nextMove -> Next = NULL;
   return nextMove;
  }

bool Rules::Occupato (PosType birdsplat)
  {
   int counter;
   PosType windshield;

   for (counter = 1; counter < NumPlayers; counter++)
     {
      windshield = thePlayers [counter] -> GetPosition ();
      if (windshield == birdsplat) return True; // and kill the damned bird!
     }
   return False;
  }

MoveList *Rules::GetLegalMoves (Player &dude)
  {
   Move *nextMove;              // These get added into the list
   MoveList *congaLine;         // Nuke () works on empty list?
   PosType position;            // Where is our frothing fiend?
   int busTokens;               // How many taxi tokens this guy has
   int taxiTokens;              // Duh, I wonder what she's
   int subwayTokens;            // talking about, Norm!
   int counter, city, limit;    // Austin City Limits :-)
   bool blocked;                // Cannot stack detectives in cities

   congaLine = new MoveList;
   position = dude.GetPosition ();
   taxiTokens = dude.NumTokens (Taxi);
   busTokens = dude.NumTokens (Bus);
   subwayTokens = dude.NumTokens (Subway);
   limit = theMap.num_connections (position);
   for (counter = 0; counter < limit; counter++)
     {
      city = theMap.connected_to (position, counter);
      nextMove = CanGo (taxiTokens, busTokens, subwayTokens, position, city);
      blocked = Occupato (city);
      if (blocked)                   // Oh, no. We gotta go, me-oh-my-oo.
  {
   delete nextMove;
   nextMove = NULL;
  }
      if (nextMove) congaLine -> Append (nextMove);
     }
   return congaLine;
  }

void Rules::UpdateSpyPos (PosType locus)
  {
   tachymetabolic = theMap.x (locus);
   endothermy = theMap.y (locus);
  }

PosType Rules::ShowSpy (void)
  {
   PosType serve;

   switch (turn)
     {
      case 2  :
      case 7  :
      case 12 :
      case 17 :
      case 22 : serve = thePlayers [theSpy] -> GetPosition ();
            UpdateSpyPos (serve);
            return serve;     // tennis, anyone?
      default: return 0;
     }
  }

preyass Rules::GameOver (void)
  {
   preyass sleuth;

   /* All right. Here's the deal with the return value of this
      function. First, it's called "prey ass" because it describes
      the game's end. Get it? I tought you would.

      Now, if the spy wins, it returns -1. Why? Because I said so,
      that's why! If the game isn't done yet it returns "notYet"
      (duh). If a detective wins, it returns his number in the
      array (so, if detective 3 wins, it returns 3. It's amazing). */

    if (NoTurnsLeft ()) return spyWins;
    if (DetectivesTrapped ()) return spyWins;
    return (preyass) SpyCaught ();
   }

---