btsprite.java

The applet illustrates the behaviour of binary search trees, Searching and Sorting Algorithms, Self-

// Source File Name:   BTSprite.java


class BTSprite
{

    public int getDebug()
    {
        return debug;
    }

    public void setDebug(int debug)
    {
        this.debug = debug;
    }

    public void setMode(int mode)
    {
        this.mode = mode;
    }

    public int getMode()
    {
        return mode;
    }

    public void setFlag(int flag)
    {
        this.flag = flag;
    }

    public int getFlag()
    {
        return flag;
    }

    public boolean is(int flag)
    {
        return (this.flag & flag) > 0;
    }

    public void setEvent(int event)
    {
        this.event = event;
    }

    public int getEvent()
    {
        return event;
    }

    public void reset()
    {
        event = 0;
        mode = 0;
        flag = 0;
        side = 0;
    }

    public void setRSide(int side)
    {
        this.side = side;
    }

    public int getRSide()
    {
        return side;
    }

    public void setPaint(int color)
    {
        flag = color;
    }

    public void resetPaint()
    {
        flag = 0;
    }

    public void setRotate(int mode, int side)
    {
        this.mode = mode;
        this.side = side;
    }

    public void resetRotate()
    {
        mode = 0;
        side = 0;
    }

    public int x()
    {
        return x;
    }

    public int y()
    {
        return y;
    }

    public int X()
    {
        return X;
    }

    public int Y()
    {
        return Y;
    }

    public int getVx()
    {
        return vx;
    }

    public int getVy()
    {
        return vy;
    }

    public void setLocation(int x, int y)
    {
        this.x = x;
        this.y = y;
    }

    public void setLocation(BTNode node)
    {
        x = ((BTSprite) (node)).x;
        y = ((BTSprite) (node)).y;
    }

    public void setDestination(int X, int Y)
    {
        this.X = X;
        this.Y = Y;
    }

    public void setDestination(BTNode node)
    {
        X = ((BTSprite) (node)).x;
        Y = ((BTSprite) (node)).y;
    }

    public void retract(int speed)
    {
        if(mode != 0)
        {
            moveTo(X, Y, speed);
            return;
        }
        int dx = (X - x) / 2;
        int dy = (Y - y) / 2;
        if(dx != 0 || dy != 0)
        {
            x += dx;
            y += dy;
            return;
        } else
        {
            x = X;
            y = Y;
            return;
        }
    }

    public void moveTo(int X, int Y, int speed)
    {
        if(speed == 0)
            return;
        this.X = X;
        this.Y = Y;
        if(x == X && y == Y)
            return;
        int dx = abs(X - x);
        int dy = abs(Y - y);
        int ix = sign(X - x);
        int iy = sign(Y - y);
        int n = dx < dy ? dy : dx;
        if(n > 5)
        {
            vx = ix * dx;
            vy = iy * dy;
        }
        int delay = (10 - speed) + 2;
        n /= delay;
        if(dx >= dy)
        {
            dy <<= 1;
            int balance = dy - dx;
            dx <<= 1;
            for(int i = 0; i <= n; i++)
            {
                if(balance >= 0)
                {
                    y += iy;
                    balance -= dx;
                }
                balance += dy;
                x += ix;
                if(x == X && y == Y)
                    return;
            }

        } else
        {
            dx <<= 1;
            int balance = dx - dy;
            dy <<= 1;
            for(int i = 0; i <= n; i++)
            {
                if(balance >= 0)
                {
                    x += ix;
                    balance -= dy;
                }
                balance += dx;
                y += iy;
                if(x == X && y == Y)
                    return;
            }

        }
    }

    public void moveTo(BTNode target, int speed)
    {
        moveTo(((BTSprite) (target)).x, ((BTSprite) (target)).y, speed);
    }

    public boolean arrivedTo(int X, int Y)
    {
        return x == X && y == Y;
    }

    public boolean arrivedTo(BTNode target)
    {
        return arrivedTo(((BTSprite) (target)).x, ((BTSprite) (target)).y);
    }

    public boolean arrived()
    {
        return x == X && y == Y;
    }

    public void push(int dx, int dy)
    {
        x += dx;
        y += dy;
    }

    public void move(int dx, int dy)
    {
        x += dx;
        y += dy;
    }

    public void fall(int speed)
    {
        int dv = speed / 4;
        if(dv == 0)
            dv = 1;
        vy += dv;
        y += vy;
        if(y > Y)
        {
            y = Y;
            vy = 0;
            return;
        } else
        {
            return;
        }
    }

    public void hitWith(BTNode pin)
    {
        push(((BTSprite) (pin)).vx / 2, ((BTSprite) (pin)).vy / 2);
    }

    public void shake()
    {
        x += (int)(80D * Math.random() - 40D);
        y += (int)(80D * Math.random() - 40D);
    }

    public static int abs(int a)
    {
        return a >= 0 ? a : -a;
    }

    public static int sign(int a)
    {
        return a >= 0 ? 1 : -1;
    }

    BTSprite()
    {
    }

    static final int VELOCITY = 5;
    int debug;
    int event;
    int flag;
    int mode;
    int side;
    int x;
    int y;
    int X;
    int Y;
    int vx;
    int vy;
}