private bool CollisionCheck(Module newModule, ModuleConnector exit)
{
var bounds = newModule.GetComponentInChildren <Collider>().bounds;
//Make an overlap sphere to get all the nearby Modules
var radius = Mathf.Max(bounds.size.x, bounds.size.z) * 4.0f;
//var drawRadius = Mathf.Max(bounds.size.x, bounds.size.z) * 0.5f;
//DebugDraw.DrawSphere(bounds.center, drawRadius, new Color(0f, .3f, .8f));
Collider[] hitColliders = Physics.OverlapSphere(bounds.center, radius);
var fatherObject = newModule.BaseModuleConnector.transform.parent.gameObject;
//Debug.Log(newModule.gameObject + ": father: " + fatherObject);
foreach (Collider c in hitColliders)
{
var possibleColliderObject = c.transform.parent.gameObject;
if (possibleColliderObject.tag != "Module" || possibleColliderObject == fatherObject || possibleColliderObject == newModule.gameObject)
{
continue;
}
//Debug.Log(newModule.gameObject + ": possible collider: " + possibleColliderObject);
if (bounds.Intersects(c.bounds))
{
//Debug.Log("Collision failed with : " + c.gameObject);
return(false);
}
}
return(true);
}
private GameObject GetRandomModuleExcluding(ModuleConnector _connector, List <string> _excludedCodes)
{
bool foundModule = false;
if (_connector == null)
{
}
int useModId = 0;
bool excluded = false;
int tries = 1;
for (int i = 0; i < generationRules.moduleRules.Count; i++)
{
if (_connector.parentModule.moduleCode == generationRules.moduleRules[i].moduleCode)
{
for (int c = 0; c < generationRules.moduleRules[i].bannedCodesArray.Length; c++)
{
_excludedCodes.Add(generationRules.moduleRules[i].bannedCodesArray[c]);
}
}
}
while (!foundModule && tries <= _excludedCodes.Count)
{
int random = Random.Range(0, m_totalRarity);
for (int i = 0; i < loadedModules.Length; i++)
{
excluded = false;
if (!foundModule)
{
foreach (string code in _excludedCodes)
{
if (loadedModules[i].moduleCode == code)
{
excluded = true;
}
}
if (excluded)
{
}
else if (loadedModules[i].unique)
{
}
else if (random >= loadedModules[i].GetMinRarity() && random <= loadedModules[i].GetMaxRarity())
{
useModId = i;
foundModule = true;
}
}
}
tries++;
}
if (!foundModule)
{
return(GetSpecificModule("straight"));
}
return(loadedModules[useModId].gameObject);
}
private void SetCloseBlock(ModuleConnector CloseConnector, int numberForName)
{
var CloseModule1 = (Module)Instantiate(_CloseModule, MainGameObject.transform);
CloseModule1.name = CloseModule1.name + "_" + numberForName;
var CloseModule1Exits = CloseModule1.GetExits();
var Closeexit1ToMatch = CloseModule1Exits.FirstOrDefault(x => x.IsDefault) ?? GetRandom(CloseModule1Exits);
MatchExits(CloseConnector, Closeexit1ToMatch);
}
private void MatchExits(ModuleConnector oldExit, ModuleConnector newExit)
{
var newModule = newExit.transform.parent;
var forwardVectorToMatch = -oldExit.transform.forward;
var correctiveRotation = Azimuth(forwardVectorToMatch) - Azimuth(newExit.transform.forward);
newModule.RotateAround(newExit.transform.position, Vector3.up, correctiveRotation);
var correctiveTranslation = oldExit.transform.position - newExit.transform.position;
newModule.transform.position += correctiveTranslation;
}
private void DyeModule(ModuleConnector pendingExit, Module newModule)
{
if (pendingExit.transform.parent.gameObject.GetComponent <Module>().Tags[0] == "room") // if the module of the current pending exit is a room
{
newModule.GetComponent <SpriteRenderer>().color = new Color(1f, 0f, 0f); //set the new module corridor to red
}
else if (newModule.gameObject.GetComponent <Module>().Tags[0] == "room") // if the new module is a room
{
pendingExit.transform.parent.gameObject.GetComponent <SpriteRenderer>().color = new Color(1f, 0f, 0f); //set current corridor to red
}
}
private void AlignConnectors(ModuleConnector oldExit, ModuleConnector newExit)
{
Transform newModule = newExit.parentModule.gameObject.transform;
var forwardVectorToMatch = -oldExit.transformPoint.forward;
var correctiveRotation = Azimuth(forwardVectorToMatch) - Azimuth(newExit.transformPoint.forward);
newModule.RotateAround(newExit.transformPoint.position, Vector3.up, correctiveRotation);
var correctiveTranslation = oldExit.transformPoint.position - newExit.transformPoint.position;
newModule.transform.position += correctiveTranslation;
}
private void MatchExits(ModuleConnector oldExit, ModuleConnector newExit) //I did not change name of the variables, but I am using
//right instead of forward
{
var newModule = newExit.transform.parent;
var forwardVectorToMatch = -oldExit.transform.right; //get opposite as old exit's orientation
var correctiveRotation = Azimuth(forwardVectorToMatch) - Azimuth(newExit.transform.right); //use orientations to calculate angle needed
newModule.RotateAround(newExit.transform.position, Vector3.forward, correctiveRotation); //rotate
var correctiveTranslation = oldExit.transform.position - newExit.transform.position; //vector to move
newModule.transform.position += correctiveTranslation;
}
private void MatchExits(ModuleConnector oldExit, ModuleConnector newExit)
{
try {
var newModule = newExit.transform.parent;
var forwardVectorToMatch = -oldExit.transform.forward;
var correctiveRotation = Helper.Azimuth(forwardVectorToMatch) - Helper.Azimuth(newExit.transform.forward);
newModule.RotateAround(newExit.transform.position, Vector3.up, correctiveRotation);
var correctiveTranslation = oldExit.transform.position - newExit.transform.position;
newModule.transform.position += correctiveTranslation;
} catch (MissingReferenceException e) {
Debug.LogError("Missing Ref catched: " + e.Message);
}
}
private void SealExitWithADoor(ModuleConnector baseExit)
{
//Debug.Log("Couldn't find any possible combination. Sealing off the exit with a door");
var newModule = ProBuilder.Instantiate(DoorPrefab.gameObject, Vector3.zero, Quaternion.identity).GetComponent <Module>();
newModule.transform.parent = DungeonGameObject.transform;
var doorExit = newModule.GetExits()[0];
MatchExits(baseExit, doorExit);
baseExit.ConnectWith(doorExit);
doorExit.ConnectWith(baseExit);
}
private void MatchExits(ModuleConnector oldExit, ModuleConnector newExit)
{
var newModule = newExit.transform.parent;
var forwardVectorToMatch = -oldExit.transform.forward;
//corr z & y axis rot
var correctiveRotation = Azimuth(forwardVectorToMatch) - Azimuth(newExit.transform.forward);
newModule.RotateAround(newExit.transform.position, Vector3.up, correctiveRotation);
//get the trans required for exit to meet
var correctiveTranslation = oldExit.transform.position - newExit.transform.position;
//move it so they meet
newModule.transform.position += correctiveTranslation;
}
private void buildDeadendOutOfCurrentRoom(ModuleConnector currentModuleConnector)
{
Module moduleToChange = currentModuleConnector.transform.parent.GetComponent <Module>();
var exitsToMatch = moduleToChange.GetExits().Where(e => e.IsMatched()).ToArray();
var exitToMatch = Helper.GetRandom <ModuleConnector>(exitsToMatch);
bool matched = FindMatchingModuleWithExits(exitsToMatch.Count(), exitToMatch.getOtherSide(), moduleToChange);
if (matched)
{
moduleToChange.gameObject.SetActive(false);
//Destroy(moduleToChange.gameObject);
}
else
{
Debug.LogError("No DeadendMatch!");
}
}
private void LinkModules(ModuleConnector _a, ModuleConnector _b)
{
if (_a != null && _b != null)
{
_a.UniqueId = StaticMethods.GetUniqueInt();
_b.UniqueId = StaticMethods.GetUniqueInt();
_a.linkedModule = _b.parentModule;
_b.linkedModule = _a.parentModule;
_a.LinkedUniqueId = _b.UniqueId;
_b.LinkedUniqueId = _a.UniqueId;
Debug.LogWarning("LINKED MODULES : " + _a.UniqueId + ", " + _b.UniqueId);
}
else
{
Debug.LogWarning("COULD NOT LINK MODULES : " + _a.UniqueId + ", " + _b.UniqueId);
}
}
private bool checkIfExitsFitDirectly(ModuleConnector currentModuleConnector, Module collidingModule)
{
var possibleExits = collidingModule.GetExits();
foreach (ModuleConnector exit in possibleExits)
{
if (exit.transform.position.Equals(currentModuleConnector.transform.position))
{
exit.setOtherSide(currentModuleConnector);
currentModuleConnector.setOtherSide(exit);
exit.SetMatched(true);
currentModuleConnector.SetMatched(true);
return(true);
}
}
return(false);
}
private void BuildPathEndings()
{
while (pendingExits.Count() > 0)
{
var pendingExit = pendingExits.First();
if (pendingExit.gameObject.activeSelf && pendingExit.transform.parent.gameObject.activeSelf)
{
Module newModulePrefab = GetRandomMatchingTile(pendingExit, true);
var newModule = (Module)Instantiate(newModulePrefab);
newModule.gameObject.name = "Endroom " + CurrentRooms;
ModuleConnector exitToMatch = GetRandomExitWithTag(newModule, pendingExit.GetComponentInParent <Module>().tags);
MatchExits(pendingExit, exitToMatch);
EndRoomCollisionHandling(newModule, pendingExit);
}
pendingExits = pendingExits.Where(e => (!e.IsMatched() || e.getOtherSide() == null) && e.transform.parent.gameObject.activeSelf).ToList();
}
}
private Module GetRandomMatchingTile(ModuleConnector mainExit, bool deadendNeeded)
{
//module tags match at least one exittag and have an exit that matches the current module and modules that match deadendneeded
Debug.Log("MainExit " + mainExit.tag + " of tile " + mainExit.transform.parent.name);
var possibleModules = Modules.Where(e => e.hasTag(mainExit.tags) &&
(e.tags & mainExit.tags) != TileTagsEnum.DeadEnd &&
e.GetComponentsInChildren <ModuleConnector>().
Where(d => d.hasTag(mainExit.GetComponentInParent <Module>().tags) && (d.tags & mainExit.GetComponentInParent <Module>().tags) != TileTagsEnum.DeadEnd).Count() > 0 &&
e.hasTag(TileTagsEnum.DeadEnd) == deadendNeeded);
if (possibleModules.Count() > 0)
{
return(Helper.GetRandom <Module>(possibleModules.ToArray()));
}
else
{
return(Helper.GetRandom <Module>(Modules.Where(e => e.hasTag(FALLBACK_TAG) && !e.hasTag(TileTagsEnum.DeadEnd)).ToArray()));
}
}
private void BuildBridgeForFinal(Module finalMain)
{
var finalMainExit = Helper.GetRandom(finalMain.GetExits().Where(e => !e.IsMatched()).ToArray());
ModuleConnector bridgeConnector = Instantiate(finalMainExit);
bridgeConnector.name = "BridgeConnector";
bridgeConnector.transform.parent = finalMainExit.transform.parent;
bridgeConnector.transform.SetPositionAndRotation(finalMainExit.transform.position, finalMainExit.transform.rotation);
bridgeConnector.tags = TileTagsEnum.Entrance;
var bridgePrefab = GetRandomMatchingTile(bridgeConnector, false);
var bridgeModule = (Module)Instantiate(bridgePrefab);
bridgeModule.gameObject.name = "FinalBridge";
bridgeConnector.gameObject.SetActive(false);
var bridgeModuleExitToMatch = GetRandomExitWithTag(bridgeModule, finalMainExit.GetComponentInParent <Module>().tags);
MatchExits(finalMainExit, bridgeModuleExitToMatch);
if (CollisionDetection(bridgeModule, finalMainExit.GetComponentInParent <Module>()))
{
bridgeModule.gameObject.SetActive(false);
Debug.Log("Gameobject " + bridgeModule.name + " disabled");
Destroy(bridgeModule.gameObject);
bridgeModule = null;
Destroy(bridgeConnector.gameObject);
BuildBridgeForFinal(finalMain);
}
else
{
finalMainExit.SetMatched(true);
finalMainExit.setOtherSide(bridgeModuleExitToMatch);
bridgeModuleExitToMatch.SetMatched(true);
bridgeModuleExitToMatch.setOtherSide(finalMainExit);
mainPath.Add(bridgeModule);
bridgeModule.transform.parent = moduleHolder.transform;
pendingExits.AddRange(finalMain.GetExits().Where(e => !e.IsMatched()));
CurrentRooms++;
}
}
private void EnforceSingleEntrance()
{
if (m_singleEntranceEnforced)
{
return;
}
for (int i = 0; i < connectors.Count; i++)
{
if (connectors[i].isEntrance)
{
if (!m_singleEntranceEnforced)
{
m_entranceConnector = connectors[i];
}
else
{
connectors[i].isEntrance = false;
}
m_singleEntranceEnforced = true;
}
}
m_singleEntranceEnforced = true;
}
private void HandleMovement()
{
float h = CrossPlatformInputManager.GetAxis("Horizontal");
float v = CrossPlatformInputManager.GetAxis("Vertical");
if (h != 0 || v != 0 || voiceMovement)
{
var forwardVectorToMatch = currentModule.transform.forward;
var camForward = Vector3.Scale(Camera.main.transform.forward, new Vector3(1, 0, 1)).normalized;
var correctiveRotation = Helper.Azimuth(forwardVectorToMatch) - Helper.Azimuth(camForward);
Debug.Log("RotationTile: " + forwardVectorToMatch + ", Rotation Cam: " + Camera.main.transform.forward + ",Correction: " + correctiveRotation);
ModuleConnector agentDestinationModuleConnector = null;
switch (Convert.ToInt32(correctiveRotation))
{
case 0:
Debug.Log("Rotation 0 Case");
if (h < 0 || voiceDirection == VoiceDirection.LEFT)
{
agentDestinationModuleConnector = Helper.FindComponentInChildWithTag <ModuleConnector>(currentModule.gameObject, "left");
}
else if (h > 0 || voiceDirection == VoiceDirection.RIGHT)
{
agentDestinationModuleConnector = Helper.FindComponentInChildWithTag <ModuleConnector>(currentModule.gameObject, "right");
}
else if (v < 0 || voiceDirection == VoiceDirection.BACKWARD)
{
agentDestinationModuleConnector = Helper.FindComponentInChildWithTag <ModuleConnector>(currentModule.gameObject, "back");
}
else if (v > 0 || voiceDirection == VoiceDirection.FORWARD)
{
agentDestinationModuleConnector = Helper.FindComponentInChildWithTag <ModuleConnector>(currentModule.gameObject, "front");
}
break;
case 90:
Debug.Log("Rotation 90 Case");
if (h < 0 || voiceDirection == VoiceDirection.LEFT)
{
agentDestinationModuleConnector = Helper.FindComponentInChildWithTag <ModuleConnector>(currentModule.gameObject, "back");
}
else if (h > 0 || voiceDirection == VoiceDirection.RIGHT)
{
agentDestinationModuleConnector = Helper.FindComponentInChildWithTag <ModuleConnector>(currentModule.gameObject, "front");
}
else if (v < 0 || voiceDirection == VoiceDirection.BACKWARD)
{
agentDestinationModuleConnector = Helper.FindComponentInChildWithTag <ModuleConnector>(currentModule.gameObject, "right");
}
else if (v > 0 || voiceDirection == VoiceDirection.FORWARD)
{
agentDestinationModuleConnector = Helper.FindComponentInChildWithTag <ModuleConnector>(currentModule.gameObject, "left");
}
break;
case -90:
Debug.Log("Rotation -90 Case");
if (h < 0 || voiceDirection == VoiceDirection.LEFT)
{
agentDestinationModuleConnector = Helper.FindComponentInChildWithTag <ModuleConnector>(currentModule.gameObject, "front");
}
else if (h > 0 || voiceDirection == VoiceDirection.RIGHT)
{
agentDestinationModuleConnector = Helper.FindComponentInChildWithTag <ModuleConnector>(currentModule.gameObject, "back");
}
else if (v < 0 || voiceDirection == VoiceDirection.BACKWARD)
{
agentDestinationModuleConnector = Helper.FindComponentInChildWithTag <ModuleConnector>(currentModule.gameObject, "left");
}
else if (v > 0 || voiceDirection == VoiceDirection.FORWARD)
{
agentDestinationModuleConnector = Helper.FindComponentInChildWithTag <ModuleConnector>(currentModule.gameObject, "right");
}
break;
case 180:
Debug.Log("Rotation 180 Case");
if (h < 0 || voiceDirection == VoiceDirection.LEFT)
{
agentDestinationModuleConnector = Helper.FindComponentInChildWithTag <ModuleConnector>(currentModule.gameObject, "right");
}
else if (h > 0 || voiceDirection == VoiceDirection.RIGHT)
{
agentDestinationModuleConnector = Helper.FindComponentInChildWithTag <ModuleConnector>(currentModule.gameObject, "left");
}
else if (v < 0 || voiceDirection == VoiceDirection.BACKWARD)
{
agentDestinationModuleConnector = Helper.FindComponentInChildWithTag <ModuleConnector>(currentModule.gameObject, "front");
}
else if (v > 0 || voiceDirection == VoiceDirection.FORWARD)
{
agentDestinationModuleConnector = Helper.FindComponentInChildWithTag <ModuleConnector>(currentModule.gameObject, "back");
}
break;
default:
Debug.Log("no matching rotation for movement: " + Convert.ToInt32(correctiveRotation));
break;
}
if (agentDestinationModuleConnector != null && agentDestinationModuleConnector.getOtherSide() != null || voiceMovement)
{
voiceMovement = false;
voiceDirection = VoiceDirection.NONE;
agent.SetTarget(Helper.FindComponentInChildWithTag <Transform>(agentDestinationModuleConnector.getOtherSide().GetComponentInParent <Module>().gameObject, "movePoint").transform);
}
}
}
/**
* The only scenario where CreateNewModule would return false, is if there was no way to generate a module, so we have to seal it off with a door
*/
private bool CreateNewModule(ModuleConnector baseExit, List <GameObject> availableModulePrefabs, List <ModuleConnector> newExits, out GameObject moduleGameObject)
{
bool foundExit = false;
bool foundModule = false;
ModuleConnector newModuleExit = null;
ModuleConnector[] newModuleExits = null;
moduleGameObject = null;
Module newModule = null;
foreach (var newModulePrefab in availableModulePrefabs)
{
//Create the new module prefab
newModule = ProBuilder.Instantiate(newModulePrefab, Vector3.zero, Quaternion.identity).GetComponent <Module>();
newModule.transform.parent = DungeonGameObject.transform;
newModuleExits = newModule.GetExits();
Util.ShuffleArray(newModuleExits);
for (var i = 0; i < newModuleExits.Count(); i++)
{
newModuleExit = newModuleExits[i];
//Match the exits
MatchExits(baseExit, newModuleExit);
//Letting a full frame go by so we can do a collision check
if (CollisionCheck(newModule, baseExit))
{
foundModule = true;
foundExit = true;
break;
}
}
//We've tried every exit combination with this module, get a new module
if (!foundExit)
{
Destroy(newModule.gameObject);
continue;
}
//if we've reached here, we have found a suitable exit with a suitable module, or we have not found anything suitable.
break;
}
//We haven't found anything useful. Just make a door, and find another baseModuleExit
if (!foundModule)
{
return(false);
}
//the new module was received. All is good. Connect with the base module exit. Find another baseModuleExit to connect with
baseExit.ConnectWith(newModuleExit);
newModuleExit.ConnectWith(baseExit);
if (newExits != null)
{
newExits.AddRange(newModuleExits.Where(e => e != newModuleExit));
}
CameraPortal cameraPortal = (CameraPortal)newModule.gameObject.GetComponentInChildren(typeof(CameraPortal));
if (cameraPortal != null)
{
Portals.Add(cameraPortal);
}
moduleGameObject = newModule.gameObject;
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 GameObject GetRandomModule(ModuleConnector _connector)
{
return(GetRandomModuleExcluding(_connector, new List <string>()));
}
public void ConnectWith(ModuleConnector neighborConnection)
{
NeighborConnection = neighborConnection;
}
private void StartCreate()
{
DataBoundsList = new List <DataStruct>();
var startModule = (Module)Instantiate(_StartModule, transform.position, transform.rotation, MainGameObject.transform);
AddBound(startModule.GetComponent <BoxCollider>().bounds, startModule.name);
var pendingExits = new List <ModuleConnector>(startModule.GetExits());
List <ModuleConnector> globalExits = new List <ModuleConnector>(pendingExits);
int i = 0;
for (int iteration = 0; iteration < _Iterations; iteration++)
{
var newExits = new List <ModuleConnector>();
foreach (var pendingExit in pendingExits)
{
//ModuleConnector lastconnector = new ModuleConnector();
bool found = false;
List <string> pendingExitList = pendingExit.Tags.ToList();
while (pendingExitList.Count > 0 && !found)
{
found = false;
string newTag = GetRandom(pendingExitList);
List <Module> modulesForTag = _Modules.Where(m => m.Tags.Contains(newTag)).ToList();
while (modulesForTag.Count > 0 && !found)
{
Module newModulePref = GetRandom(modulesForTag);
Module newModule = (Module)Instantiate(newModulePref, MainGameObject.transform);
newModule.name = newModule.name + "_" + ++i;
List <ModuleConnector> connectorsInModule = newModule.GetExits().ToList();
while (connectorsInModule.Count > 0 && !found)
{
ModuleConnector connector = connectorsInModule.FirstOrDefault(x => x.IsDefault) ?? GetRandom(connectorsInModule);
MatchExits(pendingExit, connector);
if (!checkBoundData(newModule.GetComponent <BoxCollider>().bounds, newModule.name))
{
Debug.Log("intersect");
//if setting fails remove block from random list. TODO :)
connectorsInModule.Remove(connector);
//when nothing found add to globalexits for block and smoothing
//lastconnector = connector;
}
else
{
connector.ConnectedConnector = pendingExit;
pendingExit.ConnectedConnector = connector;
//remove pendingExit from global one if fits
globalExits.Remove(pendingExit);
newExits.AddRange(newModule.GetExits().ToList().Where(e => e != connector));
found = true;
}
}
if (!found)
{
Destroy(newModule.gameObject);
modulesForTag.Remove(newModulePref);
}
}
if (!found)
{
pendingExitList.Remove(newTag);
}
}
}
globalExits.AddRange(newExits);
pendingExits = newExits;
}
var BossModule = (Module)Instantiate(_BossModule, MainGameObject.transform);
string BossModuleName = BossModule.name;
var BossModuleExits = BossModule.GetExits();
var BossexitToMatch = BossModuleExits.FirstOrDefault(x => x.IsDefault) ?? GetRandom(BossModuleExits);
bool BossRoomSet = false;
List <string> SmoothList = new List <string>(_SmoothModules.ToList());
bool removableLeft = true;
while (removableLeft)
{
removableLeft = false;
for (int j = 0; j < globalExits.Count; j++)
{
ModuleConnector tryExit = globalExits[j];
i++;
//Set BossRoom
if (!BossRoomSet)
{
BossModule.name = BossModuleName + "_" + i;
MatchExits(tryExit, BossexitToMatch);
if (checkBoundData(BossModule.GetComponent <BoxCollider>().bounds, BossModule.name))
{
//RemoveGlobalExits.Add(tryExit);
BossexitToMatch.ConnectedConnector = tryExit;
tryExit.ConnectedConnector = BossexitToMatch;
BossRoomSet = true;
globalExits.Remove(tryExit);
removableLeft = true;
break;
}
}
//Smooth Blocks
GameObject ParentGo = tryExit.transform.parent.gameObject; //for destroy
Module ParentModule = ParentGo.GetComponent <Module>();
List <string> ParentModuleTags = ParentModule.Tags.ToList();
if (ParentModuleTags.Except(SmoothList).ToList().Count <= 0)
{
int connectedConnectors = 0;
ModuleConnector newExit = null;
List <ModuleConnector> connectors = new List <ModuleConnector>(ParentModule.GetExits().ToList());
foreach (ModuleConnector mc in connectors)
{
if (mc != tryExit && mc.ConnectedConnector != null)
{
connectedConnectors++;
newExit = mc.ConnectedConnector;
}
}
if (connectedConnectors == 1)
{
removableLeft = true;
newExit.ConnectedConnector = null;
globalExits.RemoveAll(e => connectors.Contains(e));
globalExits.Add(newExit);
Destroy(ParentGo);
break;
}
}
}
}
//Set Close Blocks
foreach (ModuleConnector tryExit in globalExits)
{
SetCloseBlock(tryExit, i++);
}
}
//BUILD PATHS
private void BuildMainPath()
{
while (mainPath.Count() < genParams.mainPathRooms)
{
if (LastCount == mainPath.Count())
{
timesSameIteration++;
}
else
{
timesSameIteration = 0;
}
if (timesSameIteration >= 5)
{
Backtrack(2);
timesSameIteration = 0;
}
LastCount = mainPath.Count();
var mainExits = mainPath.Last().GetExits();
var mainExitToMatch = Helper.GetRandom(mainPath.Last().GetExits().Where(e => e.IsMatched() != true).ToArray());
var newMainModulePrefab = GetRandomMatchingTile(mainExitToMatch, false);
var newMainModule = (Module)Instantiate(newMainModulePrefab);
newMainModule.gameObject.name = CurrentRooms + "";
var newModuleExitToMatch = GetRandomExitWithTag(newMainModule, mainExitToMatch.GetComponentInParent <Module>().tags);
MatchExits(mainExitToMatch, newModuleExitToMatch);
if (CollisionDetection(newMainModule, mainExitToMatch.GetComponentInParent <Module>()))
{
newMainModule.gameObject.SetActive(false);
Debug.Log("Gameobject " + newMainModule.name + " disabled");
Destroy(newMainModule.gameObject);
newMainModule = null;
}
if (newMainModule != null)
{
mainExitToMatch.SetMatched(true);
mainExitToMatch.setOtherSide(newModuleExitToMatch);
newModuleExitToMatch.SetMatched(true);
newModuleExitToMatch.setOtherSide(mainExitToMatch);
mainPath.Add(newMainModule);
newMainModule.transform.parent = moduleHolder.transform;
pendingExits.AddRange(mainExits.Where(e => !e.IsMatched()));
CurrentRooms++;
}
}
var endModulePrefab = Database.getEndRoom();
var endModule = Instantiate(endModulePrefab);
ModuleConnector finalMainExit = null;
try {
finalMainExit = GetRandomExitWithTag(mainPath.Last(), endModule.tags);
} catch (IndexOutOfRangeException e) {
Debug.LogWarning(e);
BuildBridgeForFinal(mainPath.Last());
finalMainExit = GetRandomExitWithTag(mainPath.Last(), endModule.tags);
}
ModuleConnector finalExitToMatch = GetRandomExitWithTag(endModule, finalMainExit.GetComponentInParent <Module>().tags);
MatchExits(finalMainExit, finalExitToMatch);
endModule.gameObject.name = "Final";
CurrentRooms++;
mainPath.Add(endModule);
if (CollisionDetection(endModule, finalMainExit.GetComponentInParent <Module>()))
{
Backtrack(3);
BuildMainPath();
}
else
{
finalMainExit.SetMatched(true);
finalMainExit.setOtherSide(finalExitToMatch);
finalExitToMatch.SetMatched(true);
finalExitToMatch.setOtherSide(finalMainExit);
endModule.transform.parent = moduleHolder.transform;
pendingExits.AddRange(finalMainExit.GetComponentInParent <Module>().GetExits().Where(e => e.IsMatched() != true));
pendingExits.AddRange(endModule.GetExits().Where(e => e.IsMatched() != true));
}
}
public void setOtherSide(ModuleConnector other)
{
otherSide = other;
ExitMatched = other != null;
}
public void SetBaseModule(ModuleConnector baseModuleConnector)
{
BaseModuleConnector = baseModuleConnector;
}
private bool FindMatchingModuleWithExits(int exits, ModuleConnector exitToMatch, Module otherModule)
{
List <Collider> colliderList = new List <Collider> {
exitToMatch.GetComponentInParent <Module>().GetComponent <BoxCollider>()
};
foreach (ModuleConnector exit in otherModule.GetExits().Where(e => e.IsMatched() && e.getOtherSide() != null))
{
var exitOfModuleToMatch = exit.getOtherSide();
colliderList.Add(exitOfModuleToMatch.
GetComponentInParent <Module>().
GetComponent <BoxCollider>());
}
otherModule.gameObject.SetActive(false);
var possibleModules = Modules.Where(e => e.GetExits().Count() == exits);
List <ModuleConnector> exitsToMatch = new List <ModuleConnector>();
exitsToMatch.Add(exitToMatch);
foreach (ModuleConnector exit in otherModule.GetExits().Where(e => e.IsMatched() && e.getOtherSide() != null))
{
exitsToMatch.Add(exit.getOtherSide());
}
for (int i = 0; i < possibleModules.Count(); i++)
{
int rotations = 0;
Module testedModulePrefab = possibleModules.ElementAt(i);
Module testedModule = Instantiate(testedModulePrefab);
while (rotations < 4)
{
Debug.Log("Testing Module " + testedModule.name + " at " + (90 * rotations) + "°");
var exitsLeftToMatch = exitsToMatch;
foreach (ModuleConnector testedModuleExit in testedModule.GetExits())
{
exitsLeftToMatch = exitsLeftToMatch.Except(exitsLeftToMatch.Where(e => e.transform.forward == -testedModuleExit.transform.forward &&
e.hasTag(testedModule.tags) &&
(e.GetComponentInParent <Module>().tags & testedModuleExit.tags) != TileTagsEnum.DeadEnd &&
(e.tags & testedModule.tags) != TileTagsEnum.DeadEnd &&
testedModuleExit.hasTag(e.GetComponentInParent <Module>().tags))).ToList();
}
if (exitsLeftToMatch.Count() > 0)
{
//Debug.Log(exitsLeftToMatch.Count());
exitsLeftToMatch = exitsToMatch;
testedModule.transform.Rotate(Vector3.up, 90);
rotations++;
}
else
{
var testedModuleExits = testedModule.GetExits();
testedModule.gameObject.transform.position -=
(testedModule.GetExits().First().transform.position -
exitsToMatch.Where(e => e.transform.forward == -testedModuleExits.First().transform.forward).First().transform.position);
exitsToMatch.ForEach(e => e.SetMatched(true));
exitsToMatch.ForEach(e => e.setOtherSide(testedModuleExits.Where(d => - d.transform.forward == e.transform.forward).First()));
testedModuleExits.ToList().
ForEach(e => e.setOtherSide(
exitsToMatch.Where(d => - d.transform.forward == e.transform.forward)
.First()));
testedModuleExits.ToList().ForEach(e => e.SetMatched(true));
allModules.Add(testedModule);
if (mainPath.Contains(otherModule))
{
int index = mainPath.IndexOf(otherModule);
mainPath.Insert(index, testedModule);
}
testedModule.gameObject.name = "Endroom " + CurrentRooms + "(" + otherModule.gameObject.name + ")";
testedModule.gameObject.transform.parent = moduleHolder.transform;
Debug.Log("Matching suceess: " + testedModule.gameObject.name);
return(true);
}
}
Destroy(testedModule.gameObject);
}
return(false);
}
private void EndRoomCollisionHandling(Module newModule, ModuleConnector currentModuleConnector)
{
var newModuleCollider = newModule.GetComponent <BoxCollider>();
var currentModuleCollider = currentModuleConnector.GetComponentInParent <Module>().GetComponent <BoxCollider>();
var possibleCollisions = Physics.OverlapSphere(newModuleCollider.bounds.center, newModuleCollider.bounds.extents.magnitude);
var relevantCollisions = possibleCollisions.Where(e => e != newModuleCollider && e != currentModuleCollider && e.GetComponent <Module>() != null).ToList();
int intersects = 0;
foreach (var collision in relevantCollisions)
{
if (newModuleCollider.bounds.Intersects(collision.bounds))
{
intersects++;
Debug.Log("Relevante Collision für Tile " + newModule.name + ":" + collision.gameObject.name);
}
}
Debug.Log("Relevante Collisions für Anschluss an Tile " + currentModuleConnector.transform.parent.name + ":" + intersects);
if (intersects > 0)
{
var outDistance = 0f;
//float maxDistance = newModuleCollider.bounds.size.z+currentModuleCollider.bounds.extents.z;
//Debug.Log("MaxRayDistance for " + currentModuleCollider.name + ": " + maxDistance);
var modulesInExitDirection = relevantCollisions.Where(e => e.bounds.
IntersectRay(new Ray(currentModuleCollider.bounds.center, currentModuleConnector.transform.forward), out outDistance) &&
outDistance <= 6 &&
newModuleCollider.bounds.Intersects(e.bounds)).ToList();
if (modulesInExitDirection.Count() > 0)
{
if (modulesInExitDirection.Count() > 1)
{
Debug.Log("Need to sort raycast intersects");
var currentModuleConnectorPosition = currentModuleConnector.transform.position;
modulesInExitDirection.ForEach(e => Debug.Log("Intersected Module: " + e.transform.name +
" ; Distance: " + (e.ClosestPoint(currentModuleConnectorPosition) - currentModuleConnectorPosition).magnitude));
modulesInExitDirection
.Sort((e1, e2) => (e1.ClosestPoint(currentModuleConnectorPosition) - currentModuleConnectorPosition).magnitude
.CompareTo((e2.ClosestPoint(currentModuleConnectorPosition) - currentModuleConnectorPosition).magnitude));
}
Module adjacentModule = modulesInExitDirection.First().GetComponentInParent <Module>();
Debug.Log("Colliding Module to work with: " + adjacentModule.name);
int exits = adjacentModule.GetExits().Where(e => e.IsMatched()).Count();
newModule.gameObject.SetActive(false);
Debug.Log("DeadEnd " + newModule.name + " disabled");
Destroy(newModule.gameObject);
bool exitsFit = checkIfExitsFitDirectly(currentModuleConnector, adjacentModule);
bool matched = false;
Debug.Log("Exits to find: " + (exits + 1));
if (!exitsFit && adjacentModule.tag != "immutable")
{
matched = FindMatchingModuleWithExits(exits + 1, currentModuleConnector, adjacentModule);
}
Debug.Log("Endroommatching: " + (matched | exitsFit));
if (matched)
{
adjacentModule.gameObject.SetActive(false);
//Destroy(adjacentModule.gameObject);
}
else
{
Debug.Log("No Match Case");
buildDeadendOutOfCurrentRoom(currentModuleConnector);
adjacentModule.gameObject.SetActive(true);
}
}
else
{
Debug.Log("No Frontal Collision");
newModule.transform.parent = moduleHolder.transform;
allModules.Add(newModule);
currentModuleConnector.SetMatched(true);
var matchedExit = newModule.GetExits().First();
currentModuleConnector.setOtherSide(matchedExit);
matchedExit.SetMatched(true);
matchedExit.setOtherSide(currentModuleConnector);
}
}
else
{
Debug.Log("No Collision");
newModule.transform.parent = moduleHolder.transform;
allModules.Add(newModule);
currentModuleConnector.SetMatched(true);
var matchedExit = newModule.GetExits().First();
currentModuleConnector.setOtherSide(matchedExit);
matchedExit.SetMatched(true);
matchedExit.setOtherSide(currentModuleConnector);
}
//currentModuleConnector.gameObject.SetActive(false);
pendingExits.Remove(currentModuleConnector);
CurrentRooms++;
}
public void GenerateMap()
{
//_surface.UpdateNavMesh(null);
foreach (Transform t in transform)
{
Destroy(t.gameObject);
}
CurrentRooms.Clear();
Module baseRoom = Instantiate(Rooms.GetRandom(), transform);
baseRoom.transform.localPosition = Vector3.zero;
CurrentRooms.Add(baseRoom);
List <Module> currentModules = new List <Module>();
List <Module> nextModules = new List <Module>();
currentModules.Add(baseRoom);
for (int i = 0; i < Iterations; ++i)
{
foreach (Module module in currentModules)
{
foreach (ModuleConnector connector in module.Connectors)
{
if (connector.IsAlreadyUsed)
{
continue;
}
Module tempModule;
connector.IsAlreadyUsed = true;
if (connector.CanConnectTo == ModuleType.Room)
{
tempModule = Rooms.GetRandom();
}
else
{
tempModule = Halls.GetRandom();
}
tempModule = Instantiate(tempModule, transform);
ModuleConnector tempConnector = tempModule.Connectors.Where(x => !x.IsAlreadyUsed).First();
if (tempConnector != null)
{
tempConnector.IsAlreadyUsed = true;
//tempModule.transform.rotation = connector.EntryPoint.rotation;
tempModule.transform.position = connector.EntryPoint.position;
tempModule.transform.position += connector.EntryPoint.position - tempConnector.EntryPoint.position;
float angle = Vector3.SignedAngle(
connector.EntryPoint.forward,
tempConnector.EntryPoint.forward,
Vector3.up
);
tempModule.transform.RotateAround(tempConnector.EntryPoint.position, Vector3.up, 180 - angle);
}
nextModules.Add(tempModule);
}
}
currentModules = new List <Module>(nextModules);
var query = currentModules.Where(x => x.ModuleType == ModuleType.Room).ToList();
CurrentRooms.AddRange(query);
nextModules.Clear();
}
StartCoroutine(WaitToRebuild());
}
