Esempio n. 1
0
    static Bounds3Int[] PlaceAddonRadially(float radianAngle, Bounds3Int[] addon, SpatialHash <LandParcel> occupied, out Vector2Int position)
    {
        Vector2        direction = Mathx.RadianToVector2(radianAngle);
        PixelTraversal tracer    = new PixelTraversal(new Vector2(), direction);

        Bounds3Int[] placed = new Bounds3Int[addon.Length];
        bool         overlaps;

        do
        {
            tracer.Step();
            overlaps = false;

            for (int i = 0, len = addon.Length; i < len; ++i)
            {
                Bounds3Int translated = addon[i].Translate(tracer.position.ToVector3XZ());
                if (occupied.Overlaps(translated))
                {
                    overlaps = true;
                    break;
                }
                placed[i] = translated;
            }
        } while (overlaps);

        position = tracer.position;
        return(placed);
    }
Esempio n. 2
0
    static bool ShiftTowardsZero(Bounds3Int[] addon, Bounds3Int[] placed, SpatialHash <LandParcel> occupied, int positionIndex, ref Vector2Int placedPosition)
    {
        Vector2Int position = placedPosition;

        if (position[positionIndex] == 0)
        {
            return(false);
        }

        int       step = position[positionIndex] > 0 ? -1 : 1;
        bool      overlaps;
        const int maxIterations = 20;
        int       iter          = 0;

        do
        {
            overlaps = false;
            position[positionIndex] += step;
            if (position[positionIndex] == step)
            {
                break;
            }

            if (iter >= maxIterations)
            {
                // Failsafe in case we miss the geometry and shift into oblivion
                for (int i = 0, len = addon.Length; i < len; ++i)
                {
                    placed[i] = addon[i].Translate(placedPosition.ToVector3XZ());
                }
                return(false);
            }
            ++iter;


            for (int i = 0, len = addon.Length; i < len; ++i)
            {
                Bounds3Int translated = addon[i].Translate(position.ToVector3XZ());
                if (occupied.Overlaps(translated))
                {
                    overlaps = true;
                }
                placed[i] = translated;
            }
        } while (!overlaps);

        position[positionIndex] -= step;
        for (int i = 0, len = addon.Length; i < len; ++i)
        {
            placed[i] = addon[i].Translate(position.ToVector3XZ());
            //Shouldn't overlap
        }

        bool moved = position[positionIndex] != placedPosition[positionIndex];

        placedPosition = position;
        return(moved);
    }
Esempio n. 3
0
    void Add(Machine machine)
    {
        Assert.IsFalse(machineSpatialHash.Overlaps(machine.bounds));
        machines.Add(machine);
        machineSpatialHash.Add(machine, machine.bounds);
        MachineInfo machineInfo = machine.machineInfo;

        bool machinesMetaDataExists = machinesMetaData.TryGetValue(machineInfo, out MachineMetaData machineMetaData);

        machineMetaData.numInstances++;
        if (machinesMetaDataExists)
        {
            machinesMetaData[machineInfo] = machineMetaData;
        }
        else
        {
            machinesMetaData.Add(machineInfo, machineMetaData);
        }
    }