public override void OnRoomListUpdate(List <RoomInfo> roomList)
{
foreach (RoomInfo info in roomList)
{
if (info.RemovedFromList)
{
int indexNumber = roomsList.FindIndex(o => o.roomInfo.Name == info.Name);
if (indexNumber != -1)
{
Destroy(roomsList[indexNumber].gameObject);
roomsList.RemoveAt(indexNumber);
}
}
else
{
int indexNumber = roomsList.FindIndex(o => o.roomInfo.Name == info.Name);
if (indexNumber != -1)
{
Destroy(roomsList[indexNumber].gameObject);
roomsList.RemoveAt(indexNumber);
}
RoomElement element = Instantiate(roomElement, content);
if (info != null)
{
element.SetUpRoomInfo(info);
roomsList.Add(element);
}
}
}
RectTransform rt = content.gameObject.GetComponent <RectTransform>();
rt.sizeDelta = new Vector2(0, roomsList.Count * 90);
}
/*
* void BuildWay(Room room, Vector3 wayPosition)
* {
* GameObject Prefab = (ResourceManager.instance.GetAsset<GameObject>("Prefabs/Way"));
* try
* {
* switch (Mathf.FloorToInt(wayPosition.x))
* {
* case GameConst.Dir_Left:
* {
* int posx = Mathf.FloorToInt(roomBounds.min.x);
* int posy = Mathf.FloorToInt(wayPosition.y);
* for (int i = 0; i < wayPosition.z; i++)
* {
* for (int j = 0; j < GameConst.WayWidth; j++)
* {
* GameObject wayObject = Instantiate(Prefab);
* Way way = wayObject.GetComponent<Way>();
* way.Init(posx - i, posy + j);
* wayList.Add(way);
* }
* }
* }
* break;
* case GameConst.Dir_Right:
* {
* int posx = Mathf.FloorToInt(roomBounds.max.x);
* int posy = Mathf.FloorToInt(wayPosition.y);
* for (int i = 0; i < wayPosition.z; i++)
* {
* for (int j = 0; j < GameConst.WayWidth; j++)
* {
* GameObject wayObject = Instantiate(Prefab);
* Way way = wayObject.GetComponent<Way>();
* way.Init(posx + i, posy + j);
* wayList.Add(way);
* }
* }
* }
* break;
* case GameConst.Dir_Top:
* {
* int posy = Mathf.FloorToInt(roomBounds.max.y);
* int posx = Mathf.FloorToInt(wayPosition.y);
* for (int i = 0; i < wayPosition.z; i++)
* {
* for (int j = 0; j < GameConst.WayWidth; j++)
* {
* GameObject wayObject = Instantiate(Prefab);
* Way way = wayObject.GetComponent<Way>();
* way.Init(posx + j, posy + i);
* wayList.Add(way);
* }
* }
* }
* break;
*
* case GameConst.Dir_Bottom:
* {
* int posy = Mathf.FloorToInt(roomBounds.min.y);
* int posx = Mathf.FloorToInt(wayPosition.y);
* for (int i = 0; i < wayPosition.z; i++)
* {
* for (int j = 0; j < GameConst.WayWidth; j++)
* {
* GameObject wayObject = Instantiate(Prefab);
* Way way = wayObject.GetComponent<Way>();
* way.Init(posx + j, posy - i);
* wayList.Add(way);
* }
* }
* }
* break;
* }
*
* }
* finally
* {
* Prefab = null;
* }
* }
*/
BaseObject FindBlankObject(List <int> list, int exceptx1, int excepty1, int exceptx2, int excepty2)
{
int repeatCount = 10;
while (repeatCount > 0)
{
int index = Mathf.FloorToInt(UnityEngine.Random.value * list.Count);
RoomElement ele = objList[list[index]] as RoomElement;
if (ele.OrnamentId == 0 && ele.Position.x != exceptx1 && ele.Position.y != excepty1 &&
ele.Position.x != exceptx2 && ele.Position.y != excepty2)
{
return(objList[list[index]]);
}
repeatCount--;
}
for (int i = 0; i < list.Count; i++)
{
RoomElement ele = objList[list[i]] as RoomElement;
if (ele.OrnamentId == 0 && ele.Position.x != exceptx1 && ele.Position.y != excepty1 &&
ele.Position.x != exceptx2 && ele.Position.y != excepty2)
{
return(objList[list[i]]);
}
}
return(null);
}
public void RecalculateBounds()
{
int roomElementsCount = roomElements.Count;
for (int i = 0; i < roomElementsCount; i++)
{
RoomElement elements = roomElements[i];
Volume volume = elements.GetComponent <Volume>();
volume.RecalculateBounds();
}
}
public void RecalculateWorldPosition()
{
int roomElementsCount = roomElements.Count;
for (int i = 0; i < roomElementsCount; i++)
{
RoomElement elements = roomElements[i];
Volume volume = elements.GetComponent <Volume>();
volume.RecalculateVoxelsWorldSpace();
}
}
private void InitilizeNewItem(RoomElement item)
{
item.Volume.RecalculateVoxelsWorldSpace();
int itemVoxelsLength = item.Voxels.Length;
for (int i = 0; i < itemVoxelsLength; i++)
{
Voxel itemVoxel = item.Voxels[i];
GameObject itemGO = item.VoxelGOs[i];
Voxel.SetGameObjectName(itemGO, itemVoxel.worldPosition);
acceptedItemVoxels.Add(itemVoxel.worldPosition);
}
}
public override void OnRoomListUpdate(List <RoomInfo> roomList)
{
CleanListRoomElements();
foreach (var room in roomList)
{
if (room.RemovedFromList)
{
continue;
}
RoomElement element = Instantiate(elementPrefab, ListingTransform);
element.SetRoomInfo(room);
listRoomElements.Add(element);
}
}
bool LayoutContainsStart(RoomElement.States roomToCheck)
{
int roomCount = 0;
for (int i = 0; i < layout.Length; i++)
{
if (layout[i].state == roomToCheck)
{
roomCount++;
}
}
if (roomCount == 1)
return true;
return false;
}
void AddOrnamentExcute(RoomElement element, OrnamentTemplate temp)
{
GameObject Prefab = (ResourceManager.instance.GetAsset <GameObject>("Prefabs/Ornament"));
try
{
GameObject ornamentObject = Instantiate(Prefab);
string name = gameObject.name + "Ornament_" + element.Position.x + "_" + element.Position.y;
OrnamentObject ornament = ornamentObject.GetComponent <OrnamentObject>();
ornament.Init(LevelManager.GetElementID(), roomId, name, element.Position.x, element.Position.y, temp);
objList[ornament.ID] = ornament;
ornamentList.Add(ornament.ID);
ornamentDictionary[GetPosKey(Mathf.FloorToInt(element.Position.x), Mathf.FloorToInt(element.Position.y))] = ornament.ID;
element.OrnamentId = ornament.ID;
}
finally
{
Prefab = null;
}
}
public void ButtonAction(RoomElement prefab)
{
Switch(false);
aviableGrid.Clear();
if (prefab.horizontal == true)
{
aviableGrid.AddRange(horizontalAviableGrid);
}
if (prefab.vertical == true)
{
aviableGrid.AddRange(veritcalAviableGrid);
}
Switch(true);
ChangeMaterial(GetGridElements(false), greenMaterial);
canBuild = true;
prefabToBuild = prefab;
}
private void InitDoorsVoxelMap()
{
doorsVoxelMap = new HashSet <Vector3>();
doorsVoxelGoMap = new Dictionary <Vector3, GameObject>();
int doorsCount = doors.Count;
for (int i = 0; i < doorsCount; i++)
{
RoomElement door = doors[i];
Voxel[] doorVoxels = door.Voxels;
GameObject[] doorVoxelGOs = door.VoxelGOs;
int wallsVoxelLength = doorVoxels.Length;
for (int j = 0; j < wallsVoxelLength; j++)
{
Vector3 voxelWorldPosition = doorVoxels[j].worldPosition;
doorsVoxelMap.Add(voxelWorldPosition);
doorsVoxelGoMap.Add(voxelWorldPosition, doorVoxelGOs[j]);
}
}
}
private void InitWallsVoxelMap()
{
wallsVoxelMap = new HashSet <Vector3>();
wallsVoxelGoMap = new Dictionary <Vector3, GameObject>();
int wallsCount = walls.Count;
for (int i = 0; i < wallsCount; i++)
{
RoomElement wall = walls[i];
Voxel[] wallVoxels = wall.Voxels;
GameObject[] wallVoxelGOs = wall.VoxelGOs;
int wallsVoxelLength = wallVoxels.Length;
for (int j = 0; j < wallsVoxelLength; j++)
{
Vector3 voxelWorldPosition = wallVoxels[j].worldPosition;
wallsVoxelMap.Add(voxelWorldPosition);
wallsVoxelGoMap.Add(voxelWorldPosition, wallVoxelGOs[j]);
}
}
}
private void UpdateAviableGrid(RoomElement roomElement)
{
if (roomElement.horizontal == true)
{
foreach (var horizontalGrid in roomElement.GetHorizontalAviableGrid)
{
if (!horizontalAviableGrid.Contains(horizontalGrid))
{
horizontalAviableGrid.Add(horizontalGrid);
}
}
}
if (roomElement.vertical == true)
{
foreach (var verticalGrid in roomElement.GetVerticalAviableGrid)
{
if (!veritcalAviableGrid.Contains(verticalGrid))
{
veritcalAviableGrid.Add(verticalGrid);
}
}
}
}
public void BuildRoomData(int levelId)
{
// generate monster data
m_parentObj = GameObject.Instantiate(CurRoomInfo.m_roomData) as GameObject;
m_parentObj.transform.localPosition = Vector3.zero;
m_parentObj.transform.position = CurRoomInfo.m_roomObj.transform.position;
RoomDataCfg dataCfg = m_parentObj.GetComponent <RoomDataCfg>();
for (int i = 1; i <= dataCfg.MonsterCount; i++)
{
string str;
if (i < 10)
{
str = string.Format("monster0{0}", i);
}
else
{
str = string.Format("monster{0}", i);
}
GameObject obj = m_parentObj.transform.Find(str).gameObject;
RoomElement ele = obj.GetComponent <RoomElement>();
ele.MonsterData = new SM.MonsterRoomData();
ele.MonsterData.monsterId = i;
ele.MonsterData.monsterObjId = ele.ObjSettingID;
if (ele._PatrolList.Count <= 0)
{
ele._PatrolList = dataCfg._GlobalPatrolList;
}
ActorRefresh actor = new ActorRefresh(obj.transform, this);
m_actorRefreshList.Add(actor);
}
//出生点
if (null == CurRoomInfo.m_parent)
{
Transform posTrans = m_parentObj.transform.Find("charPosition");
if (null == posTrans)
{
string objName = "charposition";
GameObject childObj = new GameObject(objName);
childObj.transform.parent = m_parentObj.transform;
childObj.transform.localPosition = new Vector3(CurRoomInfo.m_charPosition.x * blockWidth, 0f, CurRoomInfo.m_charPosition.z * blockHeight);
CurRoomInfo.CharPosition = new Vector3(childObj.transform.position.x, 0.15f, childObj.transform.position.z);;
CurRoomInfo.CharPosTransform = childObj.transform;
}
else
{
CurRoomInfo.CharPosition = new Vector3(posTrans.position.x, 0.15f, posTrans.position.z);;
CurRoomInfo.CharPosTransform = posTrans;
}
}
//激活检测开始战斗的刚体
if (CurRoomInfo.m_monsterDataList.Count > 0)
{
Transform starBattleColliderTans = CurRoomInfo.m_roomObj.transform.Find("activeArea");
if (starBattleColliderTans != null)
{
for (int i = 0; i < starBattleColliderTans.transform.childCount; i++)
{
Transform child = starBattleColliderTans.transform.GetChild(i);
TriggerCallback triggerCallback = child.gameObject.AddComponent <TriggerCallback>();
triggerCallback.EnterCallback = OnCheckEnterCallBack;
}
}
}
}
private IEnumerator CreateRoom()
{
Random rng = new Random(seed);
newRoom = new GameObject("New Room").transform;
newRoom.parent = transform;
newRoom.position = new Vector3(0.0f, 200.0f, 0.0f);
Stack <StackElement> stack = new Stack <StackElement>();
generationFailed = false;
RoomElement enter = elements
.FirstOrDefault(e => e.type == ElementType.ENTER);
Transform enterTrans = Instantiate(enter, newRoom).transform;
enterTrans.localPosition = Vector3.zero;
RoomElement enterElement = enterTrans.GetComponent <RoomElement>();
enterElement.RegisterElement(ElementCollision);
CrossingEntity crossing = enterElement.crossings[0];
newParams.playerSpawn = enterElement.playerSpawnPoint;
newParams.enemySpawns.AddRange(enterElement.enemySpawnPoints);
stack.Push(new StackElement(crossing.crossing.localPosition, crossing.direction, 1));
int branches = 1;
bool exitCreated = false;
while (stack.Count > 0)
{
if (generationFailed)
{
progress = GenerationProgress.ERROR;
yield break;
}
StackElement el = stack.Pop();
int requirements = SelectElements(el.depth, exitCreated, branches);
RoomElement[] els = elements.Where(e => ((int)e.type & requirements) > 0).ToArray();
RoomElement nextEl = els[rng.Next(0, els.Length)];
Transform tr = Instantiate(nextEl, newRoom.transform).transform;
Vector3 pos = new Vector3(el.entryPoint.x, 0.0f, el.entryPoint.z);
tr.localPosition = pos;
tr.localRotation = DirectionToRotation(el.direction);
RoomElement re = tr.GetComponent <RoomElement>();
re.RegisterElement(ElementCollision);
newParams.enemySpawns.AddRange(re.enemySpawnPoints);
if (nextEl.type == ElementType.CROSSING)
{
if (re.crossings.Count > 1)
{
branches += re.crossings.Count - 1;
}
foreach (var ce in re.crossings)
{
StackElement newStackElement = new StackElement();
newStackElement.depth = el.depth + 1;
newStackElement.direction = CalculateDirection(el.direction, ce.direction);
//newStackElement.entryPoint = tr.localPosition + ce.crossing.localPosition;
newStackElement.entryPoint = ce.crossing.position;
stack.Push(newStackElement);
}
}
else if (nextEl.type == ElementType.EXIT)
{
exitCreated = true;
}
if (nextEl.type == ElementType.EXIT || nextEl.type == ElementType.DEAD_END)
{
branches--;
}
//yield return new WaitForSeconds(waitFor);
yield return(new WaitForFixedUpdate());
}
//yield return new WaitForSeconds(waitFor);
yield return(new WaitForFixedUpdate());
progress = GenerationProgress.END;
}
public void SetOwner(RoomElement owner) => this.owner = owner;
private void DeactivateDoor(Transform room)
{
RoomElement el = room.GetChild(0).GetComponent <RoomElement>();
el.DeactivateDoor();
}
void PositionOnFloor()
{
Voxel[] floorVoxels = blueprint.FloorVoxels;
List<int> floorVoxelsIndexList = GetFloorVoxelsIndexsList(floorVoxels);
roomItemPrefab.Init();
Vector3[] itemWorldPositions = null;
Voxel acceptedFloorVoxel = null;
ConditionData conditionData;
conditionData.endPointDirection = DirectionType.FORWARD;
conditionData.blueprint = blueprint;
conditionData.roomItemPrefab = roomItemPrefab;
conditionData.takenVoxels = acceptedItemVoxels;
int infiniteLoopCheckCount = 0, infiniteLoopCheck = 100000;//targetElementsCount << elementsFactory.loopCheckCount;
do
{
if (infiniteLoopCheckCount++ > infiniteLoopCheck)
{
throw new System.Exception("RoomGenerator::Room generation takes too long. - Possible infinite loop.");
}
if (floorVoxelsIndexList.Count == 0) break;
int randomFloorVoxelIndex = Random.Range(0, floorVoxelsIndexList.Count);
randomFloorVoxelIndex = floorVoxelsIndexList[randomFloorVoxelIndex];
floorVoxelsIndexList.Remove(randomFloorVoxelIndex);
Voxel randomFloorVoxel = floorVoxels[randomFloorVoxelIndex];
Vector3 randomFloorVoxelPos = randomFloorVoxel.worldPosition;
itemWorldPositions = roomItemPrefab.GetOffsetedVoxelPostions(randomFloorVoxelPos);
/////
conditionData.randomFloorVoxelPos = randomFloorVoxelPos;
conditionData.endPointDirection = DirectionType.FORWARD;
bool testPassed = false;
int infiniteLoopCheckCount2 = 0, infiniteLoopCheck2 = 100000;//targetElementsCount << elementsFactory.loopCheckCount;
int endPointIndex = 0, endPointsCount = roomItemPrefab.endPoint.directions.Count;
do
{
if (infiniteLoopCheckCount2++ > infiniteLoopCheck2)
{
throw new System.Exception("RoomGenerator::Room item rotation takes too long. - Possible infinite loop.");
}
conditionData.endPointDirection = roomItemPrefab.endPoint.directions[endPointIndex];
List<GenerationCondition> generationConditions = roomItemPrefab.generationConditions;
int conditionsCount = generationConditions.Count;
for (int i = 0; i < conditionsCount; i++)
{
GenerationCondition condition = generationConditions[i];
testPassed = condition.Test(conditionData);
if (!testPassed) break;
}
if (!testPassed) endPointIndex++;//conditionData.rotationIndex++;
} while (!testPassed && endPointIndex < endPointsCount);
/////
if (!testPassed) continue;
acceptedFloorVoxel = randomFloorVoxel;
}
while (acceptedFloorVoxel == null && floorVoxelsIndexList.Count > 0);
if (acceptedFloorVoxel == null)
{
Debug.Log("No more space in room");
return;
}
RoomElement item = Instantiate(roomItemPrefab, gameObject.transform);
item.transform.position = acceptedFloorVoxel.worldPosition;
item.transform.rotation = Quaternion.AngleAxis((float)conditionData.endPointDirection, Vector3.up);
InitilizeNewItem(item);
}
