private void OnSelect(FluidSelectable currentSelectable)
    {
        KMSelectable[] children = parentSelectable.Children;

        int reserveChildCount = children.Length - 12;

        Array.Clear(children, reserveChildCount, 12);

        KMSelectable selectable = currentSelectable != null ? currentSelectable.selectable : null;

        children[reserveChildCount]     = selectable;
        children[reserveChildCount + 1] = selectable;
        children[reserveChildCount + 2] = selectable;
        children[reserveChildCount + 7] = selectable;

        if (currentSelectable != null)
        {
            children[reserveChildCount + 4]  = currentSelectable.up != null ? currentSelectable.up.selectable : null;
            children[reserveChildCount + 6]  = currentSelectable.left != null ? currentSelectable.left.selectable : null;
            children[reserveChildCount + 8]  = currentSelectable.right != null ? currentSelectable.right.selectable : null;
            children[reserveChildCount + 10] = currentSelectable.down != null ? currentSelectable.down.selectable : null;
        }

        parentSelectable.UpdateChildren(selectable);
    }
    public void SetChildren(FluidSelectable[] childSelectables)
    {
        int reserveChildCount = childSelectables.Length;

        if (reserveChildCount % 3 != 0)
        {
            reserveChildCount += 3 - (reserveChildCount % 3);
        }

        int finalChildCount = reserveChildCount + 12;

        parentSelectable.Children       = new KMSelectable[finalChildCount];
        parentSelectable.ChildRowLength = 3;

        for (int childSelectableIndex = 0; childSelectableIndex < childSelectables.Length; ++childSelectableIndex)
        {
            FluidSelectable childSelectableClosure = childSelectables[childSelectableIndex];
            childSelectableClosure.selectable.OnSelect     += () => OnSelect(childSelectableClosure);
            parentSelectable.Children[childSelectableIndex] = childSelectableClosure.selectable;
        }

        OnSelect(null);
    }
예제 #3
0
    private void GenerateFluidGrid()
    {
        Vector2 tempIntersection = Vector2.zero;

        foreach (PaintingCell cell in Cells)
        {
            Vector2 centerPoint    = cell.visiblePolyExtrude.CenterPoint;
            float   bestUpDelta    = float.PositiveInfinity;
            float   bestDownDelta  = float.PositiveInfinity;
            float   bestLeftDelta  = float.PositiveInfinity;
            float   bestRightDelta = float.PositiveInfinity;

            FluidSelectable fluidSelectable = cell.fluidSelectable;
            fluidSelectable.up    = null;
            fluidSelectable.down  = null;
            fluidSelectable.left  = null;
            fluidSelectable.right = null;

            foreach (PaintingCell otherCell in Cells)
            {
                if (otherCell == cell)
                {
                    continue;
                }

                if (Vector2Extensions.GetLinePolyIntersection(out tempIntersection, centerPoint, Vector2.up, otherCell.visiblePolyExtrude.points))
                {
                    float delta = (tempIntersection - centerPoint).sqrMagnitude;
                    if (delta < bestUpDelta)
                    {
                        bestUpDelta        = delta;
                        fluidSelectable.up = otherCell.fluidSelectable;
                    }
                }

                if (Vector2Extensions.GetLinePolyIntersection(out tempIntersection, centerPoint, Vector2.down, otherCell.visiblePolyExtrude.points))
                {
                    float delta = (tempIntersection - centerPoint).sqrMagnitude;
                    if (delta < bestDownDelta)
                    {
                        bestDownDelta        = delta;
                        fluidSelectable.down = otherCell.fluidSelectable;
                    }
                }

                if (Vector2Extensions.GetLinePolyIntersection(out tempIntersection, centerPoint, Vector2.left, otherCell.visiblePolyExtrude.points))
                {
                    float delta = (tempIntersection - centerPoint).sqrMagnitude;
                    if (delta < bestLeftDelta)
                    {
                        bestLeftDelta        = delta;
                        fluidSelectable.left = otherCell.fluidSelectable;
                    }
                }

                if (Vector2Extensions.GetLinePolyIntersection(out tempIntersection, centerPoint, Vector2.right, otherCell.visiblePolyExtrude.points))
                {
                    float delta = (tempIntersection - centerPoint).sqrMagnitude;
                    if (delta < bestRightDelta)
                    {
                        bestRightDelta        = delta;
                        fluidSelectable.right = otherCell.fluidSelectable;
                    }
                }
            }
        }
    }
예제 #4
0
    private bool SetupPaletteToPaintingLinks()
    {
        Vector2 tempIntersection = Vector2.zero;

        foreach (PaletteColor paletteColor in _paletteColors)
        {
            Vector2 direction = Vector2.zero;
            switch (paletteColor.paintingDirection)
            {
            case PaletteColor.Direction.Down:
                direction = Vector2.down;
                break;

            case PaletteColor.Direction.Left:
                direction = Vector2.left;
                break;

            default:
                continue;
            }

            FluidSelectable paletteFluidSelectable = paletteColor.fluidSelectable;

            float           bestDelta = float.PositiveInfinity;
            FluidSelectable bestCellFluidSelectable = null;

            foreach (PaintingCell cell in _painting.Cells)
            {
                if (Vector2Extensions.GetLinePolyIntersection(out tempIntersection, paletteColor.paintingPoint, direction, cell.visiblePolyExtrude.points))
                {
                    float delta = (tempIntersection - paletteColor.paintingPoint).sqrMagnitude;
                    if (delta < bestDelta)
                    {
                        bestDelta = delta;
                        bestCellFluidSelectable = cell.fluidSelectable;
                    }
                }
            }

            if (bestCellFluidSelectable != null)
            {
                switch (paletteColor.paintingDirection)
                {
                case PaletteColor.Direction.Down:
                    paletteFluidSelectable.down = bestCellFluidSelectable;
                    if (bestCellFluidSelectable.up == null)
                    {
                        bestCellFluidSelectable.up = paletteFluidSelectable;
                    }
                    break;

                case PaletteColor.Direction.Left:
                    paletteFluidSelectable.left = bestCellFluidSelectable;
                    if (bestCellFluidSelectable.right == null)
                    {
                        bestCellFluidSelectable.right = paletteFluidSelectable;
                    }
                    break;

                default:
                    break;
                }
            }
        }

        return(true);
    }