Ejemplo n.º 1
0
    public static Vector3 pointOnEdge(Edge edge)
    {
        Vector3 midpoint         = (edge.endpoints [0] + edge.endpoints [1]) / 2;
        int     maxDisplacement  = edge.length() / 3;
        Vector3 displacementAxis = GenericUtils.rotateClockwise(edge.axisDirection);
        float   displacement     = Randomiser.intBetween(maxDisplacement * -1, maxDisplacement);

        return(midpoint + displacement * displacementAxis);
    }
Ejemplo n.º 2
0
    public PlainBuildingDataStruct getDataStruct(BuildingFoundation foundation)
    {
        PlainBuildingDataStruct data = new PlainBuildingDataStruct();

        data.sizeX      = foundation.lengthX;
        data.sizeZ      = foundation.lengthZ;
        data.floorCount = Randomiser.intBetween(2, 3);
        GameObject[] windowPrefabs = GenericUtils.loadAllPrefabs("prefabs/windows");
        data.windowPrefab    = windowPrefabs [Random.Range(0, windowPrefabs.Length)];
        data.wallPrefab      = GenericUtils.loadPrefab("plain building", "wallPrefab");
        data.fullFloorPrefab = GenericUtils.loadPrefab("plain building", "fullFloorPrefab");
        data.roofPrefab      = GenericUtils.loadPrefab("plain building", "roofPrefab");
        return(data);
    }
Ejemplo n.º 3
0
    private List <int> generateDecorSequence()
    {
        List <int> res       = new List <int> ();
        int        itemCount = Randomiser.intBetween(1, 5);

        for (; itemCount > 1; itemCount--)
        {
            res.Add(Randomiser.intBetween(2, 5));
        }
        res.Add(Randomiser.intBetween(4, 8));
        foreach (int i in res)
        {
        }
        return(res);
    }
    bool addNewMinaret()
    {
        Edge     curEdge      = freeEdges[Randomiser.intBetween(0, freeEdges.Count / 2)];
        Junction junction     = new Junction(Randomiser.pointOnEdge(curEdge), curEdge.axisDirection);
        Vector3  measurePoint = junction.position + 0.2f * curEdge.axisDirection;

        if (!checkJunction(measurePoint))
        {
            return(false);
        }
        int distanceAlongEdge = Mathf.Min(
            Randomiser.measureDistance(measurePoint, GenericUtils.rotateClockwise(curEdge.axisDirection), maxLengthR / 2),
            Randomiser.measureDistance(measurePoint, -1 * GenericUtils.rotateClockwise(curEdge.axisDirection), maxLengthR / 2)
            );

        if (distanceAlongEdge < minLengthS)
        {
            return(false);
        }
        int distanceAlongAxis = Randomiser.measureDistance(measurePoint, curEdge.axisDirection, minaretSize);

        if (distanceAlongAxis * 2 < minaretSize)
        {
            return(false);
        }
        distanceAlongAxis = Randomiser.clampInRange(distanceAlongAxis, minaretSize, (int)(distanceAlongEdge * 2));
        MinaretFoundation minaret = minaretFromJunction(junction, curEdge.axisDirection, Mathf.Min(distanceAlongEdge * 2, distanceAlongAxis));

        if (!checkMinaretConsistency(minaret))
        {
            minaret.delete();
            return(false);
        }
        if (!checkOverlaps(minaret))
        {
            minaret.delete();
            return(false);
        }
        minarets.Add(minaret);
        freeEdges.Remove(curEdge);
        usedEdges.Add(curEdge);
        return(true);
    }
    bool addNewSquare()
    {
        Edge     curEdge      = freeEdges[Randomiser.intBetween(0, freeEdges.Count / 2)];
        Junction junction     = new Junction(Randomiser.pointOnEdge(curEdge), curEdge.axisDirection);
        Vector3  measurePoint = junction.position + 0.2f * curEdge.axisDirection;

        if (!checkJunction(measurePoint))
        {
            return(false);
        }
        int distanceAlongEdge = Mathf.Min(
            Randomiser.measureDistance(measurePoint, GenericUtils.rotateClockwise(curEdge.axisDirection), maxLengthR / 2),
            Randomiser.measureDistance(measurePoint, -1 * GenericUtils.rotateClockwise(curEdge.axisDirection), maxLengthR / 2)
            );

        if (distanceAlongEdge < minLengthS)
        {
            return(false);
        }
        int distanceAlongAxis = Randomiser.measureDistance(measurePoint, curEdge.axisDirection, maxLengthR);

        if (distanceAlongAxis * 2 < minLengthS)
        {
            return(false);
        }
        distanceAlongAxis = Randomiser.clampInRange(distanceAlongAxis, minLengthR, (int)(distanceAlongEdge * 2));
        SquareFoundation square = SquareFromJunction(junction, curEdge.axisDirection, Mathf.Min(distanceAlongEdge * 2, distanceAlongAxis));

        if (!checkSquareConsistency(square))
        {
            square.delete();
            return(false);
        }
        if (!checkOverlaps(square))
        {
            square.delete();
            return(false);
        }
        updateLists(square, curEdge, junction, squares, true, false);
        return(true);
    }
    private void generateDataStruct()
    {
        dataStruct               = new MinaretDataStruct();
        dataStruct.baseWidth     = 7;
        dataStruct.baseHeight    = 3;
        dataStruct.shaftHeight   = Randomiser.intBetween(25, 40);
        dataStruct.shaftWidth    = 5;
        dataStruct.ringNumber    = Randomiser.intBetween(1, 3);
        dataStruct.ringWidth     = 6;
        dataStruct.ringHeight    = 1.5f;
        dataStruct.galleryWidth  = 4;
        dataStruct.galleryHeight = 3.5f;
        dataStruct.topWidth      = dataStruct.galleryWidth;
        dataStruct.topHeight     = dataStruct.galleryWidth;
        dataStruct.decorHeight   = 1;
        dataStruct.decorWidth    = 1;

        GameObject[] basePrefabs = GenericUtils.loadAllPrefabs("prefabs/minaret/base_M");
        dataStruct.basePrefab = basePrefabs [Random.Range(0, basePrefabs.Length)];
        GameObject[] shaftPrefabs = GenericUtils.loadAllPrefabs("prefabs/minaret/shaft_M");
        dataStruct.shaftPrefab = shaftPrefabs [Random.Range(0, shaftPrefabs.Length)];
        GameObject[] ringPrefabs = GenericUtils.loadAllPrefabs("prefabs/minaret/ring_M");
        dataStruct.ringPrefab = ringPrefabs [Random.Range(0, ringPrefabs.Length)];
        GameObject[] galleryPrefabs = GenericUtils.loadAllPrefabs("prefabs/minaret/gallery_M");
        dataStruct.galleryPrefab = galleryPrefabs [Random.Range(0, galleryPrefabs.Length)];
        GameObject[] topPrefabs = GenericUtils.loadAllPrefabs("prefabs/minaret/top_M");
        dataStruct.topPrefab = topPrefabs [Random.Range(0, topPrefabs.Length)];
        GameObject[] decorPrefabs = GenericUtils.loadAllPrefabs("prefabs/minaret/decoration_M");
        dataStruct.decorPrefab   = decorPrefabs [Random.Range(0, decorPrefabs.Length)];
        dataStruct.decorSequence = generateDecorSequence();

        ArchData ad = gameObject.GetComponent <ArchData> ();

        dataStruct.columnBase    = ad.getColumnBase();
        dataStruct.columnShaft   = ad.getColumnShaft();
        dataStruct.columnCapital = ad.getColumnCapital();
        dataStruct.arch          = ad.getSimpleArch();
    }
Ejemplo n.º 7
0
    public MosqueDataStruct getDataStruct(BuildingFoundation foundation)
    {
        MosqueDataStruct dataStruct = new MosqueDataStruct();

        dataStruct.size           = foundation.lengthX;
        dataStruct.collarDiameter = dataStruct.size * 0.9f;
        dataStruct.collarHeight   = 1.5f;
        int collars = Randomiser.intBetween(0, 3);

        dataStruct.collarSequence = new List <int> ();
        for (int i = 0; i < collars; i++)
        {
            dataStruct.collarSequence.Add((int)Randomiser.oneOf(0, 1.5f));                //0 -> full collar, 1 -> arch collar
        }
        dataStruct.baseHeight       = 5;
        dataStruct.decorSequence    = generateDecorSequence();
        dataStruct.mosqueBodyPrefab = mosqueBodyPrefabs[Random.Range(0, mosqueBodyPrefabs.Count)];
        dataStruct.fullCollarPrefab = fullCollarPrefab;
        GameObject[] arches = GenericUtils.loadAllPrefabs("prefabs/arches/simple");
        dataStruct.archPrefab  = arches [Random.Range(0, arches.Length)];
        dataStruct.topPrefab   = topPrefabs [Random.Range(0, topPrefabs.Count)];
        dataStruct.decorPrefab = decorPrefab;
        return(dataStruct);
    }