---

players.c

Go to the documentation of this file.

/**********************************************************************
*    FILE:     players.c
*    AUTHOR:   EHB
*    DATE:     29 April 1993
*    PURPOSE:
*      Defines player functions.
***********************************************************************/

#include "map.h"
#include "players.h"
#include "rules.h"
#include "random.h"
#include "ui.h"
#include "msgwin.h"
#include <assert.h>
#include <math.h>
#include <string.h>
#include <stdio.h>

bool Player::IsSpy (void) { return False; }
bool Spy::IsSpy (void) { return True; }

Player::Player (char* name, int color)
  {
   strncpy (Name, name, NameSize);
   Color = color;
   Pos = theRules.RandomPos ();
  }

Player::Player (char* name, int color, PosType pos)
  {
   strncpy (Name, name, NameSize);
   Color = color;
   Pos = pos;
  }

Detective::Detective (void)
  {
   for (int i=0; i < NTokenTypes; i++)
  Tokens [i] = theRules.StartingTokens ((TokenType) i);
  }

Move Detective::TakeTurn (void)
  {
   UI.BeginTurn (*this);
   Move m = ChooseMove ();
   if (m != NullMove)
     {
      if (m.Trans & TaxiMask)              // update tokens
  Tokens[Taxi]--;
      else if (m.Trans & BusMask)
  Tokens[Bus]--;
      else if (m.Trans & SubwayMask)
  Tokens[Subway]--;
      UI.EndTurn (*this, m);
      Pos = m.Node;
     }
   return m;
  }

Move Spy::TakeTurn (void)
  {
   Move squamosal; // Squamosal = "crest" of a ceratopsian dinosaur
   Move Rostrum;   // Rostrum = bony "beak" of a ceratopsian dinosaur

   UI.BeginTurn (*this);
   squamosal = ChooseMove ();
   if (squamosal != NullMove)
     {
      Move* theMove = new Move;
      *theMove = squamosal;
      History.Append (theMove);
      Pos = theMove -> Node;               // update Pos
      if (theRules.ShowSpy ())
  UI.RevealSpy (*this, squamosal);
      else
  UI.SpyTurn (squamosal, theRules.CurrentTurn());
     }
   return squamosal;
  }

Move Human::ChooseMove (void)
  {
   MoveList *ml = theRules.GetLegalMoves (*this);
   Move m;
   if (ml->Length() == 0)
     m = UI.NoLegalMoves (*this);
   else
     m = UI.GetPlayerMove (*this, *ml);
   delete ml;
   return m;
  }

byte ComputerDetective::NumNodeTypes (int node)
  {
   byte me = 0;

   me += theMap.bus (node);
   me += theMap.taxi (node);
   me += theMap.subway (node);
   return me;
  }

bool ComputerDetective::CanLeave (Move *duh)
  {
   bool taxi, bus, subway, ok = False;
   int vertex;

   vertex = duh -> Node;
   if (NumNodeTypes (vertex) > 1) return True;

   bus = theMap.bus (vertex);
   taxi = theMap.taxi (vertex);
   subway = theMap.subway (vertex);

   if (bus)
     {
      bus &= (bool) (NumTokens (Bus) - 1);    // Just one token left...
      if (!bus) return False;
     }

   if (taxi)
     {
      bus &= (bool) (NumTokens (Taxi) - 1);   // Just one token left...
      if (!bus) return False;
     }

   if (subway)
     {
      bus &= (bool) (NumTokens (Subway) - 1); // Just one token left...
      if (!bus) return False;
     }

   return True;         // He has more than one token
  }

Move *ComputerDetective::FindNearest (int x, int y, MoveList *moves)
  {
   Move *best, *temp;
   int deltaX, deltaY;
   double dist, nearest;

   nearest = MAXINT;
   moves -> Reset ();
   best = moves -> GetCurrent ();
   while (moves -> Next ())
     {
      temp = moves -> GetCurrent ();
      deltaX = x - theMap.x (temp -> Node);
      deltaY = y - theMap.y (temp -> Node);
      dist = deltaX * deltaX;
      dist += deltaY * deltaY;
      dist = sqrt (dist);
      if ((dist < nearest) && CanLeave (temp))  // Will he get stuck?
  {
   best = temp;
   nearest = dist;
  }
     }
   return best;
  }

Move ComputerDetective::ChooseMove (void)
  {
   MoveList *ml;
   Move *shalowitz, theMove;
   int ira, barry;                         // If it was us, could you eat?

   ml = theRules.GetLegalMoves (*this);
   ira = ml -> Length ();
   if (ira == 0)                           // Dooh!
     theMove = UI.NoLegalMoves (*this);
   else                                    // Our AI routine
     {
      ira = theRules.SpyLastX ();
      barry = theRules.SpyLastY ();
      shalowitz = FindNearest (ira, barry, ml);

      theMove = *shalowitz;                // Rum raisin! Woof!
      theMove.Next = NULL;
     }
   delete ml;                              // Let's try Smalltalk
   return theMove;
  }

Move *ComputerSpy::FindFarthest (int x, int y, MoveList *moves)
  {
   Move *best, *temp;
   int deltaX, deltaY;
   double dist, farthest = 0;

   moves -> Reset ();
   best = moves -> GetCurrent ();
   while (moves -> Next ())
     {
      temp = moves -> GetCurrent ();
      deltaX = x - theMap.x (temp -> Node);
      deltaY = y - theMap.y (temp -> Node);
      dist = deltaX * deltaX;
      dist += deltaY * deltaY;
      dist = sqrt (dist);
      if (dist > farthest)
  {
   best = temp;
   farthest = dist;
  }
     }
   return best;
  }

Move ComputerSpy::ChooseMove (void)
  {
   MoveList *ml;
   Move *shalowitz, theMove;
   int ira, barry;                         // If it was us, could you eat?

   ml = theRules.GetLegalMoves (*this);
   ira = ml -> Length ();
   if (ira == 0)                           // Dooh!
     theMove = UI.NoLegalMoves (*this);
   else                                    // Our AI routine
     {
      ira = theRules.SpyLastX ();
      barry = theRules.SpyLastY ();
      shalowitz = FindFarthest (ira, barry, ml);

      theMove = *shalowitz;                // Rum raisin! Woof!
      theMove.Next = NULL;
     }
   delete ml;                              // Let's try Smalltalk
   return theMove;
  }

---