shixi1.01.cpp

本程序模拟一栋大楼内10部电梯的运行情况及人员流动。开发平台为TC30

//# ifndef _ELEVSIM_H
//# define _ELEVSIM_H
# include <time.h>
# include <dos.h>
# include <stdlib.h>
//# include "simulation.h"


enum bool {false,true};

class simulation
{
  long timeSimulate;
  long timeRemaining;
  public:
    simulation();
    bool continues (void);
    void SetTime (long secs);
    long getTime(void);
    void reduceTime( long secs);
    void perform (void);
    void display(void);
    void results(void);
};

enum direction { DOWN=-1,NODIRECTION=0,UP=1 };

const int ESCKEY=27;
const int MAXELEVS=10;
const int MAXFLOORS=10;
const int MAXPERSONS=500;
const int ELEVWAIT=15;
const int CAPACITY=24;
const int TRAVELTIME=5;
time_t starttime,endtime;
int WantsToEnter(void) { return rand()<200;}
int EnterDest(void) { return 1+(rand()%(MAXFLOORS-1));}
int Maxwait(void) { return 180+(rand()%180);}
int Business(void) { return 400+(rand()%6200);}
bool leaving(void) { return rand()<22000?false:true;}
 int totalPeople=0;
 int inBuilding=0;
 int leftBuilding=0;
 int avgwait=0;
 int avgRide=0;
 int tookstair=0;
 int totalTime=0;

//# endif
//# ifndef _SIMULATION_H
//# define _SIMULATION_H


//# endif
# include <iostream.h>
//# include "simulation.h"
# include <conio.h>
# include "draw_win.h"

simulation::simulation()
{
  timeSimulate=36000;
  timeRemaining=timeSimulate;
}

bool simulation::continues(void)
{
  if (timeRemaining>0)
    return true;
  else
    return false;
}

void simulation::SetTime(long secs)
{
  timeSimulate=secs;
  timeRemaining=timeSimulate;
}

long simulation::getTime(void) {return timeRemaining;}

void simulation::reduceTime(long secs)
{
  if (secs>timeRemaining)
    timeRemaining=0;
  else
    timeRemaining-=secs;
}

void simulation::perform(void)
{
  cout<<"Simulation! Press <Space> to contimue";
  while (getch()==' ')  reduceTime(600);
}

void simulation::display(void)
{
  cout<<endl<<"Timeremaining";
  cout<<timeRemaining<<"secs";
}

void simulation::results(void)
{
  char buffer[4096];
  char main[4000];
  gettext(1,1,80,25,buffer);
  clrscr();
  Draw_window (14,6,60,19);
  gotoxy(15,7);
  textcolor(RED);
  cprintf("---------&**& Simulation results &**&--------");
  gotoxy(15,9);
  textcolor(YELLOW);
  cprintf("Time at start:");
  cout<<ctime(&starttime);
  gotoxy(15,10);
  endtime=time(NULL);
  cprintf("Time at end:");
  cout<<ctime(&endtime);
  gotoxy(15,11);
  cprintf("Sun time:");
  cout<<difftime(endtime,starttime);
  textcolor(RED);
  gotoxy(17,13);
  cprintf("totalPeople:");
  cout<<totalPeople;
  gotoxy(42,13);
  cprintf("inBuilding:");
  cout<<inBuilding;
  gotoxy(17,14);
  cprintf("leftBuilding:");
  cout<<leftBuilding;
  gotoxy(42,14);
  cprintf("avgWait:");
  cout<<avgwait;
  gotoxy(17,15);
  cprintf("avgRide:");
  cout<<avgRide;
  gotoxy(42,15);
  cprintf("tookstair:");
  cout<<tookstair;
  gotoxy(17,16);
  cprintf("MAXFLOORS:");
  cout<<MAXFLOORS;
  gotoxy(42,16);
  cprintf("MAXEFEVS:");
  cout<<MAXELEVS;
  gotoxy(15,17);
  textcolor(12);
  cprintf("See last picture press <S>");
  gotoxy(40,18);
  textcolor(CYAN+BLINK);
  cprintf("press <Q> to quit...");
  while (!kbhit())
  {
    if (getch()=='s')
    {
      gettext(14,6,60,19,main);
      clrscr();
      puttext(1,1,80,25,buffer);
      gotoxy(1,25);
      textcolor(RED+BLINK);
      cprintf("Press Any Key To Back...");
      getch();
      clrscr();
      puttext(14,6,60,19,main);
    }
    if (getch()=='q')  return;
  }
  textcolor(WHITE);
}
//# ifndef _PERSON_H
//# define _PERSON_H

//# include "elevsim.h"
//# include "building.h"


class person
{
  int floorNowOn;
  int destination;
  int maxWaitTime;
  bool WaitingForElev;
  bool takingStairs;
  int elevNowIn;
  public:
    person();
    void action(void);
    bool upWaiting (int floorNumber);
    bool dnWaiting (int floorNumber);
    bool loadIfWaiting (int elevNumber,int floorNumber,int &pdest);
    bool loadIfGoing (int elevNumber,int floorNumber,direction dir,int &pdest);
    bool discharge(int elevNumber,int floorNumber);
};

class perSet
{
  person pa[MAXPERSONS];
  public:
    void action(void);
    void numWaiting (int floorNumber,int &nup,int &ndn);
    bool loadAny (int elevNumber,int floorNumber,int &pdest);
    bool loadOne(int elevNumber,int floorNumber,direction dir,int &pdest);
    int discharge(int elevNumber,int floorNumber);
};

//# endif
# include <iostream.h>
# include <stdlib.h>
# include <math.h>
//# include "person.h"

person::person()
{
  floorNowOn=-1;
  WaitingForElev=false;
  destination=-1;
  maxWaitTime=0;
  takingStairs=false;
  elevNowIn=-1;
}

void person::action(void)
{
  if (floorNowOn<0)
  {
    if (WantsToEnter())
    {
      destination=EnterDest();
      floorNowOn=0;
      maxWaitTime=Maxwait();
      WaitingForElev=true;
      takingStairs=false;
      elevNowIn=-1;
      totalPeople++;
      inBuilding++;
    }
  }
  else
  {
    if (WaitingForElev)
    {
      if ((maxWaitTime--)<=0)
      {
	WaitingForElev=false;
	takingStairs=true;
	maxWaitTime=30*abs(destination-floorNowOn);
	tookstair++;
      }
    }
    else
    {
      if (takingStairs)
      {
	if (maxWaitTime--<=0)
	{
	  floorNowOn=destination;
	  takingStairs=false;
	  maxWaitTime=Business();
	}
      }
      else
	if (elevNowIn<0)
	{
	  if (maxWaitTime--<=0)
	  {
	    if (leaving())
	      destination=0;
	    else
	      destination=EnterDest();
	    if (destination==floorNowOn)  destination=0;
	    maxWaitTime=Maxwait();
	    WaitingForElev=true;
	  }
	}
     }
  }
  if ((floorNowOn==0)&&(destination==0))
  {
    floorNowOn=-1;
    leftBuilding++;
    inBuilding--;
  }
}

bool person::upWaiting(int floorNumber)
{
  return WaitingForElev&&(floorNowOn==floorNumber)&&(destination>floorNowOn);
}

bool person::dnWaiting(int floorNumber)
{
  return WaitingForElev&&(floorNowOn==floorNumber)&&(destination<floorNowOn);
}

bool person::loadIfWaiting(int elevNumber,int floorNumber,int &pdest)
{
  if (WaitingForElev&&(floorNowOn==floorNumber))
  {
    WaitingForElev=false;
    elevNowIn=elevNumber;
    pdest=destination;
    return true;
  }
  return false;
}

bool person::loadIfGoing(int elevNumber,int floorNumber,direction dir,int &pdest)
{
  direction pdir;
  if (destination>floorNumber)
    pdir=UP;
  else
    pdir=DOWN;
  if (WaitingForElev&&(floorNowOn==floorNumber)&&(dir==pdir))
  {
    WaitingForElev=false;
    elevNowIn=elevNumber;
    pdest=destination;
    return true;
  }
  return false;
}

bool person::discharge(int elevNumber,int floorNumber)
{
  if ((elevNowIn==elevNumber)&&(destination==floorNumber))
  {
    elevNowIn=-1;
    floorNowOn=destination;
    if (floorNowOn!=0)  maxWaitTime=Business();
    return true;
  }
  else
  return false;
}

void perSet::action()
{
  for (int i=0;i<MAXPERSONS;i++)
    pa[i].action();
}
void perSet::numWaiting(int floorNumber,int &nup,int &ndn)
{
  nup=ndn=0;
  for (int i=0;i<MAXPERSONS;i++)
  {
    nup+=pa[i].upWaiting(floorNumber);
    ndn+=pa[i].dnWaiting(floorNumber);
  }
}

bool perSet::loadAny(int elevNumber,int floorNumber,int &pdest)
{
  for (int i=0;i<MAXPERSONS;i++)
    if (pa[i].loadIfWaiting(elevNumber,floorNumber,pdest))  return true;
  return false;
}

bool perSet::loadOne(int elevNumber,int floorNumber,direction dir,int &pdest)
{
  for (int i=0;i<MAXPERSONS;i++)
    if (pa[i].loadIfGoing(elevNumber,floorNumber,dir,pdest))  return true;
  return false;
}

int perSet::discharge(int elevNumber,int floorNumber)
{
  int n=0;
  for (int i=0;i<MAXPERSONS;i++)
    n+=pa[i].discharge(elevNumber,floorNumber);
  return n;
}
//# ifndef _FLOOR_H
//# define _FLOOR_H

//# include "person.h"

class floors
{
  int floorNumber;
  bool up,down;
  int np;
  public:
    floors();
    void SetFloorNumber(int n){ floorNumber=n;}
    bool downButton(void) { return down;}
    bool upButton(void) {return up;}
    void reSetUpButton(void) {up=false;}
    void reSetDownButton(void) {down=false;}
    int getNumWaiting(void) {return np;}
    void showFloor(perSet&persons);
    void SetUpButton(void);
    void SetDownButton(void);
};

class floorSet
{
  floors fa[MAXFLOORS];
  public:
    floorSet();
    void showFloors(perSet &persons);
    void reSetButton(direction dir,int floorNumber);
    bool signalUp(int floorNumber);
    bool signalDown(int floorNumber);
    bool signalSameDir(direction dir,int floorNumber);
    int avgWaiting(void);
    int getnp(int floorNumber){ return fa[floorNumber].getNumWaiting();}
};

//# endif
//# include "floor.h"
//# include <iostream.h>
//# include <conio.h>
# include <iomanip.h>

floors::floors()
{
  up=down=false;
  np=0;
}

void floors::showFloor(perSet &persons)
{
  char uc='-',dc='-';
  int nup,ndn;
  persons.numWaiting(floorNumber,nup,ndn);
  np=nup+ndn;
  if (nup>0)  SetUpButton();
  if (ndn>0)  SetDownButton();
  if (up)  uc='U';
  if (down) dc='D';
  gotoxy(1,21-floorNumber*2);
  textcolor(12);
  switch (floorNumber)
  {
    case 0:   cprintf(" 1"); break;
    case 1:   cprintf(" 2"); break;
    case 2:   cprintf(" 3"); break;
    case 3:   cprintf(" 4"); break;
    case 4:   cprintf(" 5"); break;
    case 5:   cprintf(" 6"); break;
    case 6:   cprintf(" 7"); break;
    case 7:   cprintf(" 8"); break;
    case 8:   cprintf(" 9"); break;
    case 9:   cprintf("10"); break;
  }
  cout<<" ";
  if (uc=='U'&&dc=='-')
  {
    textcolor(RED);
    cprintf("U");
    textcolor(GREEN);
    cprintf("-");
  }
  else
  if (dc=='D'&&uc=='-')