public void Generate()
{
character.characterName.text = nameGenerator.fullName;
character.hairRenderer.sprite = hairSprites.GetRandom();
character.bodyRenderer.sprite = bodySprites.GetRandom();
character.headRenderer.sprite = headSprites.GetRandom();
character.chestRenderer.sprite = chestSprites.GetRandom();
character.legsRenderer.sprite = legsSprites.GetRandom();
character.feetRenderer.sprite = feetSprites.GetRandom();
if (RandomE.Chance(0.3f))
{
character.weaponRenderer.enabled = true;
character.weaponRenderer.sprite = weaponSprites.GetRandom();
if (RandomE.Chance(0.3f))
{
character.shieldRenderer.enabled = true;
character.shieldRenderer.sprite = shieldSprites.GetRandom();
}
else
{
character.shieldRenderer.enabled = false;
}
}
else
{
character.weaponRenderer.enabled = false;
character.shieldRenderer.enabled = false;
}
}
public static MeshDraft Armrests0(float seatWidth, float seatDepth, Vector3 backCenter, float backHeight,
float legWidth)
{
var draft = new MeshDraft();
float armrestHeight = RandomE.Range(backHeight / 4, backHeight * 3 / 4, 3);
float armrestLength = seatDepth - legWidth;
Vector3 corner = backCenter + Vector3.left * (seatWidth / 2 - legWidth / 2) + Vector3.back * legWidth / 2;
float offset = 0;
if (RandomE.Chance(0.5f))
{
offset = RandomE.Range(legWidth / 2, legWidth, 2);
}
Vector3 v0 = corner + Vector3.back * (armrestLength - legWidth / 2);
Vector3 v1 = v0 + Vector3.up * (armrestHeight - legWidth / 2);
Vector3 v2 = corner + Vector3.up * armrestHeight;
Vector3 v3 = v2 + Vector3.back * (armrestLength + offset);
var armrest = ChairGenerator.BeamDraft(v0, v1, legWidth);
armrest.Add(ChairGenerator.BeamDraft(v2, v3, legWidth));
draft.Add(armrest);
armrest.Move(Vector3.right * (seatWidth - legWidth));
draft.Add(armrest);
return(draft);
}
private MeshDraft Armrests1(Vector3 seatDimensions, Vector3 backCenter, float backHeight, float legWidth)
{
var draft = new MeshDraft();
float armrestHeight = RandomE.Range(backHeight / 4, backHeight * 3 / 4, 3);
float armrestLength = RandomE.Range(seatDimensions.z * 3 / 4, seatDimensions.z, 2);
legWidth = RandomE.Range(legWidth * 3 / 4, legWidth, 2);
var corner = backCenter + Vector3.left * (seatDimensions.x / 2 + legWidth / 2) +
Vector3.forward * legWidth / 2;
float offset = 0;
if (RandomE.Chance(0.5f))
{
offset = RandomE.Range(armrestLength / 4, armrestLength / 2, 2) - legWidth / 2;
}
var v0 = corner + Vector3.back * (armrestLength - legWidth / 2 - offset) + Vector3.down * legWidth;
var v1 = v0 + Vector3.up * (armrestHeight + legWidth / 2);
var v2 = corner + Vector3.up * armrestHeight;
var v3 = v2 + Vector3.back * armrestLength;
var armrest = BeamDraft(v0, v1, legWidth);
armrest.Add(BeamDraft(v2, v3, legWidth));
draft.Add(armrest);
armrest.Move(Vector3.right * (seatDimensions.x + legWidth));
draft.Add(armrest);
return(draft);
}
private MeshDraft KhrushchyovkaDraft()
{
float width = Random.Range(widthLB, widthUB);
float length = Random.Range(lengthLB, lengthUB);
int floorCount = Random.Range(floorCountLB, floorCountUB);
var hasAttic = RandomE.Chance(0.5f);
float height = FloorHeight * floorCount + SocleHeight + (hasAttic ? AtticHeight : 0);
var draft = new MeshDraft {
name = "Khrushchyovka"
};
var corners = new Vector3[]
{
Vector3.left *length / 2 + Vector3.back *width / 2,
Vector3.right *length / 2 + Vector3.back *width / 2,
Vector3.right *length / 2 + Vector3.forward *width / 2,
Vector3.left *length / 2 + Vector3.forward *width / 2
};
commonPanelConstructors[PanelType.Entrance] = panelConstructors[PanelType.Entrance].GetRandom();
commonPanelConstructors[PanelType.EntranceWall] = panelConstructors[PanelType.EntranceWall].GetRandom();
wallColor = RandomE.colorHSV.WithA(0);
var facadePlan0 = FacadeGenerator(length, floorCount, hasAttic, true, true);
draft.Add(Facade(corners[0], Vector3.right, facadePlan0));
var facadePlan1 = FacadeGenerator(width, floorCount, hasAttic);
draft.Add(Facade(corners[1], Vector3.forward, facadePlan1));
var facadePlan2 = FacadeGenerator(length, floorCount, hasAttic, false, true);
draft.Add(Facade(corners[2], Vector3.left, facadePlan2));
var facadePlan3 = FacadeGenerator(width, floorCount, hasAttic);
draft.Add(Facade(corners[3], Vector3.back, facadePlan3));
draft.Add(Roof(corners[0], corners[1], corners[2], corners[3], Vector3.up * height));
var basement = MeshE.QuadDraft(corners[0], corners[1], corners[2], corners[3]);
basement.Paint(roofColor);
draft.Add(basement);
return(draft);
}
private ILayout PlanEntranceFacade(float facadeWidth, int floors, float entranceInterval, bool hasAttic, bool leftIsConvex,
bool rightIsConvex)
{
float remainder;
List <PanelSize> panelSizes = DivideFacade(facadeWidth, leftIsConvex, rightIsConvex, out remainder);
bool hasBalconies = RandomE.Chance(0.5f);
commonConstructors[PanelType.Entrance] = constructors[PanelType.Entrance].GetRandom();
commonConstructors[PanelType.EntranceWindow] = constructors[PanelType.EntranceWindow].GetRandom();
commonConstructors[PanelType.Wall] = constructors[PanelType.Wall].GetRandom();
var horizontal = new HorizontalLayout();
bool hasRemainder = remainder > Geometry.Epsilon;
if (hasRemainder)
{
horizontal.Add(CreateBufferWallVertical(remainder / 2, floors, hasAttic));
}
int entranceCount = Mathf.Max(Mathf.FloorToInt(facadeWidth / entranceInterval) - 1, 1);
int entranceIndexInterval = (panelSizes.Count - entranceCount) / (entranceCount + 1);
int lastEntranceIndex = -1;
for (int i = 0; i < entranceCount; i++)
{
int entranceIndex = (i + 1) * entranceIndexInterval + i;
horizontal.Add(CreateNormalFacadeVertical(panelSizes, lastEntranceIndex + 1, entranceIndex, floors, hasAttic, hasBalconies));
horizontal.Add(CreateEntranceVertical(sizeValues[panelSizes[entranceIndex]], floors, hasAttic));
if (i == entranceCount - 1)
{
horizontal.Add(CreateNormalFacadeVertical(panelSizes, entranceIndex + 1, panelSizes.Count, floors, hasAttic, hasBalconies));
}
lastEntranceIndex = entranceIndex;
}
if (hasRemainder)
{
horizontal.Add(CreateBufferWallVertical(remainder / 2, floors, hasAttic));
}
return(horizontal);
}
private IEnumerator GenerateCoroutine()
{
texture = new Texture2D(mazeWidth, mazeHeight, TextureFormat.ARGB32, false, true)
{
filterMode = FilterMode.Point
};
cellWidth = (mazeWidth - cellWallSize) / (cellSize + cellWallSize);
cellHeight = (mazeHeight - cellWallSize) / (cellSize + cellWallSize);
maze = new Maze(cellWidth, cellHeight);
var origin = new Cell {
x = Random.Range(0, cellWidth), y = Random.Range(0, cellHeight)
};
maze[origin] = Directions.None;
edges = new List <Edge>(maze.GetEdges(origin));
texture.Clear(Color.black);
yield return(null);
switch (mazeAlgorithm)
{
case MazeAlgorithm.None:
if (RandomE.Chance(0.5f))
{
yield return(StartCoroutine(RandomTraversal()));
}
else
{
yield return(StartCoroutine(RandomDepthFirstTraversal()));
}
break;
case MazeAlgorithm.RandomTraversal:
yield return(StartCoroutine(RandomTraversal()));
break;
case MazeAlgorithm.RandomDepthFirstTraversal:
yield return(StartCoroutine(RandomDepthFirstTraversal()));
break;
}
texture.Apply();
}
public CompoundMeshDraft Generate(Config config)
{
Assert.IsTrue(config.width > 0);
Assert.IsTrue(config.length > 0);
Assert.IsTrue(config.floors > 0);
Assert.IsTrue(config.entranceInterval > 0);
InitializeConstructors(config.palette);
var foundationPolygon = new List <Vector2>
{
Vector2.left *config.length / 2 + Vector2.down *config.width / 2,
Vector2.right *config.length / 2 + Vector2.down *config.width / 2,
Vector2.right *config.length / 2 + Vector2.up *config.width / 2,
Vector2.left *config.length / 2 + Vector2.up *config.width / 2
};
commonConstructors[PanelType.Entrance] = constructors[PanelType.Entrance].GetRandom();
commonConstructors[PanelType.EntranceWindow] = constructors[PanelType.EntranceWindow].GetRandom();
var facadeLayouts = new List <FacadeLayout>();
for (int i = 0; i < foundationPolygon.Count; i++)
{
Vector2 a = foundationPolygon[i];
Vector2 b = foundationPolygon.GetLooped(i + 1);
float? entranceInterval = i == 0 ? config.entranceInterval : (float?)null;
bool hasBalconies = RandomE.Chance(0.5f);
facadeLayouts.Add(GenerateFacade(a, b, config.floors, hasBalconies, config.hasAttic, entranceInterval));
}
float facadeHeight = floorHeight * config.floors + socleHeight + (config.hasAttic ? atticHeight : 0);
var compoundDraft = GenerateFacadesCompoundMeshDraft(foundationPolygon, facadeLayouts);
var roofDraft = RoofGenerator.Generate(foundationPolygon, facadeHeight, config.roofConfig)
.Paint(config.palette.roofColor);
compoundDraft.Add(roofDraft);
compoundDraft.MergeDraftsWithTheSameName();
compoundDraft.SortDraftsByName();
compoundDraft.name = "Building";
return(compoundDraft);
}
private ILayout PlanNormalFacade(float facadeWidth, int floors, bool hasAttic, bool leftIsConvex, bool rightIsConvex)
{
List <PanelSize> panelSizes = DivideFacade(facadeWidth, leftIsConvex, rightIsConvex, out float remainder);
bool hasBalconies = RandomE.Chance(0.5f);
var vertical = CreateNormalFacadeVertical(panelSizes, 0, panelSizes.Count, floors, hasAttic, hasBalconies);
if (remainder > Geometry.Epsilon)
{
return(new HorizontalLayout
{
CreateBufferWallVertical(remainder / 2, floors, hasAttic),
vertical,
CreateBufferWallVertical(remainder / 2, floors, hasAttic)
});
}
return(vertical);
}
private List <FloorPlan> FacadeGenerator(float width, int floorCount, bool hasAttic, bool hasEntrances = false,
bool longFacade = false)
{
var panelSizes = PanelSizes(width);
int panelCount = panelSizes.Count;
var floors = new List <FloorPlan>(floorCount + 1);
int entrances = (int)(width / 10 - 1);
var entranceCount = 1;
var entranceIndex = panelCount * entranceCount / (entrances + 1);
for (var i = 0; i < floorCount + 1; i++)
{
var floorPlan = new FloorPlan {
height = i == 0 ? SocleHeight : FloorHeight
};
floors.Add(floorPlan);
for (var j = 0; j < panelCount; j++)
{
if (i == 0)
{
if (hasEntrances && j == entranceIndex && entranceCount <= entrances)
{
floorPlan.panels.Add(new Panel
{
type = PanelType.Entrance,
size = panelSizes[j],
height = FloorHeight
});
entranceCount++;
entranceIndex = panelCount * entranceCount / (entrances + 1);
}
else
{
floorPlan.panels.Add(new Panel
{
type = PanelType.Socle,
size = panelSizes[j],
height = SocleHeight
});
}
}
else if (i == 1)
{
if (floors[0].panels[j].type == PanelType.Entrance)
{
floorPlan.panels.Add(new Panel
{
type = PanelType.EntranceWall,
size = panelSizes[j],
height = FloorHeight,
heightOffset = FloorHeight - SocleHeight
});
}
else if (longFacade)
{
floorPlan.panels.Add(new Panel
{
type = PanelType.Window,
size = panelSizes[j],
height = FloorHeight
});
}
else
{
floorPlan.panels.Add(new Panel
{
type = PanelType.Wall,
size = panelSizes[j],
height = FloorHeight
});
}
}
else
{
floorPlan.panels.Add(new Panel(floors[i - 1].panels[j]));
}
if (i == floorCount && (floors[i - 1].panels[j].type == PanelType.Entrance ||
floors[i - 1].panels[j].type == PanelType.EntranceWall))
{
floorPlan.panels[j].type = PanelType.EntranceWallLast;
floorPlan.panels[j].height = SocleHeight;
floorPlan.panels[j].heightOffset = FloorHeight - SocleHeight;
}
}
if (i == 1 && !longFacade)
{
for (int j = 0; j <= panelCount / 2; j++)
{
if (j != 0 && j != panelCount - 1 && RandomE.Chance(0.5f))
{
floorPlan.panels[j].type = PanelType.Window;
floorPlan.panels[panelCount - 1 - j].type = PanelType.Window;
}
}
}
if (i == 2)
{
for (int j = 0; j <= panelCount / 2; j++)
{
if (floorPlan.panels[j].type == PanelType.Window &&
floorPlan.panels[panelCount - 1 - j].type == PanelType.Window && RandomE.Chance(0.5f))
{
floorPlan.panels[j].type = PanelType.Balcony;
floorPlan.panels[panelCount - 1 - j].type = PanelType.Balcony;
}
}
}
}
if (hasAttic)
{
var floorPlan = new FloorPlan {
height = AtticHeight
};
floors.Add(floorPlan);
for (var i = 0; i < panelCount; i++)
{
floorPlan.panels.Add(new Panel
{
type = PanelType.Attic,
size = panelSizes[i],
height = AtticHeight
});
}
}
return(floors);
}
private static List <FloorPlan> FacadeGenerator(float width, int floorCount, bool hasAttic,
bool hasEntrances = false,
bool longFacade = false)
{
List <PanelSize> panelSizes = SplitWallIntoPanels(width);
int panelCount = panelSizes.Count;
var floors = new List <FloorPlan>(floorCount + 1);
int entrances = (int)(width / 10 - 1);
int entranceCount = 1;
int entranceIndex = panelCount * entranceCount / (entrances + 1);
for (var i = 0; i < floorCount + 1; i++)
{
var floorPlan = new FloorPlan {
height = i == 0 ? SocleHeight : FloorHeight
};
floors.Add(floorPlan);
for (var j = 0; j < panelCount; j++)
{
// On socle floor we have entrances and socle panels
if (i == 0)
{
if (hasEntrances && j == entranceIndex && entranceCount <= entrances)
{
floorPlan.panels.Add(new Panel
{
type = PanelType.Entrance,
size = panelSizes[j],
height = FloorHeight
});
entranceCount++;
entranceIndex = panelCount * entranceCount / (entrances + 1);
}
else
{
floorPlan.panels.Add(new Panel
{
type = PanelType.Socle,
size = panelSizes[j],
height = SocleHeight
});
}
}
// On first floor we decorate entrances with entrance walls,
// place windows on long facades and regular walls on short facades
else if (i == 1)
{
if (floors[0].panels[j].type == PanelType.Entrance)
{
floorPlan.panels.Add(new Panel
{
type = PanelType.EntranceWall,
size = panelSizes[j],
height = FloorHeight,
heightOffset = FloorHeight - SocleHeight
});
}
else if (longFacade)
{
floorPlan.panels.Add(new Panel
{
type = PanelType.Window,
size = panelSizes[j],
height = FloorHeight
});
}
else
{
floorPlan.panels.Add(new Panel
{
type = PanelType.Wall,
size = panelSizes[j],
height = FloorHeight
});
}
}
// On second floor and upper we repeat layout of the first floor
else
{
floorPlan.panels.Add(new Panel(floors[i - 1].panels[j]));
}
// Entrance-type panel on the last floor should have special model
if (i == floorCount && (floors[i - 1].panels[j].type == PanelType.Entrance ||
floors[i - 1].panels[j].type == PanelType.EntranceWall))
{
floorPlan.panels[j].type = PanelType.EntranceWallLast;
floorPlan.panels[j].height = SocleHeight;
floorPlan.panels[j].heightOffset = FloorHeight - SocleHeight;
}
}
// Short facade can have windows, but their positions should have horizontal symmetry
if (i == 1 && !longFacade)
{
// Iterate from corner to center of facade and replace walls with windows
for (int j = 0; j <= panelCount / 2; j++)
{
if (j != 0 && j != panelCount - 1 && RandomE.Chance(0.5f))
{
floorPlan.panels[j].type = PanelType.Window;
floorPlan.panels[panelCount - 1 - j].type = PanelType.Window;
}
}
}
// Symmetrically replace windows with balconies
if (i == 2)
{
for (int j = 0; j <= panelCount / 2; j++)
{
if (floorPlan.panels[j].type == PanelType.Window &&
floorPlan.panels[panelCount - 1 - j].type == PanelType.Window && RandomE.Chance(0.5f))
{
floorPlan.panels[j].type = PanelType.Balcony;
floorPlan.panels[panelCount - 1 - j].type = PanelType.Balcony;
}
}
}
}
// Attach attic on top
if (hasAttic)
{
var floorPlan = new FloorPlan {
height = AtticHeight
};
floors.Add(floorPlan);
for (var i = 0; i < panelCount; i++)
{
floorPlan.panels.Add(new Panel
{
type = PanelType.Attic,
size = panelSizes[i],
height = AtticHeight
});
}
}
return(floors);
}
private MeshDraft Chair()
{
var legWidth = Random.Range(legWidthLB, legWidthUB);
var legHeight = Random.Range(legHeightLB, legHeightUB);
var seatDimensions = RandomE.Range(seatLB, seatUB);
var backHeight = Random.Range(backHeightLB, backHeightUB);
var chair = new MeshDraft {
name = "Chair"
};
var right = Vector3.right * (seatDimensions.x - legWidth) / 2;
var forward = Vector3.forward * (seatDimensions.z - legWidth) / 2;
var legCenters = new Vector3[]
{
-right - forward,
right - forward,
right + forward,
-right + forward
};
chair.Add(Leg0(legCenters[0], legWidth, legHeight));
chair.Add(Leg0(legCenters[1], legWidth, legHeight));
chair.Add(Leg0(legCenters[2], legWidth, legHeight));
chair.Add(Leg0(legCenters[3], legWidth, legHeight));
if (RandomE.Chance(0.3f))
{
var stretcherFunc = new Func <Vector3[], float, float, MeshDraft>[]
{
XStretchers,
HStretchers,
BoxStretchers
}.Choice();
chair.Add(stretcherFunc(legCenters, legWidth, legHeight));
}
chair.Add(Seat0(Vector3.up * legHeight, seatDimensions.x, seatDimensions.z, seatDimensions.y));
var backFunc = new Func <Vector3, float, float, float, MeshDraft>[]
{
Back0,
Back1,
RodBack
}.Choice();
var backCenter = Vector3.up * (legHeight + seatDimensions.y) + Vector3.forward * (seatDimensions.z - legWidth) / 2;
chair.Add(backFunc(backCenter, seatDimensions.x, legWidth, backHeight));
if (RandomE.Chance(0.3f))
{
var armrestsFunc = new Func <Vector3, Vector3, float, float, MeshDraft>[]
{
Armrests0,
Armrests1
}.Choice();
chair.Add(armrestsFunc(seatDimensions, backCenter, backHeight, legWidth));
}
chair.Paint(RandomE.colorHSV);
return(chair);
}
