Ejemplo n.º 1
0
    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);
    }
Ejemplo n.º 2
0
    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);
    }
Ejemplo n.º 3
0
 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();
     }
 }
Ejemplo n.º 4
0
    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;
                    }
                }
            }
        }
    }
Ejemplo n.º 5
0
 public void AddPoint(BarrierPoint point)
 {
     point.Init(actionLockController, this, blockPrefab, blockHeight, maxBlock, spawnTime, blockOffset);
     points.Add(point);
 }