/// <summary>
/// Sets up the Skyscraper script and then calls its
/// Generate() method.
/// </summary>
public void GenerateRandomly()
{
Skyscraper ss = GetComponent <Skyscraper>();
SetFields(ss);
ss.Generate();
}
/// <summary>
/// Draws handles for each vertex in the base and draws lines between them. Also previews the height
/// with additional lines.
/// </summary>
void OnSceneGUI()
{
if (Camera.current != null)
{
Handles.color = Color.red;
Skyscraper tar = (Skyscraper)target;
for (int i = 0; i < tar.baseVertices.Length; i++)
{
Vector3 pos = tar.baseVertices[i];
if (MoveHandle(tar, ref pos))
{
Undo.RecordObject(tar, "Move Vertex");
tar.baseVertices[i] = pos;
EditorUtility.SetDirty(tar);
}
Handles.DrawLine(tar.transform.TransformPoint(tar.baseVertices[i]),
tar.transform.TransformPoint(tar.baseVertices[i] + Vector3.up * tar.height));
if (i > 0)
{
Handles.DrawLine(tar.transform.TransformPoint(tar.baseVertices[i - 1] + Vector3.up * tar.height),
tar.transform.TransformPoint(pos + Vector3.up * tar.height));
Handles.DrawLine(tar.transform.TransformPoint(tar.baseVertices[i - 1]),
tar.transform.TransformPoint(pos));
}
else
{
Handles.DrawLine(tar.transform.TransformPoint(tar.baseVertices[tar.baseVertices.Length - 1] + Vector3.up * tar.height),
tar.transform.TransformPoint(pos + Vector3.up * tar.height));
Handles.DrawLine(tar.transform.TransformPoint(tar.baseVertices[tar.baseVertices.Length - 1]),
tar.transform.TransformPoint(pos));
}
}
}
}
static void Main(string[] args)
{
foreach (Level level in Levels.GetLevels())
{
SkyscraperDto skyscraperDto = new SkyscraperDto
{
Floors = new List <FloorDto> (),
Elevators = new List <ElevatorDto> ()
};
for (int i = 0; i < level.FloorCount; i++)
{
skyscraperDto.Floors.Add(new FloorDto {
FloorNumber = i
});
}
for (int i = 0; i < level.ElevatorCount; i++)
{
skyscraperDto.Elevators.Add(new ElevatorDto {
CurrentFloor = 0, MaxPassengerCount = level.MaxPassengerCount
});
}
var skyscraper = new Skyscraper(skyscraperDto);
var player = new Dev2Player();
skyscraper.LoadPlayer(player);
InitialiseGame(skyscraper, level);
}
}
private static void Render(TimeSpan gameTime, Skyscraper skyscraper, Level level)
{
//System.Console.WriteLine(skyscraper.Floors[0].PassengersWaiting.Count);
if (gameTime.Milliseconds == 0 && gameTime.Seconds == 0 && gameTime.Minutes == 0)
{
System.Console.WriteLine(gameTime);
System.Console.WriteLine(skyscraper.Elevators[0].CurrentFloor + " - " + skyscraper.Elevators[0].HeightAboveCurrentFloor);
}
switch (level.state)
{
case LevelState.Active:
break;
case LevelState.Success:
Win(skyscraper, level, gameTime);
break;
case LevelState.Failure:
Lose(skyscraper, level, gameTime);
break;
default:
break;
}
}
private static void SaveSkyscraper(Skyscraper skyscraper)
{
var cache = MemoryCache.Default;
cache.Remove("skyscraper");
cache.Set("skyscraper", skyscraper, new CacheItemPolicy {
AbsoluteExpiration = DateTimeOffset.Now.AddDays(1)
});
}
/// <summary>
/// Removes the last vertex of the base
/// </summary>
/// <param name="tar">The skyscraper to modify</param>
private void RemoveBaseVertex(Skyscraper tar)
{
Vector3[] newBase = new Vector3[tar.baseVertices.Length - 1];
for (int i = 0; i < tar.baseVertices.Length - 1; i++)
{
newBase[i] = tar.baseVertices[i];
}
tar.baseVertices = newBase;
EditorUtility.SetDirty(target);
}
private static void GeneratePassengers(TimeSpan gameTime, Skyscraper skyscraper, Level level)
{
foreach (var arrivalRate in level.PassengerArrivalProfile.FloorArrivalRate)
{
if (gameTime >= arrivalRate.LastArrival.Add(new TimeSpan(0, 0, 0, 0, arrivalRate.msPerArrival)))
{
arrivalRate.LastArrival = gameTime;
skyscraper.Floors[arrivalRate.Floor].PassengerArrives(skyscraper, new Passenger(2));
}
}
}
private static void Win(Skyscraper skyscraper, Level level, TimeSpan gametime)
{
System.Console.WriteLine("You Win:" + level.Name + ":" + gametime);
foreach (var elevator in skyscraper.Elevators)
{
System.Console.WriteLine(elevator.UnloadedCount);
}
System.Console.WriteLine("Press Any Key To Close:");
System.Console.ReadLine();
}
public ContentResult New(SkyscraperDto skyscraperDto)
{
var skyscraper = new Skyscraper(skyscraperDto);
var player = LoadPlayer();
skyscraper.LoadPlayer(player); // This calls the Init method on Player and hooks up events
SaveSkyscraper(skyscraper);
var json = JsonConvert.SerializeObject("Ready."); // TODO: Not needed, unless you want to pass some UI message back.
return(Content(json, "application/json"));
}
/// <summary>
/// Returns the base back to the default shape and size
/// </summary>
/// <param name="tar">The skyscraper to modify</param>
private void ResetBase(Skyscraper tar)
{
Vector3[] newBase = new Vector3[]
{
new Vector3(5f, 0, -5f),
new Vector3(5f, 0, 5f),
new Vector3(-5f, 0, 5f),
new Vector3(-5f, 0, -5f)
};
tar.baseVertices = newBase;
EditorUtility.SetDirty(target);
}
/// <summary>
/// Designs a base by picking a base shape and scaling it according to
/// some random values, and then rotating it randomly.
/// </summary>
/// <param name="ss">The skyscraper whose base is being built</param>
/// <returns></returns>
private Vector3[] BuildBase(Skyscraper ss)
{
float l = Random.Range(minLength, maxLength);
float w = Random.Range(minWidth, maxWidth);
List <PossibleBase> possibilities = new List <PossibleBase>();
foreach (PossibleBase pBase in standardBases)
{
if (pBase.selected)
{
possibilities.Add(pBase);
}
}
foreach (PossibleBase pBase in customBases)
{
if (pBase.selected)
{
possibilities.Add(pBase);
}
}
if (possibilities.Count == 0)
{
Debug.LogWarning("No base shapes have been selected. Defaulting to the exisiting shape.");
return(ss.baseVertices);
}
int randomIndex = Random.Range(0, possibilities.Count);
Vector3[] chosenBase = (Vector3[])possibilities[randomIndex].baseVerts.Clone();
int rotationIndex = Random.Range(0, 4);
for (int i = 0; i < chosenBase.Length; i++)
{
chosenBase[i].x *= w;
chosenBase[i].z *= l;
switch (rotationIndex)
{
case 0:
chosenBase[i] = Quaternion.Euler(0, -90, 0) * chosenBase[i];
break;
case 1:
chosenBase[i] = Quaternion.Euler(0, -180, 0) * chosenBase[i];
break;
case 2:
chosenBase[i] = Quaternion.Euler(0, -270, 0) * chosenBase[i];
break;
}
}
return(chosenBase);
}
private static void Lose(Skyscraper skyscraper, Level level, TimeSpan gametime)
{
System.Console.WriteLine("You Lose:" + level.Name + ":" + gametime);
foreach (var elevator in skyscraper.Elevators)
{
System.Console.WriteLine(elevator.UnloadedCount);
}
System.Console.WriteLine("Total Transported:" + skyscraper.Elevators.Sum(e => e.UnloadedCount));
System.Console.WriteLine("Press Any Key To Close:");
System.Console.ReadLine();
}
/// <summary>
/// Rather than use Skyscraper's Generate() method, this goes
/// through the process step by step in order to update a
/// progress bar. Then it save the generated content as assets
/// and assigns them back to the object.
/// </summary>
/// <param name="tar">The skyscraper to modify</param>
public static void GenerateAndSave(Skyscraper tar)
{
EditorUtility.DisplayProgressBar("Generating Tower", "Generating Mesh", 0);
MeshRenderer r = tar.GetComponent <MeshRenderer>();
try
{
MeshFilter mf = tar.GetComponent <MeshFilter>();
mf.mesh = tar.BuildMesh();
EditorUtility.DisplayProgressBar("Generating Tower", "Generating Material", .33f);
Texture2D genTex = tar.BuildTexture();
tar.BuildMaterial(genTex);
EditorUtility.DisplayProgressBar("Generating Tower", "Saving assets", .67f);
}
catch (UnityException ex)
{
Debug.LogError("An error occurs when generating the skyscraper: " + ex.ToString());
}
try
{
Texture2D tex = (Texture2D)tar.gameObject.GetComponent <MeshRenderer>().sharedMaterial.mainTexture;
string dir = "Assets/SkyscraperMaker/Skyscrapers/" + tar.name + tar.GetInstanceID();
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
byte[] bytes = tex.EncodeToPNG();
File.WriteAllBytes(dir + "/" + tar.name + "_wall_texture.png", bytes);
AssetDatabase.CreateAsset(tar.GetComponent <MeshFilter>().sharedMesh, dir + "/" + tar.name + "_mesh.asset");
AssetDatabase.CreateAsset(r.sharedMaterial, dir + "/" + tar.name + "_material.mat");
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
//Now that everything exists as an asset, we make assignments to link everything together
Material material = (Material)(AssetDatabase.LoadAssetAtPath(dir + "/" + tar.name + "_material.mat", typeof(Material)));
Texture2D mainTex = (Texture2D)(AssetDatabase.LoadAssetAtPath(dir + "/" + tar.name + "_wall_texture.png", typeof(Texture2D)));
material.mainTexture = mainTex;
tar.BuildCollider(tar.GetComponent <MeshFilter>().sharedMesh);
AssetDatabase.SaveAssets();
}
catch (UnityException ex)
{
Debug.LogError("Unable to save the generated assets at this time: " + ex.ToString());
}
EditorUtility.ClearProgressBar();
AssetDatabase.Refresh();
Undo.RecordObject(tar, "Built Skyscraper");
}
public ActionResult DeleteSkyscraperConfirmed(int id)
{
if (!User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index"));
}
Skyscraper skyscraper = db.Skyscrapers.Find(id);
db.Skyscrapers.Remove(skyscraper);
db.SaveChanges();
return(RedirectToAction("Index"));
}
private static void InitialiseGame(Skyscraper skyscraper, Level level)
{
level.state = LevelState.Active;
var gameTime = new TimeSpan();
while (level.state == LevelState.Active)
{
Update(gameTime, skyscraper, level);
Render(gameTime, skyscraper, level);
}
}
/// <summary>
/// Places another vertex equidistant to the first and last
/// existing vertices
/// </summary>
/// <param name="tar">The skyscraper to modify</param>
private void AddBaseVertex(Skyscraper tar)
{
Vector3[] newBase = new Vector3[tar.baseVertices.Length + 1];
for (int i = 0; i < tar.baseVertices.Length; i++)
{
newBase[i] = tar.baseVertices[i];
}
newBase[newBase.Length - 1] = new Vector3(
(newBase[0].x + newBase[newBase.Length - 2].x) / 2,
0,
(newBase[0].z + newBase[newBase.Length - 2].z) / 2);
tar.baseVertices = newBase;
EditorUtility.SetDirty(target);
}
/// <summary>
/// Changes all the properties of the Skyscraper according to
/// psuedorandomness.
/// </summary>
/// <param name="ss">The skyscraper to modify</param>
public void SetFields(Skyscraper ss)
{
//Set random values based on given limits
ss.height = Random.Range(minHeight, maxHeight);
ss.windowWidth = Random.Range(minWindowWidth, maxWindowWidth);
ss.windowHeight = Random.Range(minWindowHeight, maxWindowHeight);
ss.floorSpace = Random.Range(minStoryGap, maxStoryGap);
ss.roofColor = roofColors[Random.Range(0, roofColors.Count)];
ss.windowColor = windowColors[Random.Range(0, windowColors.Count)];
ss.cornerColor = cornerColors[Random.Range(0, cornerColors.Count)];
ss.storyDividerColor = storyDividerColors[Random.Range(0, storyDividerColors.Count)];
ss.windowDividerColor = windowDividerColors[Random.Range(0, windowDividerColors.Count)];
ss.baseVertices = BuildBase(ss);
int windowI = ChooseAmongTrue(windowStyleOptions);
if (windowI >= 0)
{
ss.windowType = (WindowType)windowI;
}
else
{
Debug.LogWarning("No window type selected. Defaulting to previous type.");
}
int roofI = ChooseAmongTrue(roofStyleOptions);
if (roofI >= 0)
{
ss.roofType = (RoofType)roofI;
}
else
{
Debug.LogWarning("No roof type selected. Defaulting to previous type.");
}
if (ss.roofType == RoofType.Slanted)
{
ss.roofSlant = Random.Range(minSlant, maxSlant);
ss.slantRoofBorder = Random.Range(minRoofBorder, maxRoofBorder);
ss.slantWallColor = slantWallColors[Random.Range(0, slantWallColors.Count)];
ss.roofPeak = (Direction)Random.Range(0, 4);
}
else if (ss.roofType == RoofType.Indented)
{
ss.indentedRoofHeight = Random.Range(minIndentedRoofHeight, maxIndentedRoofHeight);
ss.indent = Random.Range(minIndent, maxIndent);
}
}
public ActionResult EditSkyscraper([Bind(Include = "Id,Name,Country,City,Height,Year")] Skyscraper skyscraper)
{
if (!User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index"));
}
if (ModelState.IsValid)
{
db.Entry(skyscraper).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(skyscraper));
}
// GET: Skyscrapers/Delete/5
public ActionResult DeleteSkyscraper(int?id)
{
if (!User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index"));
}
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Skyscraper skyscraper = db.Skyscrapers.Find(id);
if (skyscraper == null)
{
return(HttpNotFound());
}
return(View(skyscraper));
}
/// <summary>
/// Takes care of vertex handle movement, locking them along the Y axis.
/// </summary>
/// <param name="tar">The skyscraper to modify</param>
/// <param name="pos">Position of the handle</param>
/// <returns></returns>
public bool MoveHandle(Skyscraper tar, ref Vector3 pos)
{
EditorGUI.BeginChangeCheck();
Vector3 newPos = Handles.FreeMoveHandle(tar.transform.TransformPoint(pos), Quaternion.identity, .5f, new Vector3(1f, 1f, 1f), Handles.CircleCap);
//To allow rotations, everything will be done locally
newPos = tar.transform.InverseTransformPoint(newPos);
Vector3 camPos = tar.transform.InverseTransformPoint(Camera.current.transform.position);
Vector3 posDiff = camPos - newPos;
float factor = camPos.y / posDiff.y;
newPos = new Vector3(camPos.x - posDiff.x * factor,
0,
camPos.z - posDiff.z * factor);
pos = newPos;
return(EditorGUI.EndChangeCheck());
}
private static void Update(TimeSpan gameTime, Skyscraper skyscraper, Level level)
{
gameTime = gameTime.Add(new TimeSpan(0, 0, 0, 0, 1));
GeneratePassengers(gameTime, skyscraper, level);
skyscraper.Update(gameTime);
if (level.WinCriteriaMet(skyscraper))
{
level.state = LevelState.Success;
}
else
{
if (gameTime.TotalSeconds > level.TimeLimit)
{
level.state = LevelState.Failure;
}
}
}
void Update()
{
if (monster.input.jumpPressed && !inAir) {
startJumpTime = Time.time;
startJump = true;
lr.enabled = true;
lr.SetColors(jumpTrailColorStart, jumpTrailColorEnd);
}
if (startJump) {
var deltaTime = Mathf.Clamp(Time.time - startJumpTime, 0f, monster.maxJumpTime);
jumpForce = deltaTime * monster.maxJumpForce / monster.maxJumpTime;
var targetBloodTake = (monster.move.jumpForce / monster.maxJumpForce) * monster.maxBloodPerJump;
monster.bloodTaken = monster.bloodManager.reserveBlood(targetBloodTake);
}
//
if (checkGround()) {
if (inAir) {
velocity = Vector3.zero;
inAir = false;
monster.sounder.playSound(monster.landingSound);
transform.position = hit.point + hit.normal * monster.size.y;
var angle = Mathf.Atan2(hit.normal.y, hit.normal.x) * Mathf.Rad2Deg - 90f;
transform.rotation = Quaternion.Euler(0f, 0f, angle);
}
previousObject = null;
}
else if (checkWorldObject()) {
if (hit.collider.GetComponent<WorldObject>() != previousObject) {
velocity = Vector3.zero;
inAir = false;
monster.sounder.playSound(monster.landingSound);
transform.position = (Vector3)hit.point
+ Vector3.up * hit.normal.y * monster.size.y
+ Vector3.right * hit.normal.x * monster.size.x;
var angle = Mathf.Atan2(hit.normal.y, hit.normal.x) * Mathf.Rad2Deg - 90f;
transform.rotation = Quaternion.Euler(0f, 0f, angle);
sittingOnObject = hit.collider.GetComponent<WorldObject>();
if (!sittingOnObject.canThrow && sittingOnObject.canBlood) {
sittingOnObject.damage(monster.damageValue);
sittingOnObject = null;
}
else {
transform.SetParent(sittingOnObject.transform);
transform.localScale = Vector3.one;
}
}
}
else if (checkSkyscraper()) {
if (targetSkyscraper == null) {
if (hit.collider.GetComponent<Skyscraper>() != currentSkyscraper) {
velocity = Vector3.zero;
currentSkyscraper = hit.collider.GetComponent<Skyscraper>();
targetSkyscraper = null;
inAir = false;
monster.sounder.playSound(monster.landingSound);
var angle = Mathf.Atan2(hit.normal.y, hit.normal.x) * Mathf.Rad2Deg - 90f;
transform.rotation = Quaternion.Euler(0f, 0f, angle);
}
}
else {
var targetDistance = (transform.position - targetPoint).magnitude;
if (targetDistance < minTargetDistance) {
minTargetDistance = targetDistance;
}
else {
velocity = Vector3.zero;
currentSkyscraper = targetSkyscraper;
targetSkyscraper = null;
inAir = false;
monster.sounder.playSound(monster.landingSound);
}
}
previousObject = null;
}
if (monster.input.jumpReleased && !inAir) {
var dir = (monster.input.clickPos - transform.position).normalized;
monster.bloodManager.getBlood(monster.bloodTaken);
jumpForce = monster.bloodTaken / monster.maxBloodPerJump * monster.maxJumpForce;
velocity = dir * jumpForce;
targetPoint = monster.input.clickPos;
minTargetDistance = Mathf.Infinity;
var col = Physics2D.OverlapCircle(monster.input.clickPos, 0.1f, Game.instance.skyscraperLayer);
if (col != null) {
targetSkyscraper = col.GetComponent<Skyscraper>();
}
else
targetSkyscraper = null;
sittingOnObject = null;
transform.SetParent(null);
transform.localScale = Vector3.one;
inAir = true;
startJump = false;
lr.enabled = false;
monster.bloodTaken = 0f;
monster.sounder.playSound(monster.jumpSound);
}
if (monster.input.throwObject && sittingOnObject != null) {
if (sittingOnObject.canThrow) {
var dir = (monster.input.clickPos - transform.position).normalized;
velocity = -dir * monster.maxJumpForce;
sittingOnObject.throwObject(dir, monster.throwForce);
previousObject = sittingOnObject;
sittingOnObject = null;
transform.SetParent(null);
transform.localScale = Vector3.one;
inAir = true;
lr.enabled = false;
throwable = false;
monster.sounder.playSound(monster.throwSound);
}
}
else if (sittingOnObject != null) {
if (sittingOnObject.canThrow) {
throwable = true;
lr.enabled = true;
lr.SetColors(throwTrailColorStart, throwTrailColorEnd);
}
}
if (sittingOnObject == null) {
transform.position += velocity * Time.deltaTime;
if (inAir) {
velocity.y += Game.instance.gravity * Time.deltaTime;
}
if (velocity.magnitude > 0) {
var angle = Mathf.Atan2(velocity.y, velocity.x) * Mathf.Rad2Deg - 90f;
transform.rotation = Quaternion.Euler(0f, 0f, angle);
}
}
if (transform.position.x > Game.instance.rightTopCorner.position.x) {
var repos = transform.position;
repos.x = Game.instance.leftBottomCorner.position.x;
transform.position = repos;
} else if (transform.position.x < Game.instance.leftBottomCorner.position.x) {
var repos = transform.position;
repos.x = Game.instance.rightTopCorner.position.x;
transform.position = repos;
}
}
public void TestSkyscraper()
{
// Arrange
SearsTower = new Skyscraper("TestSears", 110);
WillisTower = new Skyscraper("TestWillis", 30);
// Act
string searsName = SearsTower.Name;
int searsMax = SearsTower.NumberOfFloors;
string searsAbout = SearsTower.About();
string willisAbout = WillisTower.About();
bool elevDoorfirst = SearsTower.elevator.doorsClosed;
string elevAbout = SearsTower.elevatorAbout();
string elevOpenMessage = SearsTower.elevator.closeDoors();
bool elevDoorSecond = SearsTower.elevator.doorsClosed;
SearsTower.elevator.closeDoors();
bool elevDoorThird = SearsTower.elevator.doorsClosed;
string elevCloseMessage = SearsTower.elevator.About();
string elevatorUp = SearsTower.UseElevator(50);
bool doorShouldOpen = SearsTower.elevator.doorsClosed;
SearsTower.elevator.closeDoors();
string elevatorDown = SearsTower.elevator.ChangeFloor(40);
string elevatorDoorsOpen = SearsTower.elevator.ChangeFloor(1000);
SearsTower.elevator.closeDoors();
string elevatorMax = SearsTower.elevator.ChangeFloor(1000);
string closedDoors = SearsTower.elevatorDoors();
// Assert
Assert.AreEqual("This " + SearsTower.ToString() + " is named " + searsName + ", has " + searsMax + " number of floors",
searsAbout);
//Skyscrapers have at least 41 floors
Assert.AreEqual("This " + WillisTower.ToString() + " is named " + "TestWillis" + ", has " + 41 + " number of floors",
willisAbout);
Assert.AreEqual(false, elevDoorfirst);
Assert.AreEqual("This elevator's doors are open, this elevator's range is 0 to " + "110",
elevAbout);
Assert.AreEqual("Doors Closed!", elevOpenMessage);
Assert.AreEqual(true, elevDoorSecond);
Assert.AreEqual(true, elevDoorThird);
Assert.AreEqual("This elevator's doors are closed, this elevator's range is 0 to " + "110", elevCloseMessage);
Assert.AreEqual("Destination reached, Current Floor: " + 50, elevatorUp);
Assert.AreEqual(false, doorShouldOpen);
Assert.AreEqual("Destination reached, Current Floor: " + 40, elevatorDown);
Assert.AreEqual("Elevator cannot move. Doors must be closed first.", elevatorDoorsOpen);
Assert.AreEqual("Error: Elevator cannot reach that floor. Elevator range is 0 to " + SearsTower.elevator.maxFloor, elevatorMax);
Assert.AreEqual("Doors Closed!", closedDoors);
}
/// <summary>
/// Creates the inspector with lots of controls. for various ranges.
/// </summary>
public override void OnInspectorGUI()
{
SkyscraperRandomizer tar = (SkyscraperRandomizer)target;
EditorGUI.BeginChangeCheck();
tar.generateOnStart = EditorGUILayout.Toggle("Generate on Start", tar.generateOnStart);
DisplayRangeControl("Height", ref tar.minHeight, ref tar.maxHeight);
DisplayRangeControl("Width", ref tar.minWidth, ref tar.maxWidth);
DisplayRangeControl("Length", ref tar.minLength, ref tar.maxLength);
DisplayRangeControl("Window Width", ref tar.minWindowWidth, ref tar.maxWindowWidth);
DisplayRangeControl("Window Height", ref tar.minWindowHeight, ref tar.maxWindowHeight);
DisplayRangeControl("Window Spacing", ref tar.minWindowGap, ref tar.maxWindowGap);
DisplayRangeControl("Gap Between Stories", ref tar.minStoryGap, ref tar.maxStoryGap);
EditorGUILayout.Separator();
showRoofColors = DisplayColorGroup("Roof Colors", tar.roofColors, showRoofColors);
showWindowColors = DisplayColorGroup("Window Colors", tar.windowColors, showWindowColors);
showWindowDividerColors = DisplayColorGroup("Window Divider Colors", tar.windowDividerColors, showWindowDividerColors);
showCornerColors = DisplayColorGroup("Corner Colors", tar.cornerColors, showCornerColors);
showStoryDividerColors = DisplayColorGroup("Story Divider Colors", tar.storyDividerColors, showStoryDividerColors);
//Allows the editing of base shape options as well as the registering of new ones
EditorGUILayout.Separator();
showPossibleBases = EditorGUILayout.Foldout(showPossibleBases, "Base Shapes");
if (showPossibleBases)
{
foreach (PossibleBase possibleBase in tar.standardBases)
{
possibleBase.selected = EditorGUILayout.Toggle(possibleBase.name, possibleBase.selected);
}
for (int i = 0; i < tar.customBases.Count; i++)
{
EditorGUILayout.BeginHorizontal();
tar.customBases[i].selected = EditorGUILayout.Toggle(tar.customBases[i].name, tar.customBases[i].selected);
if (GUILayout.Button("Delete"))
{
tar.customBases.RemoveAt(i);
}
EditorGUILayout.EndHorizontal();
}
newBaseName = EditorGUILayout.TextField(newBaseName);
if (GUILayout.Button("Add Current Base Shape"))
{
Vector3[] verts = (Vector3[])tar.GetComponent <Skyscraper>().baseVertices.Clone();
RescaleBase(verts);
tar.customBases.Add(new PossibleBase(newBaseName, verts));
}
}
//Allows you to pick and choose different possible window types
EditorGUILayout.Separator();
showPossibleWindowTypes = EditorGUILayout.Foldout(showPossibleWindowTypes, "Window Types");
if (showPossibleWindowTypes)
{
for (int i = 0; i < tar.windowStyleOptions.Length; i++)
{
tar.windowStyleOptions[i] = EditorGUILayout.Toggle(windowTypeNames[i], tar.windowStyleOptions[i]);
}
}
//Allows you to pick and choose different possible roof types
showPossibleRoofTypes = EditorGUILayout.Foldout(showPossibleRoofTypes, "Roof Types");
if (showPossibleRoofTypes)
{
for (int i = 0; i < tar.roofStyleOptions.Length; i++)
{
tar.roofStyleOptions[i] = EditorGUILayout.Toggle(roofTypeNames[i], tar.roofStyleOptions[i]);
}
if (tar.roofStyleOptions[(int)RoofType.Slanted])
{
DisplayRangeControl("Roof Slant", ref tar.minSlant, ref tar.maxSlant);
DisplayRangeControl("Slant Roof Border", ref tar.minRoofBorder, ref tar.maxRoofBorder);
showSlantWallColors = DisplayColorGroup("Slant Wall Colors", tar.slantWallColors, showSlantWallColors);
}
if (tar.roofStyleOptions[(int)RoofType.Indented])
{
DisplayRangeControl("Indented Roof Height", ref tar.minIndentedRoofHeight, ref tar.maxIndentedRoofHeight);
DisplayRangeControl("Indentation", ref tar.minIndent, ref tar.maxIndent);
}
}
//Button for randomizing in the Editor
if (GUILayout.Button("Randomly Generate"))
{
Skyscraper ss = tar.GetComponent <Skyscraper>();
tar.SetFields(ss);
SkyscraperEditor.GenerateAndSave(ss);
EditorUtility.SetDirty(target);
}
Undo.RecordObject(tar, "Modified Skyscraper Randomizer");
}
/// <summary>
/// Use ElevatorCommands for sending back to client.
/// </summary>
/// <param name="skyscraperDto"></param>
/// <param name="skyscraper"></param>
/// <returns></returns>
internal static ElevatorCommands CreateElevatorCommands(SkyscraperDto skyscraperDto, Skyscraper skyscraper)
{
var elevatorCommands = new ElevatorCommands();
var jumpQueueDestinations = skyscraper.Elevators[skyscraperDto.EventRaisedElevatorIndex].JumpQueueDestinations;
var newDestinations = skyscraper.Elevators[skyscraperDto.EventRaisedElevatorIndex].NewDestinations;
while (jumpQueueDestinations.Count > 0)
{
AddGoToFloorCommands(skyscraperDto, jumpQueueDestinations, elevatorCommands, true);
}
while (newDestinations.Count > 0)
{
AddGoToFloorCommands(skyscraperDto, newDestinations, elevatorCommands, false);
}
foreach (var elevator in skyscraper.Elevators)
{
if (elevator.StopElevator)
{
elevatorCommands.StopElevators.Add(new StopElevator(elevator.Index));
elevator.StopElevator = false; // This is not synced so must be reset here
}
elevatorCommands.SetUpIndicators.Add(new SetIndicatorCommand(elevator.Index, elevator.GoingUpIndicator));
elevatorCommands.SetDownIndicators.Add(new SetIndicatorCommand(elevator.Index, elevator.GoingDownIndicator));
if (elevator.IsDestinationQueueModified)
{
elevatorCommands.DestinationQueueCommands.Add(new DestinationQueueCommand
{
ElevatorIndex = elevator.Index,
DestinationQueue = elevator.DestinationQueue
});
}
}
return(elevatorCommands);
}
/// <summary>
/// Allows some additional controls to the Inspector, such as vertex manipulation
/// control and and generation button. It also hides fields that are irrelevant
/// because of other field selections.
/// </summary>
public override void OnInspectorGUI()
{
Skyscraper tar = (Skyscraper)target;
EditorGUI.BeginChangeCheck();
if (GUILayout.Button("Reset Base"))
{
ResetBase(tar);
}
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("Add Base Vertex"))
{
AddBaseVertex(tar);
}
if (tar.baseVertices.Length > 3 && GUILayout.Button("Remove Base Vertex"))
{
RemoveBaseVertex(tar);
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.Separator();
tar.resolution = EditorGUILayout.IntField("Texture Resolution", tar.resolution);
tar.addCollider = EditorGUILayout.Toggle("Add Collider", tar.addCollider);
tar.height = EditorGUILayout.FloatField("Height", tar.height);
tar.windowWidth = EditorGUILayout.FloatField("Window Width", tar.windowWidth);
tar.windowHeight = EditorGUILayout.FloatField("Window Height", tar.windowHeight);
tar.floorSpace = EditorGUILayout.FloatField("Space Between Floors", tar.floorSpace);
tar.windowSpace = EditorGUILayout.FloatField("Space Between Windows", tar.windowSpace);
tar.windowType = (WindowType)EditorGUILayout.EnumPopup("Window Type", tar.windowType);
tar.roofType = (RoofType)EditorGUILayout.EnumPopup("Roof Type", tar.roofType);
if (tar.roofType == RoofType.Slanted)
{
tar.roofSlant = EditorGUILayout.FloatField("Roof Slant Height", tar.roofSlant);
tar.roofPeak = (Direction)EditorGUILayout.EnumPopup("Roof Peak", tar.roofPeak);
tar.slantRoofBorder = EditorGUILayout.FloatField("Slant Roof Border", tar.slantRoofBorder);
tar.slantWallColor = EditorGUILayout.ColorField("Slant Wall Color", tar.slantWallColor);
}
else if (tar.roofType == RoofType.Indented)
{
tar.indentedRoofHeight = EditorGUILayout.FloatField("Indented Roof Height", tar.indentedRoofHeight);
tar.indent = EditorGUILayout.FloatField("Indent", tar.indent);
}
EditorGUILayout.Separator();
EditorGUILayout.LabelField("Colors", EditorStyles.boldLabel);
tar.windowColor = EditorGUILayout.ColorField("Windows", tar.windowColor);
tar.roofColor = EditorGUILayout.ColorField("Roof", tar.roofColor);
tar.windowDividerColor = EditorGUILayout.ColorField("Window Dividers", tar.windowDividerColor);
tar.storyDividerColor = EditorGUILayout.ColorField("Story Dividers", tar.storyDividerColor);
tar.cornerColor = EditorGUILayout.ColorField("Corners", tar.cornerColor);
EditorGUI.EndChangeCheck();
Undo.RecordObject(tar, "Modified Skyscraper");
EditorGUILayout.Separator();
if (GUILayout.Button("Generate"))
{
GenerateAndSave(tar);
}
}
internal bool WinCriteriaMet(Skyscraper skyscraper)
{
return(skyscraper.Elevators.Sum(e => e.UnloadedCount) >= NumberOfPassengers);
}
