private void AddRoom(RoomModule r)
{
Rooms.Add(r);
GenerationRooms.Add(r);
Rooms.Where(room => !r.Neighbors.ContainsKey((Vector)room.Rect.Location)).ToList()
.ForEach(room =>
{
double distance = Math.Abs(Vector
.Subtract((Vector)room.Rect.Location, (Vector)r.Rect.Location).Length);
if (distance <= GeneratorExtensions.MaxRoomSize * 2f + GeneratorExtensions.SpaceBetweenRooms)
{
r.Neighbors.Add((Vector)room.Rect.Location, room);
r.CalculateRemainingAngles(r.CalculateAngle(room));
if (!room.Neighbors.ContainsKey((Vector)r.Rect.Location))
{
room.Neighbors.Add((Vector)r.Rect.Location, r);
room.CalculateRemainingAngles(room.CalculateAngle(r));
}
}
});
r.Tiles.Where(tile => !Tiles.ContainsKey(tile.Key)).ToList().ForEach(tile => Tiles.Add(tile.Key, tile.Value));
_nrOfUsedtiles += r.Tiles.Count;
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
NinjectModule clientModule = new ClientModule();
NinjectModule usertModule = new UserModule();
NinjectModule categoryModule = new CategoryModule();
NinjectModule priceCategoryModule = new PriceCategoryModule();
NinjectModule roomModule = new RoomModule();
NinjectModule reservationModule = new ReservationModule();
NinjectModule dependencyModule = new DependencyModule("HotelModel");
var kernel = new StandardKernel(dependencyModule, usertModule, clientModule,
categoryModule, priceCategoryModule, roomModule, reservationModule);
DependencyResolver.SetResolver(new NinjectDependencyResolver(kernel));
ControllerBuilder.Current.SetControllerFactory(new NinjectControllerFactory(kernel));
//var kernel = new StandardKernel(clientModule, usertModule, categoryModule,
// priceCategoryModule, roomModule, reservationModule, dependencyModule);
//kernel.Bind<DefaultFilterProviders>().ToSelf().WithConstructorArgument(GlobalConfiguration.Configuration.Services.GetFilterProviders());
//kernel.Bind<DefaultModelValidatorProviders>().ToConstant(new DefaultModelValidatorProviders(GlobalConfiguration.Configuration.Services.GetModelValidatorProviders()));
//GlobalConfiguration.Configuration.DependencyResolver = new Ninject.Web.WebApi.NinjectDependencyResolver(kernel);
}
public void GenerateFromSeed(string _jsonSeed)
{
ResetWorld();
SerializedWorld sWorld = JsonUtility.FromJson <SerializedWorld>(_jsonSeed);
foreach (SerializedModule sMod in sWorld.modules)
{
RoomModule newModule = Instantiate(GetSpecificModule(sMod.code), sMod.position, Quaternion.Euler(0, sMod.rotation, 0), transform).GetComponent <RoomModule>();
newModule.gameObject.SetActive(true);
m_spawnedModules.Add(newModule);
m_roomCount++;
newModule.SetId(m_roomCount);
newModule.gameObject.name = ("Room " + m_roomCount + " : " + newModule.moduleCode);
}
for (int m = 0; m < m_spawnedModules.Count; m++)
{
for (int c = 0; c < m_spawnedModules[m].connectors.Count; c++)
{
if (m_spawnedModules[m].connectors[c].linkedModule == null)
{
m_spawnedModules[m].connectors[c].parentModule = m_spawnedModules[m];
m_spawnedModules[m].connectors[c].UniqueId = sWorld.modules[m].connections[c].uniqueId;
m_spawnedModules[m].connectors[c].LinkedUniqueId = sWorld.modules[m].connections[c].linkedUniqueId;
LinkModules(GetConnectorFromId(m_spawnedModules[m].connectors[c].UniqueId), GetConnectorFromId(m_spawnedModules[m].connectors[c].LinkedUniqueId));
}
}
}
timeUi.text = "Time : 0";
genUi.text = "Generation : " + m_currentAttempts;
modulesUi.text = "Modules : " + m_spawnedModules.Count;
Debug.Log("SPAWNED WORLD FROM SEED");
}
public void CreateWorldSeed()
{
if (m_spawnedModules.Count >= 1)
{
SerializedWorld sWorld = new SerializedWorld();
sWorld.modules = new SerializedModule[m_spawnedModules.Count];
for (int m = 0; m < m_spawnedModules.Count; m++)
{
SerializedModule sMod = new SerializedModule();
RoomModule mod = m_spawnedModules[m];
sMod.id = mod.GetId();
sMod.code = mod.moduleCode;
sMod.position = mod.transform.position;
sMod.rotation = Mathf.RoundToInt(mod.transform.eulerAngles.y);
sMod.connectedModuleId = new int[mod.connectors.Count];
sMod.connectedModuleCodes = new string[mod.connectors.Count];
sMod.connections = new SerializedConnector[mod.connectors.Count];
for (int c = 0; c < mod.connectors.Count; c++)
{
sMod.connectedModuleId[c] = mod.connectors[c].linkedModule.GetId();
sMod.connectedModuleCodes[c] = mod.connectors[c].linkedModule.moduleCode;
sMod.connections[c] = new SerializedConnector(mod.connectors[c].UniqueId, mod.connectors[c].LinkedUniqueId);
}
sWorld.modules[m] = sMod;
}
string jsonWorld = JsonUtility.ToJson(sWorld);
worldSeed = jsonWorld;
Debug.Log("CREATED WORLD SEED : " + jsonWorld);
}
}
private void generateDungeon()
{
DungeonGenerator.DGresult dungeon = demoDungeon;
if (dungeon.rooms.Count == 0)
{
Debug.Log("No room on generated dungeon");
return;
}
foreach (DungeonGenerator.DGresult.Room DGroom in dungeon.rooms)
{
GameObject roomObject = Instantiate(roomPrefab, (Vector3Int)DGroom.position, Quaternion.Euler(0, 0, 0));
RoomModule roomModule = roomObject.GetComponent <RoomModule>();
roomObject.transform.parent = transform;
roomModule.roomProperties = DGroom.properties;
roomModule.dungeonAsset = dungeonAsset;
roomModule.roomEnemies = new RoomEnemies();
roomModule.roomEnemies.enemyWaves = new List <List <GameObject> >();
roomModule.roomEnemies.enemyWaves.Add(new List <GameObject> {
dungeonAsset.enemies[0]
});
roomModules.Add(roomModule);
}
roomModules.ForEach(room => { room.generateBasicRoom(); });
astar.enabled = true;
astar.Scan();
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
RoomModule mod = (RoomModule)target;
if (GUILayout.Button("Set Up"))
{
mod.SetUp();
}
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
NinjectModule guestModule = new GuestModule();
NinjectModule roomModule = new RoomModule();
NinjectModule categoryModule = new CategoryModule();
NinjectModule bookingModule = new BookingModule();
NinjectModule dependencyModule = new DependencyModule("HotelModel");
var kernel = new StandardKernel(guestModule, roomModule, categoryModule, bookingModule, dependencyModule);
kernel.Bind <DefaultFilterProviders>().ToSelf().WithConstructorArgument(GlobalConfiguration.Configuration.Services.GetFilterProviders());
kernel.Bind <DefaultModelValidatorProviders>().ToConstant(new DefaultModelValidatorProviders(GlobalConfiguration.Configuration.Services.GetModelValidatorProviders()));
GlobalConfiguration.Configuration.DependencyResolver = new Ninject.Web.WebApi.NinjectDependencyResolver(kernel);
}
private void MakeRoom <T>(RoomModule module)
where T : RoomModule
{
var controller = MakeController <RoomController, RoomModule>(module);
var hotspots = Substitute.For <HotspotsController>();
var hotspotsBuffer = new Dictionary <Color, Hotspot>();
hotspots[Arg.Any <Color>()].Returns(x =>
{
if (!hotspotsBuffer.ContainsKey(x.Arg <Color>()))
{
hotspotsBuffer[x.Arg <Color>()] = Substitute.For <Hotspot>();
}
return(hotspotsBuffer[x.Arg <Color>()]);
});
controller.Hotspots.Returns(hotspots);
CampaignController.GetRoom <T>().Returns(controller);
}
public void Generate(Vector Size)
{
Rooms = new List <RoomModule>();
GenerationRooms = new List <RoomModule>();
Tiles = new Dictionary <Vector, Tile>();
_nrOfUsedtiles = 0;
Random rnd = new Random();
System.Windows.Point startingPos = new System.Windows.Point((int)(MapWindow.BackgroundCanvas.Width / (2 * Constants.TilePx)), (int)(MapWindow.BackgroundCanvas.Height / (2 * Constants.TilePx)));
bool firstRoom = true;
while ((GenerationRooms.Count > 0 || firstRoom == true) && _nrOfUsedtiles < Size.X * Size.Y)
{
if (firstRoom)
{
int size = (GeneratorExtensions.MaxRoomSize + GeneratorExtensions.MinRoomSize) / 2;
RoomModule r = new RoomModule(new Rect(startingPos, new Size(size, size)));
AddRoom(r);
firstRoom = false;
}
else
{
int index = rnd.Next(0, GenerationRooms.Count);
Rect r = GenerationRooms[index].CheckForSpace();
if (!r.IsEmpty)
{
AddRoom(new RoomModule(r));
}
else
{
GenerationRooms.RemoveAt(index);
}
}
}
GenerateRoads(45);
}
public void LoadModulesFromChildren()
{
m_totalRarity = 0;
int childCount = transform.childCount;
loadedModules = new RoomModule[childCount];
for (int i = 0; i < childCount; i++)
{
loadedModules[i] = transform.GetChild(i).GetComponent <RoomModule>();
}
if (!startModule)
{
startModule = loadedModules[0];
}
foreach (RoomModule mod in loadedModules)
{
mod.SetRarityMinMax(m_totalRarity);
m_totalRarity += mod.abundance;
}
Debug.Log("Loaded " + loadedModules.Length + " modules, total rarity " + m_totalRarity + "!");
}
private bool TestSafeBox(RoomModule _module)
{
RaycastHit hit;
Ray ray;
LayerMask mask = LayerMask.GetMask("World");
for (int i = 0; i < _module.raycastCheckers.Count; i++)
{
ray = new Ray(_module.raycastCheckers[i].position, Vector3.down);
Physics.Raycast(ray, out hit, 50f, mask, QueryTriggerInteraction.UseGlobal);
if (hit.collider)
{
if (hit.collider.gameObject != _module.gameObject)
{
return(false);
}
}
}
return(true);
}
public static Rect CheckForSpace(this RoomModule roomModule)
{
Vector pointer = new Vector(0, 1);
//Random rnd = new Random(Guid.NewGuid().GetHashCode());
List <Rect> allRects = new List <Rect>();
roomModule.AvailableAngles.ForEach(angle =>
{
if (angle.X > angle.Y)
{
double angleY = angle.X;
angle.X = angle.Y;
angle.Y = angleY;
}
List <Rect> rects = new List <Rect>();
List <int> angles = Range((int)angle.X, (int)angle.Y - (int)angle.X).GroupBy(v => v % 20).Take(1).SelectMany(v => v).Where(v => v > angle.X && v < angle.Y).ToList();
//.SelectMany(v => v).Where(v => v > angle.X && v < angle.Y).ToList();
angles.ForEach(eachAngle =>
{
Vector point = pointer.Rotate(eachAngle) * (MaxRoomSize / 2f + roomModule.Rect.Width / 2f + Random.Next(3, SpaceBetweenRooms));
point = new Vector((int)point.X, (int)point.Y) + (Vector)roomModule.Rect.Location;
if (!MapWindow.MapBasicInfo.Rect.Contains((System.Windows.Point)point))
{
return;
}
for (int i = MaxRoomSize; i >= MinRoomSize; i -= 2)
{
Rect r = new Rect((System.Windows.Point)point, new Size(i, i));
if (!MapWindow.MapBasicInfo.Rect.Contains(r))
{
continue;
}
if (roomModule.Neighbors.Values.All(room => !room.Rect.IntersectsWith(r)))
{
rects.Add(r);
if (i > MinRoomSize)
{
//Range(MinRoomSize,(i)-MinRoomSize).ToList().ForEach(size =>
for (int j = i; j >= MinRoomSize; j -= 2)
{
rects.Add(new Rect((System.Windows.Point)point, new Size(j, j)));
}
}
break;
}
}
});
if (rects.Count > 0)
{
allRects.AddRange(rects);
}
});
if (allRects.Count > 0)
{
return(allRects[Random.Next(0, allRects.Count)]);
}
else
{
return(Rect.Empty);
}
}
private bool GenerateRoad(RoomModule startingRoomModule, RoomModule endingRoomModule)
{
if (!startingRoomModule.ConnectedRoomModules.Contains(endingRoomModule))
{
startingRoomModule.ConnectedRoomModules.Add(endingRoomModule);
}
if (!endingRoomModule.ConnectedRoomModules.Contains(startingRoomModule))
{
endingRoomModule.ConnectedRoomModules.Add(startingRoomModule);
}
List <RoomModule> rooms = new List <RoomModule> {
startingRoomModule, endingRoomModule
};
List <Rect> roadRects = new List <Rect>();
if (Math.Abs(startingRoomModule.Rect.LocationCenter().X -
endingRoomModule.Rect.LocationCenter().X) <=
Math.Abs(startingRoomModule.Rect.LocationCenter().Y -
endingRoomModule.Rect.LocationCenter().Y))
{
Point roadPosition =
(Point)((startingRoomModule.Rect.LocationCenter() +
endingRoomModule.Rect.LocationCenter()) /
2f);
Size roadSize = new Size(3, 2 + Math.Abs(startingRoomModule.Rect.LocationCenter().Y - endingRoomModule.Rect.LocationCenter().Y));
roadSize = new Size((int)roadSize.Width, (int)roadSize.Height);
roadPosition = (Point)((Vector)roadPosition - (Vector)roadSize / 2f);
roadPosition = new Point((int)roadPosition.X, (int)roadPosition.Y);
Rect roadRect = new Rect(roadPosition, roadSize);
roadRects.Add(roadRect);
//RoomModule road = new RoomModule(roadRect);
//AddRoad(road);
//check edges for edginess
List <Vector> roadPoints = new List <Vector>
{
new Vector((int)roadRect.LocationCenter().X, (int)roadRect.Top + 2),
new Vector((int)roadRect.LocationCenter().X, (int)roadRect.Bottom - 1)
};
roadPoints.ForEach(point =>
{
RoomModule minRoomModule = rooms.Count == 2 ? rooms.First(room =>
Math.Abs(Math.Abs((room.Rect.LocationCenter() - point).Length) -
rooms.Min(v => Math.Abs((v.Rect.LocationCenter() - point).Length))) < 0.1f) : Rooms.First();
//rooms.Remove(minRoomModule);
Vector roadSecondaryPosition = point;
double xPos = (point.X + minRoomModule.Rect.LocationCenter().X) / 2f;
Size roadSecondarySize =
new Size(Math.Abs(point.X - minRoomModule.Rect.LocationCenter().X) + 2, 3);
if (point.X >= minRoomModule.Rect.Right - 1)
{
roadSecondarySize.Width++;
}
roadSecondarySize = new Size((int)roadSecondarySize.Width, (int)roadSecondarySize.Height);
roadSecondaryPosition = new Vector(Math.Round(xPos), (int)roadSecondaryPosition.Y);
roadSecondaryPosition = roadSecondaryPosition - (Vector)roadSecondarySize / 2f;
roadSecondaryPosition = new Vector((int)roadSecondaryPosition.X, (int)roadSecondaryPosition.Y);
roadSecondarySize = new Size((int)roadSecondarySize.Width, (int)roadSecondarySize.Height);
Rect roadSecondaryRect = new Rect((Point)roadSecondaryPosition, roadSecondarySize);
roadRects.Add(roadSecondaryRect);
//RoomModule roadSecondary = new RoomModule(roadSecondaryRect);
//AddRoad(roadSecondary);
});
}
else
{
//create vertical road
Point roadPosition =
(Point)((startingRoomModule.Rect.LocationCenter() +
endingRoomModule.Rect.LocationCenter()) /
2f);
Size roadSize =
new Size(2 +
Math.Abs(startingRoomModule.Rect.LocationCenter().X -
endingRoomModule.Rect.LocationCenter().X), 3);
roadSize = new Size((int)roadSize.Width, (int)roadSize.Height);
roadPosition = (Point)((Vector)roadPosition - (Vector)roadSize / 2f);
roadPosition = new Point((int)roadPosition.X, (int)roadPosition.Y);
Rect roadRect = new Rect(roadPosition, roadSize);
roadRects.Add(roadRect);
//RoomModule road = new RoomModule(roadRect);
//AddRoad(road);
//check edges for edginess
List <Vector> roadPoints = new List <Vector>
{
new Vector((int)roadRect.Left + 2, (int)roadRect.LocationCenter().Y),
new Vector((int)(roadRect.Right - 1), (int)roadRect.LocationCenter().Y)
};
roadPoints.ForEach(point =>
{
RoomModule minRoomModule = rooms.First(room =>
Math.Abs(Math.Abs((room.Rect.LocationCenter() - point).Length) -
rooms.Min(v => Math.Abs((v.Rect.LocationCenter() - point).Length))) < 0.1f);
Vector roadSecondaryPosition = point;
double yPos = (point.Y + minRoomModule.Rect.LocationCenter().Y) / 2f;
Size roadSecondarySize =
new Size(3, Math.Abs(point.Y - minRoomModule.Rect.LocationCenter().Y) + 2);
if (point.Y >= minRoomModule.Rect.Bottom - 1)
{
roadSecondarySize.Height++;
}
roadSecondarySize = new Size((int)roadSecondarySize.Width, (int)roadSecondarySize.Height);
roadSecondaryPosition = new Vector((int)roadSecondaryPosition.X, Math.Round(yPos));
roadSecondaryPosition = roadSecondaryPosition - (Vector)roadSecondarySize / 2f;
roadSecondaryPosition = new Vector((int)roadSecondaryPosition.X, (int)roadSecondaryPosition.Y);
Rect roadSecondaryRect = new Rect((Point)roadSecondaryPosition, roadSecondarySize);
roadRects.Add(roadSecondaryRect);
//RoomModule roadSecondary = new RoomModule(roadSecondaryRect);
//AddRoad(roadSecondary);
});
}
List <Road> newRoads = AddRoads(roadRects, rooms);
if (newRoads == null)
{
return(false);
}
startingRoomModule.Roads.AddRange(newRoads);
endingRoomModule.Roads.AddRange(newRoads);
return(true);
}
private RoomModule TrySpawnRandomModule(ModuleConnector _connector)
{
m_roomTry = 0;
List <string> excludedCodes = new List <string>();
foreach (RoomModule mod in loadedModules)
{
bool excluded = true;
foreach (string code in _connector.allowedCodesArray)
{
if (mod.moduleCode == code)
{
excluded = false;
}
}
if (excluded)
{
excludedCodes.Add(mod.moduleCode);
}
}
List <string> remainingCodes = new List <string>(_connector.allowedCodesArray);
RoomModule newModule = GameObject.Instantiate(GetRandomModuleExcluding(_connector, excludedCodes), transform).GetComponent <RoomModule>();
bool ready = false;
while (!ready && remainingCodes.Count >= 1 && m_roomTry <= loadedModules.Length)
{
if (newModule.gameObject != null)
{
Destroy(newModule.gameObject);
}
newModule = GameObject.Instantiate(GetRandomModuleExcluding(_connector, excludedCodes), transform).GetComponent <RoomModule>();
AlignConnectors(_connector, newModule.GetEntrance());
if (TestSafeBox(newModule))
{
// MODULE IS GOOD TO GO, SET IT UP
m_roomTry = 0;
remainingCodes = new List <string>();
ready = true;
}
else
{
// MODULE DOESNT FIT, DESTROY IT
remainingCodes.Remove(newModule.moduleCode);
excludedCodes.Add(newModule.moduleCode);
Destroy(newModule.gameObject);
m_roomTry++;
}
}
if (!ready)
{
newModule = GameObject.Instantiate(nullModule, transform).GetComponent <RoomModule>();
AlignConnectors(_connector, newModule.GetEntrance());
}
LinkModules(_connector, newModule.GetEntrance());
newModule.SetId(m_roomCount);
newModule.gameObject.name = ("Room " + m_roomCount + " : " + newModule.moduleCode);
newModule.gameObject.SetActive(true);
m_spawnedModules.Add(newModule);
m_roomCount++;
m_pendingConnections.RemoveAt(0);
foreach (ModuleConnector con in newModule.GetExits())
{
m_pendingConnections.Add(con);
}
m_pendingConnections.Remove(newModule.GetEntrance());
return(newModule);
}
private IEnumerator RegenerateCoroutine()
{
bool success = false;
string failReason = "";
int failReasons = 0;
float startTime = Time.time;
while (!success && (m_currentAttempts <= maximumAttempts || neverStop))
{
success = true;
if (m_spawnedModules.Count >= 1)
{
foreach (RoomModule mod in m_spawnedModules)
{
GameObject.Destroy(mod.gameObject);
}
}
m_spawnedModules = new List <RoomModule>();
m_roomCount = 0;
m_roomTry = 0;
RoomModule startingModule = Instantiate(startModule, transform.position, transform.rotation).GetComponent <RoomModule>();
startingModule.gameObject.SetActive(true);
m_spawnedModules.Add(startingModule);
m_pendingConnections = new List <ModuleConnector>(startingModule.GetExits());
switch (generationRules.generationMethod)
{
case GenerationMethod.original:
{
while (m_pendingConnections.Count >= 1 && m_roomCount <= generationRules.maximumRooms)
{
if (m_pendingConnections[0] != null)
{
RoomModule newModule = TrySpawnRandomModule(m_pendingConnections[0]);
}
else
{
Debug.LogWarning("PENDING CONNECTIONS [0] SOMEHOW IS NULL");
m_pendingConnections.RemoveAt(0);
}
timeUi.text = "Time : " + (Time.time - startTime);
modulesUi.text = "Modules : " + m_spawnedModules.Count;
if (visibleIterations)
{
yield return(null);
}
}
}
break;
case GenerationMethod.predictive:
{
}
break;
}
if (m_roomCount <= generationRules.minimumRooms)
{
failReason += ("\nModule count " + m_roomCount + " below minimum of " + generationRules.minimumRooms + ".");
failReasons++;
success = false;
}
if (m_roomCount >= generationRules.maximumRooms)
{
failReason += ("\nModule count " + m_roomCount + " above maximum of " + generationRules.maximumRooms + ".");
failReasons++;
success = false;
}
foreach (ModuleRule rule in generationRules.moduleRules)
{
if (!TestModuleRule(rule))
{
success = false;
failReason += ("\nModule rule '" + rule.moduleCode + "' violated.");
failReasons++;
}
}
if (neverStop)
{
success = false;
}
if (!success && !neverStop && showDebug)
{
if (failReasons >= 2)
{
failReason = "FAIL REASON :\nMultiple Reasons" + failReason;
}
else
{
failReason = "FAIL REASON :" + failReason;
}
Debug.LogWarning(failReason);
failReason = "";
failReasons = 0;
}
m_currentAttempts++;
genUi.text = "Generation : " + m_currentAttempts;
}
GenerateDoorsAndWalls();
timeUi.text = "Time : " + (Time.time - startTime);
genUi.text = "Generation : " + m_currentAttempts;
modulesUi.text = "Modules : " + m_spawnedModules.Count;
Debug.Log("GENERATED WORLD IN " + (Time.time - startTime) + " SECONDS AFTER " + m_currentAttempts + " ATTEMPTS!");
CreateWorldSeed();
StartCoroutine(OnGenerationComplete());
yield return(null);
}
