private void UpdateBuilder()
{
if (actionLockController.IsLocked())
{
return;
}
if (builder == null)
{
return;
}
nearestToBuilder = GetNearest(buildDistance, builder.root.position);
if (nearestToBuilder == null)
{
Unindicate();
return;
}
if (nearestToBuilder.GetBlockCount() >= nearestToBuilder.GetMaxBlock())
{
Unindicate();
return;
}
Indicate(nearestToBuilder);
}
private BarrierPoint GetNearest(float maxDistance, Vector3 to)
{
BarrierPoint nearest = null;
float distance = float.MaxValue;
foreach (var point in points)
{
var pointDistance = (point.anchor.position - to).magnitude;
if (pointDistance <= maxDistance && pointDistance < distance)
{
distance = pointDistance;
nearest = point;
}
}
return(nearest);
}
private void Indicate(BarrierPoint point)
{
if (!indcShow)
{
indcShow = true;
if (indcRoutine != null)
{
StopCoroutine(indcRoutine);
}
indcRoutine = StartCoroutine(IndcRoutine(Vector3.one, true));
indicator.transform.position = point.anchor.position + (Vector3.up * indicateHeight);
indicator.transform.rotation = Quaternion.identity;
}
if (!builder.IsIndicating())
{
builder.HandleIndicate();
}
}
public void Generate()
{
freePositions = new List <FreePosition>();
rooms = new RoomState[maxX][];
for (int x = 0; x < maxX; x++)
{
rooms[x] = new RoomState[maxY];
}
var startingRoom = AddRoom(startingRoomPrefabFront, maxX / 2 + maxX % 2, 0, RoomFacing.South);
startingRoom.neverDim = true;
var startingRoomComp = startingRoom.room.gameObject.GetComponent <StartingRoom>();
startingPoint = startingRoomComp.startingPoint;
entrancePoint = startingRoomComp.entrancePoint;
var backStartingRoom = AddRoom(startingRoomPrefabBack, maxX / 2 + maxX % 2, 1, RoomFacing.South);
startingRoom.isStarting = true;
backStartingRoom.isStarting = true;
List <Room> roomShuffle = null;
for (var index = 0; index < targetRoomCount; index++)
{
if (freePositions.Count <= 0)
{
break;
}
var positionIndex = UnityEngine.Random.Range(0, freePositions.Count);
var orientation = (RoomFacing)UnityEngine.Random.Range(0, (int)RoomFacing.West + 1);
var position = freePositions[positionIndex];
if (roomShuffle == null || roomShuffle.Count == 0)
{
roomShuffle = GetShuffledPrefabs();
}
var roomPrefab = roomShuffle[roomShuffle.Count - 1];
roomShuffle.RemoveAt(roomShuffle.Count - 1);
var mustRotate = true;
while (mustRotate)
{
var orientatedFrom = RoomFacingUtil.GetInverseOrientated(position.from, orientation);
var fromAnchor = roomPrefab.anchors.Find(anchor => anchor.facing == orientatedFrom);
if (!fromAnchor.allowAttachment)
{
orientation = RoomFacingUtil.IncrementWrapped(orientation, 1);
continue;
}
//Debug.Log(position.position + " from " + position.from + " oks anchor " + orientatedFrom + " for " + orientation);
mustRotate = false;
}
AddRoom(roomPrefab, position.position.x, position.position.y, orientation);
}
for (var x = 0; x < maxX; x++)
{
for (var y = 0; y < maxY; y++)
{
var roomState = rooms[x][y];
if (roomState == null)
{
continue;
}
foreach (var facing in RoomFacingUtil.ALL)
{
if (roomState.wallStates[facing] == WallState.Unknown)
{
var offset = RoomFacingUtil.GetOffset(facing);
var position = getValidatedPosition(offset.x + x, offset.y + y);
var facingOriented = RoomFacingUtil.GetInverseOrientated(facing, roomState.orientation);
var anchorForFacing = roomState.room.anchors.Find((anchor) => anchor.facing == facingOriented);
if (position == INVALID_POS)
{
GenerateWall(x, y, WallState.Solid, roomState, facing, true);
anchorForFacing.exitPathPoint.isDeactivated = true;
continue;
}
var oppositeRoom = rooms[position.x][position.y];
if (oppositeRoom == null)
{
GenerateWall(x, y, WallState.Solid, roomState, facing, true);
anchorForFacing.exitPathPoint.isDeactivated = true;
continue;
}
var oppositeFacing = RoomFacingUtil.GetOpposite(facing);
var oppositeFacingOriented = RoomFacingUtil.GetInverseOrientated(oppositeFacing, oppositeRoom.orientation);
var anchorForOppositeFacing = oppositeRoom.room.anchors.Find((anchor) => anchor.facing == oppositeFacingOriented);
if (!anchorForFacing.allowAttachment)
{
GenerateWall(x, y, WallState.Solid, roomState, facing, false);
oppositeRoom.wallStates[oppositeFacing] = WallState.Solid;
anchorForFacing.exitPathPoint.isDeactivated = true;
anchorForOppositeFacing.exitPathPoint.isDeactivated = true;
continue;
}
if (!anchorForOppositeFacing.allowAttachment)
{
GenerateWall(x, y, WallState.Solid, roomState, facing, false);
oppositeRoom.wallStates[oppositeFacing] = WallState.Solid;
anchorForFacing.exitPathPoint.isDeactivated = true;
anchorForOppositeFacing.exitPathPoint.isDeactivated = true;
continue;
}
if (anchorForOppositeFacing.allowNoWall && anchorForFacing.allowNoWall)
{
GenerateWall(x, y, WallState.None, roomState, facing, false);
oppositeRoom.wallStates[oppositeFacing] = WallState.None;
continue;
}
GenerateWall(x, y, WallState.Open, roomState, facing, false);
var isHorizontal = facing == RoomFacing.North || facing == RoomFacing.South;
var barrierPoint = new BarrierPoint()
{
anchor = anchorForFacing.exitPathPoint.transform, isHorizontal = isHorizontal
};
barrierController.AddPoint(barrierPoint);
oppositeRoom.wallStates[oppositeFacing] = WallState.Open;
}
}
}
}
}
public void AddPoint(BarrierPoint point)
{
point.Init(actionLockController, this, blockPrefab, blockHeight, maxBlock, spawnTime, blockOffset);
points.Add(point);
}
