Design_Pattern/Builder.cpp at master · renzocode/Design_Pattern · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
#include<iostream>
usingnamespacestd;
enum Direction { North, South, East, West };
//Mapsite is the common abstract class for all the components of maze
classMapSite
{
public:
virtualvoidEnter() = 0;
};

classRoom : publicMapSite {
public:
Room(int roomNo){};
 MapSite* GetSide(Direction) const;
voidSetSide(Direction, MapSite*){};
virtualvoidEnter(){};

private:
 MapSite* _sides[4];
int _roomNumber;
};

classWall : publicMapSite {
public:

Wall(){};
virtualvoidEnter(){};
};

classDoor : publicMapSite {
public:

Door(Room* = 0, Room* = 0){};
 Room* OtherSideFrom(Room*);
virtualvoidEnter(){};

private:
 Room* _room1;
 Room* _room2;
bool _isOpen;
};


classMaze {
public:
Maze(){};
voidAddRoom(Room*){};
 Room* RoomNo(int) const{}
private:
};

classMazeBuilder {
public:
virtualvoidBuildMaze() { }
virtualvoidBuildRoom(int room) { }
virtualvoidBuildDoor(int roomFrom, int roomTo) { }
virtual Maze* GetMaze() { return0; }
protected:
MazeBuilder(){};
};

classMazeGame {
public:
MazeGame(){};
 Maze* CreateMaze(MazeBuilder& builder);
};

Maze* MazeGame::CreateMaze(MazeBuilder& builder){
 builder.BuildMaze();
 builder.BuildRoom(1);
 builder.BuildRoom(2);
 builder.BuildRoom(3);
 builder.BuildDoor(1,2);

return builder.GetMaze();
}

classStandarMazeBuilder : publicMazeBuilder{
public:
StandarMazeBuilder(){
 _currentMaze = 0;
 }
virtualvoidBuildMaze();
virtualvoidBuildRoom(int);
virtualvoidBuildDoor(int,int);
virtual Maze* GetMaze();
private:
 Direction CommonWall(Room*, Room*){};
 Maze* _currentMaze;
};
voidStandarMazeBuilder::BuildMaze(){
	_currentMaze = newMaze();
}

Maze* StandarMazeBuilder::GetMaze() {
return _currentMaze;
}

voidStandarMazeBuilder::BuildRoom(int n){
if (!_currentMaze->RoomNo(n)){
 Room* room = newRoom(n);
 _currentMaze->AddRoom(room);

 room->SetSide(North, new Wall);
 room->SetSide(South, new Wall);
 room->SetSide(East, new Wall);
 room->SetSide(West, new Wall);
	}
}
voidStandarMazeBuilder::BuildDoor(int n1, int n2){
	Room* r1 = _currentMaze->RoomNo(n1);
	Room* r2 = _currentMaze->RoomNo(n2);
	Door* d = newDoor(r1, r2);

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

intmain(){
	Maze* maze;
	MazeGame game;
	StandarMazeBuilder builder;
	game.CreateMaze(builder);
	maze = builder.GetMaze();
return0;
}