Исходный код

 

Кафедра информационных технологий

main.cpp

 

 

#include <iostream>

#include <time.h>

using namespace std;

 

//------------------------------------------------------------------

// определенным в перечеслении константам присваиваются значения

// типа int начина я 0 (по умолчанию)

enum Direction {North, South, East, West};

 

 

//------------------------------------------------------------------

// общий абстрактный класс для всех компонентов лабиринта

//------------------------------------------------------------------

class Product

{

public:

virtual void Enter () = 0 {};

};

 

 

//------------------------------------------------------------------

// конкретный подкласс класса MapSite.

// определяет ключевые отношения между компонентами лабиринта.

// содержит ссылки на другие объекты MapSite.

// хранит номер комнаты.

// номерами идентифицируются все комнаты в лабиринте.

//------------------------------------------------------------------

class Room: public Product

{

public:

 

Product* GetSide(Direction) const;

virtual void Enter(){};

 

Room(int roomNo)

{

_roomNumber=roomNo;

}

 

void SetSide(Direction D, Product* Q)

{

switch(D)

{

case North:_sides[0] = Q;

case East:_sides[1] = Q;

case South:_sides[2] = Q;

case West:_sides[3] = Q;

}

}

 

private:

Product* _sides[4];

int _roomNumber;

};

 

 

//------------------------------------------------------------------

// стены

//------------------------------------------------------------------

class Wall: public Product

{

public:

Wall() {};

virtual void Enter() {};

};

 

 

//------------------------------------------------------------------

// двери

//------------------------------------------------------------------

class Door: public Product

{

public:

Door(Room* h1, Room* h2)

{

_room1=h1;

_room2=h2;

}

virtual void Enter(){};

Room* OtherSideFrom(Room*);

private:

Room* _room1;

Room* _room2;

bool _isOpen;

};

 

 

//------------------------------------------------------------------

// представление набора комнат.

// операция RoomNo для нахождения комнаты по ее номер.

//------------------------------------------------------------------

class Maze

{

public:

 

Maze(int count)

{

num=0;

Rooms=new Room*[count];

}

 

void AddRoom(Room* N)

{

Rooms[num]=N;

num++;

}

 

Room* RoomNo(int u)

{

return Rooms[u];

}

 

int GetNum()

{

return num;

}

 

 

private:

int num;

Room ** Rooms;

};

 

 

//------------------------------------------------------------------

// определяет интерфейс для построения лабиринтов

//------------------------------------------------------------------

class MazeBuilder

{

public:

virtual void BuildMaze(int count) { }

virtual void BuildRoom(int room) { }

virtual void BuildDoor(int roomFrom, int roomTo) { }

virtual Maze* GetMaze() { return 0; } // возвращает лабиринт клиенту

protected:

MazeBuilder() {};

};

 

 

//------------------------------------------------------------------

// подсчитывает число компонентов разного вида, которые могли бы быть созданы

//------------------------------------------------------------------

class CountingMazeBuilder: public MazeBuilder

{

public:

 

// инициализирует счетчики

CountingMazeBuilder ()

{

_rooms = _doors = 0;

}

 

void BuildRoom(int) {_rooms++;}

void BuildDoor(int,int) {_doors++;}

void GetCounts (int * rooms, int * doors)

{

(*rooms) =_rooms;

(*doors) =_doors;

}

private:

int _doors;

int _rooms;

};

 

//------------------------------------------------------------------

// Creator

//------------------------------------------------------------------

class Creator {

public:

virtual Room* MakeRoom(int n) {return 0;}

virtual Wall* MakeWall() {return 0;}

virtual Door* MakeDoor(Room* r1, Room* r2) {return 0;}

virtual Product* factoryMethod(){return 0;};

};

 

class RoomCreator: public Creator {

public:

 

Room* MakeRoom(int n) {

return new Room(n);

}

 

Product* factoryMethod(int n) {

return new Room(n);

}

};

 

class WallCreator: public Creator {

public:

Wall* MakeWall() {

return new Wall();

}

 

Product* factoryMethod() {

return new Wall();

}

};

 

class DoorCreator: public Creator {

public:

Door* MakeDoor(Room* r1, Room* r2) {

return new Door(r1,r2);

}

 

Product* factoryMethod(Room* r1, Room* r2) {

return new Door(r1,r2);

}

};

 

 

//------------------------------------------------------------------

// содержит реализацию построения простых лабиринтов

//------------------------------------------------------------------

class StandardMazeBuilder: public MazeBuilder

{

public:

 

// создает комнату и строит вокруг нее стены

void BuildRoom (int n)

{

if (!_currentMaze->RoomNo(n))

{

 

Creator* room_create = new RoomCreator();

Creator* wall_create = new WallCreator();

 

Room* room = room_create->MakeRoom(n);

 

_currentMaze->AddRoom(room);

room->SetSide(North, wall_create->MakeWall());

room->SetSide(South, wall_create->MakeWall());

room->SetSide(East, wall_create->MakeWall());

room->SetSide(West, wall_create->MakeWall());

}

}

 

// определяет направление общей для двух комнат стены.

Direction CommonWall(Room* j1, Room* j2)

{

return East;

}

 

// строит дверь между 2 комнатами

void BuildDoor (int n1, int n2)

{

Room* r1 = _currentMaze->RoomNo (n1);

Room* r2 = _currentMaze->RoomNo (n2);

 

Creator* door_create = new DoorCreator();

Door* d = door_create->MakeDoor(r1, r2);

 

r1->SetSide(CommonWall(r1,r2), d);

r2->SetSide(CommonWall(r2,r1), d);

}

 

// инстанцирует объект класса Maze

void BuildMaze (int count)

{

_currentMaze = new Maze(count);

}

 

// возвращает обьект класса Maze клиенту

Maze* GetMaze ()

{

return _currentMaze;

}

 

// просто инициализирует _currentMaze

StandardMazeBuilder ()

{

_currentMaze = 0;

}

 

private:

Maze* _currentMaze;

};

 

//------------------------------------------------------------------

// создает лабиринт

//------------------------------------------------------------------

class MazeGame

{

private:

Maze * Maze1;

int Player;

 

public:

CountingMazeBuilder * schet;

MazeGame()

{

schet=new CountingMazeBuilder();

}

 

void CreateMaze (MazeBuilder builder, int countR)

{

builder.BuildMaze(countR);

for(int i=0;i<countR;i++)

{

builder.BuildRoom(i);

(*schet).BuildRoom(1);

}

 

for(int i=0;i<(countR-1);i++)

{

builder.BuildDoor(i,i+1);

(*schet).BuildDoor(1,1);

}

 

Maze1=builder.GetMaze();

}

 

int GetCount() {return Maze1->GetNum();}

int GetPlayer() {return Player;}

};

 

 

//------------------------------------------------------------------

// main

//------------------------------------------------------------------

int main ()

{

setlocale(LC_ALL, ".1251");

 

MazeGame * y;

StandardMazeBuilder * k;

CountingMazeBuilder * k2;

int num2;

 

cout << "Симаков Константин 3АУ-39Д.\n";

for (int i=0; i < 27; i++)

cout << "-";

cout << "\n\n" << "Введите количество комнат: ";

 

cin >> num2;

cout << "\n";

 

y=new MazeGame();

k=new StandardMazeBuilder();

 

y->CreateMaze(*k,num2);

int y0=0,y02=0;

y->schet->GetCounts(&y0,&y02);

 

cout << "Комнат: " << y0 << ".\n"

<< "Дверей: " << y02 << ".\n\n";

 

system ("pause");

return 0;

}

//------------------------------------------------------------------