Exemple #1
0
    //Only used to test fill pixels

    void DebugFill()
    {
        if (pixelAmount > maxPixels)
        {
            addFill = false;
            return;
        }
        p_t += Time.deltaTime;

        if (p_t > 0.05f)
        {
            pixelAmount++;
            p_t = 0;
        }
        else
        {
            return;
        }

        Node     n = GetNodeFromWorldPos(fillDebugObj.position);
        FillNode f = new FillNode();

        f.x = n.x;
        f.y = n.y;
        fillNodes.Add(f);
        addTexture = true;
    }
Exemple #2
0
        public void FloodFill(int x, int y)
        {
            if (!IsInbound(x, y))
            {
                return;
            }

            if (Get(x, y))
            {
                return;
            }

            Set(x, y);
            Queue <FillNode> queue = new Queue <FillNode>();

            queue.Enqueue(new FillNode(x, y));

            while (queue.Count > 0)
            {
                FillNode n = queue.Dequeue();

                if (!Get(n.x, n.y - 1) && IsInbound(n.x, n.y - 1))
                {
                    Set(n.x, n.y - 1);
                    queue.Enqueue(new FillNode(n.x, n.y - 1));
                }

                if (!Get(n.x - 1, n.y) && IsInbound(n.x - 1, n.y))
                {
                    Set(n.x - 1, n.y);
                    queue.Enqueue(new FillNode(n.x - 1, n.y));
                }

                if (!Get(n.x, n.y + 1) && IsInbound(n.x, n.y + 1))
                {
                    Set(n.x, n.y + 1);
                    queue.Enqueue(new FillNode(n.x, n.y + 1));
                }

                if (!Get(n.x + 1, n.y) && IsInbound(n.x + 1, n.y))
                {
                    Set(n.x + 1, n.y);
                    queue.Enqueue(new FillNode(n.x + 1, n.y));
                }
            }
        }
Exemple #3
0
    void Filler(float delta)
    {
        if (!startFilling)
        {
            startfill_t += delta;

            if (startfill_t < startFill)
            {
                startFilling = true;
            }
        }

        if (pixelAmount > maxPixels)
        {
            ChangeAbility(Ability.walker);
            return;
        }

        pix_t += delta;

        if (pix_t > 0.05f)
        {
            pixelAmount++;
            pix_t = 0;
        }
        else
        {
            return;
        }

        int _x = (movingLeft) ? curNode.x - 3 : curNode.x + 3;
        int _y = curNode.y + 4;

        Node     n = gameControl.GetNode(_x, _y);
        FillNode f = new FillNode();

        f.x = n.x;
        f.y = n.y;
        gameControl.AddFillNode(f);
    }
Exemple #4
0
    //Add new Node

    public void AddFillNode(FillNode f)
    {
        fillNodes.Add(f);
    }
Exemple #5
0
    //Calculates fill node movement and sets a color

    void HandleFillNodes(float delta)
    {
        f_t += delta;

        if (f_t > 0.05f)
        {
            f_t = 0;
        }
        else
        {
            return;
        }

        if (fillNodes.Count == 0)
        {
            return;
        }

        for (int i = 0; i < fillNodes.Count; i++)
        {
            FillNode f  = fillNodes[i];
            Node     cn = GetNode(f.x, f.y);
            cn.isFiller = true;

            int _y = f.y;
            _y--;

            Node d = GetNode(f.x, _y);

            if (d == null)
            {
                fillNodes.Remove(f);
                continue;
            }

            if (d.isEmpty)
            {
                d.isEmpty  = false;
                d.isFiller = true;
                textureInstance.SetPixel(d.x, d.y, fillColor);
                miniMapInstance.SetPixel(d.x, d.y, miniMapColor);
                f.y = _y;
                clearNodes.Add(cn);
            }
            else
            {
                Node df = GetNode(f.x - 1, _y);

                if (df == null)
                {
                    fillNodes.Remove(f);
                    continue;
                }

                if (df.isEmpty)
                {
                    textureInstance.SetPixel(df.x, df.y, shadyCOlor);
                    miniMapInstance.SetPixel(df.x, df.y, miniMapColor);
                    f.y         = _y;
                    f.x        -= 1;
                    df.isEmpty  = false;
                    df.isFiller = true;
                    clearNodes.Add(cn);
                }
                else
                {
                    Node bf = GetNode(f.x + 1, _y);
                    if (bf.isEmpty)
                    {
                        bf.isEmpty  = false;
                        bf.isFiller = true;
                        textureInstance.SetPixel(bf.x, bf.y, fillColor);
                        miniMapInstance.SetPixel(bf.x, bf.y, miniMapColor);
                        f.y  = _y;
                        f.x += 1;
                        clearNodes.Add(cn);
                    }
                    else
                    {
                        f.t++;
                        if (f.t > 15)
                        {
                            Node _cn = GetNode(f.x, f.y);
                            _cn.isFiller = false;
                            fillNodes.Remove(f);
                        }
                    }
                }
            }
        }
    }