public void Test()
{
// The client code creates a builder object, passes it to the
// director and then initiates the construction process. The end
// result is retrieved from the builder object.
var director = new BuildingHouseDirector();
var builder = new HouseBuilder();
director.Builder = builder;
_testOutputHelper.WriteLine("Standard basic product:");
director.BuildSimpleHouse();
_testOutputHelper.WriteLine(builder.BuildHouse().ListParts());
_testOutputHelper.WriteLine("");
_testOutputHelper.WriteLine("Standard full featured product:");
director.BuildFullHouse();
_testOutputHelper.WriteLine(builder.BuildHouse().ListParts());
_testOutputHelper.WriteLine("");
// Remember, the Builder pattern can be used without a Director
// class.
_testOutputHelper.WriteLine("Custom product:");
builder.BuildWalls();
builder.InstallDoor();
_testOutputHelper.WriteLine(builder.BuildHouse().ListParts());
}
public void Resolve(IRequest request)
{
Console.WriteLine("Builder: House Builder Problem");
IHouseBuilder houseBuilder = new HouseBuilder();
IEngineer engineer = new Engineer(houseBuilder);
IHouse house = engineer.BuildHouse();
Console.WriteLine("\nBedrooms:");
foreach (IBedRoom bedRoom in house.BedRooms)
{
Console.WriteLine(bedRoom.Name);
}
Console.WriteLine("\nBathrooms:");
foreach (IBathRoom bathRoom in house.BathRooms)
{
Console.WriteLine(bathRoom.Name);
}
Console.WriteLine("\nGarage:");
Console.WriteLine(house.Garage.Name);
Console.WriteLine("\nKitchen:");
Console.WriteLine(house.Kitchen.Name);
}
public override bool Place(Point origin, StructureMap structures)
{
if (!WorldGen.InWorld(origin.X, origin.Y, 10))
{
return(false);
}
int num = 25;
for (int index1 = origin.X - num; index1 <= origin.X + num; ++index1)
{
for (int index2 = origin.Y - num; index2 <= origin.Y + num; ++index2)
{
if (Main.tile[index1, index2].wire() || TileID.Sets.BasicChest[(int)Main.tile[index1, index2].type])
{
return(false);
}
}
}
HouseBuilder builder = HouseUtils.CreateBuilder(origin, structures);
if (!builder.IsValid)
{
return(false);
}
this.ApplyConfigurationToBuilder(builder);
builder.Place(this._builderContext, structures);
return(true);
}
public override bool Place(Point origin, StructureMap structures)
{
if (!WorldGen.InWorld(origin.X, origin.Y, 10))
{
return(false);
}
int num = 25;
for (int i = origin.X - num; i <= origin.X + num; i++)
{
for (int j = origin.Y - num; j <= origin.Y + num; j++)
{
if (Main.tile[i, j].wire())
{
return(false);
}
if (TileID.Sets.BasicChest[Main.tile[i, j].type])
{
return(false);
}
}
}
HouseBuilder houseBuilder = HouseUtils.CreateBuilder(origin, structures);
if (!houseBuilder.IsValid)
{
return(false);
}
ApplyConfigurationToBuilder(houseBuilder);
houseBuilder.Place(_builderContext, structures);
return(true);
}
private new void ApplyConfigurationToBuilder(HouseBuilder builder)
{
switch (builder.Type)
{
case HouseType.Wood:
builder.ChestChance = GoldChestChance;
break;
case HouseType.Ice:
builder.ChestChance = IceChestChance;
break;
case HouseType.Desert:
builder.ChestChance = DesertChestChance;
break;
case HouseType.Jungle:
builder.ChestChance = JungleChestChance;
break;
case HouseType.Mushroom:
builder.ChestChance = MushroomChestChance;
break;
case HouseType.Granite:
builder.ChestChance = GraniteChestChance;
break;
case HouseType.Marble:
builder.ChestChance = MarbleChestChance;
break;
}
}
public void Execute(UIApplication app)
{
UIDocument uidoc = app.ActiveUIDocument;
Document doc = uidoc.Document;
string baseLevel = Properties.Settings.Default.BaseLevelName;
string topLevel = Properties.Settings.Default.TopLevelName;
float scale = Properties.Settings.Default.Scale;
double overhang = UnitUtils.ConvertToInternalUnits(Properties.Settings.Default.Overhang, UnitTypeId.Meters);;
XYZ slopeVector = BuildRoofForm.SlopeVector;
RoofDesign roofDesign = BuildRoofForm.RoofDesign;
double slope = RoofSelector.GetSlopeByType(roofDesign);
HouseBuilder elementPlacer = new HouseBuilder(doc, baseLevel, topLevel, scale);
try
{
using (Transaction transaction = new Transaction(doc, "Roof Command"))
{
transaction.Start();
elementPlacer.CreateRoof(overhang, slope, slopeVector, roofDesign);
transaction.Commit();
}
}
catch { }
}
static void Main(string[] args)
{
var container = new UnityContainer();
container.RegisterType <IHouse, WoodenHouse>();
HouseBuilder houseBuilder = new HouseBuilder(container.Resolve <IHouse>());
houseBuilder.Build();
List <Person> people = new List <Person>()
{
new Person("Test1", 10), new Person("Test2", 20)
};
people.Where(p => p.Age >= 8)
.ToList()
.ForEach(p => Console.WriteLine($"{p.ToString()}"));
int[] mas = { 2, 5, 6, 6, 9 };
mas.Reverse().ToList().ForEach(p => Console.WriteLine(p));
Console.WriteLine(mas.Average());
Console.WriteLine(lol);
Console.ReadKey();
}
public void Setup()
{
_mockWindow = new Window();
_mockRoof = new Roof();
_mockFloor = new Floor();
_houseBuilder = new HouseBuilder();
}
public override bool Place(Point origin, StructureMap structures)
{
HouseBuilder builder = HouseUtils.CreateBuilder(origin, structures);
ApplyConfigurationToBuilder(builder);
builder.Place(_builderContext, structures);
return(true);
}
private static Structure CreateHouse()
{
StructureBuilder Housebuilder = new HouseBuilder();
Director dir = new Director();
Structure House = dir.GenerateStructure(Housebuilder);
Console.WriteLine("A house was created.");
Console.WriteLine();
return(House);
}
public void BuilderTest()
{
Director director = new Director();
CarBuilder carBuilder = new CarBuilder();
HouseBuilder houseBuilder = new HouseBuilder();
director.Construct(carBuilder);
director.Construct(houseBuilder);
Assert.AreEqual(typeof(Car), carBuilder.Car.GetType());
Assert.AreEqual(typeof(House), houseBuilder.House.GetType());
}
public void Run()
{
// House house = new House(){Doors = 1, HasSwimmingPool = true};
// var builder = new HouseBuilder();
var house = HouseBuilder.GetBuilder()
.Rooms(2)
.Doors(1)
.Windows(4)
.HasPool()
.Build();
var bungalow = HouseBuilder.GetBuilder()
.CreateBungalow()
.HasPool()
.Build();
}
public House(HouseBuilder flatBuilder)
{
Id = flatBuilder.id;
SerialNumber = flatBuilder.serialNumber;
Price = flatBuilder.price;
Area = flatBuilder.area;
Description = flatBuilder.description;
Street = flatBuilder.street;
Place = flatBuilder.place;
District = flatBuilder.district;
Image = flatBuilder.image;
ImageThumbnail = flatBuilder.imageThumbnail;
Rooms = flatBuilder.rooms;
Floor = flatBuilder.floor;
YearOfBuilding = flatBuilder.yearOfBuilding;
PlotArea = flatBuilder.plotArea;
}
public House ConstructHouse(HouseBuilder builder)
{
House house = builder.CreateHouse();
Console.WriteLine(house.GetRepresentation());
house.SetFloor(builder.CreateFloor());
Console.WriteLine(house.GetFloor().GetRepresentation());
house.SetWalls(builder.CreateWalls());
Console.WriteLine(house.GetWalls().GetRepresentation());
house.SetRoof(builder.CreateRoof());
Console.WriteLine(house.GetRoof().GetRepresentation());
return(house);
}
public static void Main(string[] args)
{
House FluentHouse = new HouseBuilder()
.Floors(3)
.Bedrooms(4)
.HasKitchen()
.HasLivingRoom()
.Roof("Metal")
.Build();
Console.WriteLine("House Build with the follwing Requirement " +
"\nNumber of Floor: " + FluentHouse.Floors +
"\nNumber of BedRoom: " + FluentHouse.Bedrooms +
"\nHas Kitchen: " + FluentHouse.Kitchen +
"\nHasLivingRoom: " + FluentHouse.LivingRoom +
"\nRoofType: " + FluentHouse.Roof);
Console.ReadLine();
}
/**
* Map List:
* - Street
* - Junkyard
* - Houses x3
*/
private SceneBuilder SceneFactory(
int house_index, string type, Transform transform)
{
if (type == "house")
{
HouseBuilder builder = new HouseBuilder();
//builder.floor_tiles = materials.house_floors;
//builder.wall_tiles = materials.house_walls;
builder.houseComponents = houseComponents;
builder.columns = 20;
builder.rows = 20;
builder.sprite_list = rawHouseSprites[0]; // hardcoded for now cus we only have 1 list of sprites
builder.sprite_mapper = sprite_mapper;
builder.board_holder_transform = transform;
builder.door1 = materials.house_door1;
builder.door2 = materials.house_door2;
builder.gm = this;
return(builder);
}
else if (type == "street")
{
StreetBuilder builder = new StreetBuilder();
builder.floor_tiles = materials.street_floors;
builder.wall_tiles = materials.street_walls;
builder.door_tiles = materials.street_doors;
builder.columns = 30;
builder.rows = 80;
builder.board_holder_transform = transform;
builder.door1 = materials.house_door1;
builder.door2 = materials.house_door2;
builder.gm = this;
return(builder);
}
else
{
return(null);
}
}
private void BuildWorld()
{
// Build Houses
houses = new List <HouseBuilder>();
board_holder_transform = new GameObject("Board").transform;
for (int i = 0; i < house_count; i++)
{
HouseBuilder hg = SceneFactory(1, "house", board_holder_transform) as HouseBuilder;
hg.serealize();
houses.Add(hg);
}
// TEMP - JUST GET DOOR
// materials.street_doors.GetComponent<SpriteRenderer>().sprite = houses[0].sprite_list[sprite_mapper["door"][0]];
//houses[0].materialize();
//houses[0].deMaterialize();
//Build Street
street = SceneFactory(1, "street", board_holder_transform) as StreetBuilder;
street.serealize();
currentScene = street;
currentScene.materialize();
//street_builder.materialize();
// player.transform.position = new Vector3(15, 0, -1f);
// Build Street
// StreetBuilder street_builder = new StreetBuilder();
// street_builder.board_holder_transform = board_holder_transform;
// street_builder.floor_tiles = materials.street_floors;
// street_builder.wall_tiles = materials.street_walls;
// street_builder.seralizeStreet();
// street_builder.materalizeStreet();
// player.transform.position = new Vector3(100,0,-1f);
}
public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
{
try
{
UIDocument uidoc = commandData.Application.ActiveUIDocument;
string baseLevel = Properties.Settings.Default.BaseLevelName;
string topLevel = Properties.Settings.Default.TopLevelName;
float scale = Properties.Settings.Default.Scale;
HouseBuilder elementPlacer = new HouseBuilder(uidoc.Document, baseLevel, topLevel, scale);
using (Transaction transaction = new Transaction(commandData.Application.ActiveUIDocument.Document, "Dimensioning"))
{
transaction.Start();
elementPlacer.DimensioningBuilding(2, false);
elementPlacer.DimensioningBuilding(4, true);
transaction.Commit();
}
return(Result.Succeeded);
}
catch (Exception e)
{
message = e.Message;
return(Result.Failed);
}
}
public void Execute(UIApplication app)
{
UIDocument uidoc = app.ActiveUIDocument;
Document doc = uidoc.Document;
float scale = 0;
double overhang = 0;
string levelName = "", topLevelName = "";
try
{
scale = Properties.Settings.Default.Scale;
overhang = UnitUtils.ConvertToInternalUnits(Properties.Settings.Default.Overhang, UnitTypeId.Meters);
levelName = Properties.Settings.Default.BaseLevelName;
topLevelName = Properties.Settings.Default.TopLevelName;
}
catch (Exception e)
{
MessageBox.Show(e.Message);
PlaceElementsForm.CloseForm();
}
string path = PlaceElementsForm.filePath;
XYZ roofVector = PlaceElementsForm.roofSelector.SlopeVector;
RoofDesign roofDesign = PlaceElementsForm.roofSelector.RoofStyle;
double slope = RoofSelector.GetSlopeByType(roofDesign);
HouseBuilder builder = new HouseBuilder(doc, levelName, topLevelName, scale);
string errorMessage = "";
using (Transaction transaction = new Transaction(doc, "Contruir JSON"))
{
transaction.Start();
try
{
builder.BuildJSON(path);
}
catch (Exception e)
{
errorMessage += $"\nErro ao construir elementos do JSON: \"{e.Message}\"";
}
try
{
builder.CreateFloor(Properties.Settings.Default.FloorName);
}
catch (Exception e)
{
errorMessage += $"\nErro ao construir piso: \"{e.Message}\"";
}
try
{
builder.CreateCeiling(Properties.Settings.Default.CeilingName);
}
catch (Exception e)
{
errorMessage += $"\nErro ao construir laje: \"{e.Message}\"";
}
try
{
builder.ClassifyRooms();
}
catch (Exception e)
{
errorMessage += $"\nErro ao classificar ambientes: \"{e.Message}\"";
}
transaction.Commit();
}
using (Transaction transaction = new Transaction(doc, "Contruir Telhado"))
{
transaction.Start();
try
{
builder.CreateRoof(overhang, slope, roofVector, roofDesign);
}
catch (Exception e)
{
errorMessage += $"\nErro ao construir telhado: \"{e.Message}\"";
}
transaction.Commit();
}
if (errorMessage.Length > 1)
{
MessageBox.Show(errorMessage, "Erro!", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
PlaceElementsForm.CloseForm();
}
public HouseBuildDirector(HouseBuilder builder)
{
houseBuilder = builder;
}
public SiteManager(HouseBuilder builder)
{
_builder = builder;
}
public BOB(HouseBuilder housebuilder)
{
this.housebuilder = housebuilder;
}
public Director(HouseBuilder builder)
{
ChangeBuilder(builder);
}
public void ChangeBuilder(HouseBuilder builder)
{
this.builder = builder;
}
public CivilEngineer(HouseBuilder houseBuilder)
{
this.houseBuilder = houseBuilder;
}
public HouseDirector(HouseBuilder builder)
{
this.builder = builder;
}
private void openButton_Click(object sender, EventArgs e)
{
fileTextBox.Text = HouseBuilder.SelectFile();
filePath = fileTextBox.Text;
}
