Boids 2.0 for Python 3.1 (Python recipe) by Stephen Chappell

ActiveState Code (http://code.activestate.com/recipes/576959/)

from tkinter import *
from random import randint, choice
from time import clock, sleep

# TODO: further tweaks
# 1. Add goals for the boids to move toward (DONE - BoidGroup.target)
# 2. Add wind or current that "blows" the boids around
# 3. Have boids tend towards a place; travel through waypoints
# 4. Limit (or unlimit) a boid's speed (DONE - BoidAgent.max_speed)
# 5. Set bounds for boids (DONE - BoidGUI.force_wall & .bounce_wall)
# 6. Allow boids to "perch" on the ground at random.

# TODO: anti-flocking behaviour
# 1. Get the boid group to scatter from each other; add more rules
# 2. Send the boids away from certain areas; danger or obstacles
# 3. Introduce predators that boids will always run from

# TODO: some other details
# 1. Boids need to "see" each other
# 2. Unseen boids should be ignored
# 3. Refer to the original algorithm
# 4. http://www.red3d.com/cwr/boids/
# 5. The timing engine needs redesign (DONE - based on pt.QT.run)
# 6. Change updating system to that used by QuizMe

################################################################################

# Here are various program settings.

USE_WINDOW = False  # Display program in window.
FULLSCREEN = True   # Go fullscreen when executed.

SCR_SAVER = False   # Turn screensaver mode on or off.
COME_BACK = -1      # The program can automatically "restart."
                    # if < 0: Exit program immediately
                    # if = 0: Disable exiting program
                    # if > 0: Come back after X seconds

TITLE = 'BOIDs'     # Title to show in windowed mode.
WIDTH = 800         # Width for window to display in.
HEIGHT = 600        # Height to display in window mode.

BACKGROUND = '#000' # Background color for the screen.
BOIDS = 10          # Number of boids to show in a group.

# BoidGUI and BoidAgent have settings too.

################################################################################

def main():
    # Create the opening window for the program.
    NoDefaultRoot()
    root = Tk()
    assert not (USE_WINDOW and FULLSCREEN), \
           'Only Window or Fullscreen may be used.'
    # Define the closing event handler.
    if COME_BACK < 0:
        def close(event=None):
            root.destroy()
    else:
        def close(event=None):
            if COME_BACK:
                root.withdraw()
                sleep(COME_BACK)
                for child in root.children.values():
                    if isinstance(child, BoidGUI):
                        child.last_time += COME_BACK
                root.deiconify()
    # Create window based on settings.
    if USE_WINDOW:
        root.resizable(False, False)
        root.title(TITLE)
        width = WIDTH
        height = HEIGHT
        position = ''
    elif FULLSCREEN:
        root.overrideredirect(True)
        if not SCR_SAVER:
            root.bind_all('<Escape>', close)
        width = root.winfo_screenwidth()
        height = root.winfo_screenheight()
        position = '+0+0'
    else:
        raise ValueError('Cannot determine window type to use.')
    # Configure the root window as needed.
    root.protocol('WM_DELETE_WINDOW', close)
    if SCR_SAVER:
        assert COME_BACK, 'Screen may not be locked as screensaver.'
        root.bind_all('<Motion>', close)
        root.bind_all('<Key>', close)
    root.geometry('{0}x{1}{2}'.format(width, height, position))
    # Create the application object that handles the GUI.
    app = BoidGUI(root, width, height, BACKGROUND, BOIDS)
    app.grid()
    root.mainloop()

################################################################################

# This function parses color strings.
def parse_color(string):
    assert len(string) == 7 and string[0] == '#', 'Not Color String!'
    number = []
    for index in range(1, len(string) - 1, 2):
        number.append(int(string[index:index+2], 16))
    return tuple(number)

# This function interpolates between two colors.
def interpolate(lower, upper, bias):
    A = 1 - bias
    R = round(lower[0] * A + upper[0] * bias)
    G = round(lower[1] * A + upper[1] * bias)
    B = round(lower[2] * A + upper[2] * bias)
    return R, G, B

################################################################################

class BoidGUI(Canvas):

    # Drawing Options
    BAL_NOT_VEC = True      # Draw balls (True) or vectors (False).
    RANDOM_BACK = False     # Replace background with flashing colors?
    RANDOM_BALL = False     # Replace balls with flashing colors?
    DRAW_TARGET = True      # Show line from groups to their targets?
    # Wall Settings
    WALL_BOUNCE = False     # Bouncy wall if true; force wall if false.
    WALL_MARGIN = 50        # Pixels from edge of screen for boundary.
    WALL_FORCE = 100        # Force applied to balls outside boundary.
    # Random Parameters
    MAX_FPS = 100           # Maximum frame per second for display.
    GROUPS = 2              # Number of groups to have displayed on the GUI.
    # Target Settings
    TARGET_FORCE = 500      # Force exerted by the targets on the boid groups.
    TRIG_DIST = 100         # Distance to target where target gets changed.
    MINI_DIST = 200         # Target must be this far away when recreated.
    # Boid Settings
    MAX_SPEED = 400         # Maximum speed for boids (pixels per second).
    MAX_SIZE = 15           # Largest radius a boid is allowed to have.
    MIN_SIZE = 10           # Smallest radius a boid may be built with.
    # Color Variables
    PALETTE_MODE = True     # Palette mode if true; random mode if false.
    COLORS = '#FF0000', '#FF7F00', '#FFFF00', '#00FF00', '#0000FF', '#FF00FF'
    PALETTE = []
    for x in range(16):
        for y in range(16):
            for z in range(16):
                color = '#{:X}{:X}{:X}'.format(x, y, z)
                PALETTE.append(color)
    # Check the settings up above for errors.
    assert MINI_DIST > TRIG_DIST, 'Targets must be set beyond trigger point.'
    assert MAX_SIZE > MIN_SIZE, 'A minimum may not be larger than maximum.'
    assert len(COLORS) > GROUPS, 'There must be more colors than groups.'

    def __init__(self, master, width, height, background, boids):
        # Initialize the Canvas object.
        cursor = 'none' if SCR_SAVER else ''
        super().__init__(master, width=width, height=height, cursor=cursor,
                         background=background, highlightthickness=0)
        self.width = width
        self.height = height
        self.background = background
        # Create colors for the balls.
        self.create_ball_palette(boids)
        # Build the boid control system.
        self.build_boids(boids)
        # Build loop for frame updating.
        self.last_time = clock()
        self.time_diff = 1 / self.MAX_FPS
        self.after(1000 // self.MAX_FPS, self.update_screen)

    def create_ball_palette(self, size):
        # The last color is not used.
        size += 1
        # Turn the colors into (R, G, B) tuples.
        colors = list(map(parse_color, self.COLORS))
        self.BALL_PALETTE = []
        for index in range(len(colors)):
            # Extract color bounds.
            lower = colors[index]
            upper = colors[(index + 1) % len(colors)]
            palette = []
            # Interpolate colors between the bounds.
            for bias in range(size):
                R, G, B = interpolate(lower, upper, bias / size)
                palette.append('#{0:02X}{1:02X}{2:02X}'.format(R, G, B))
            # Add the new palette to the choice list.
            self.BALL_PALETTE.append(palette)

    def build_boids(self, boids):
        # Build various boid simulation groups.
        self.groups = []
        for group in range(self.GROUPS):
            group = BoidGroup()
            group.palette = choice(self.BALL_PALETTE)
            self.BALL_PALETTE.remove(group.palette)
            # Create a new boid for current group.
            for boid, color in zip(range(boids), group.palette):
                # Place the boid somewhere on screen.
                x = randint(0, self.width)
                y = randint(0, self.height)
                position = Vector2(x, y)
                # Give it a random velocity (within 400).
                velocity = Polar2(randint(1, self.MAX_SPEED), randint(1, 360))
                # Create a random size for the ball.
                size = randint(self.MIN_SIZE, self.MAX_SIZE)
                assert size != 2, 'This is an oddly shaped ball.'
                # Create a boid (with a maximum speed of 400).
                boid = BoidAgent(position, velocity, size, self.MAX_SPEED)
                # Add a color attribute from COLORS list.
                if self.PALETTE_MODE:
                    boid.color = color
                else:
                    boid.color = choice(self.COLORS)
                group.add_boid(boid)
            # Add some mutators to this group.
            if self.WALL_BOUNCE:
                group.add_control(self.bounce_wall)
            else:
                group.add_control(self.force_wall)
            group.add_control(self.motivate)
            # Add a random target attribute to the group.
            x = randint(self.WALL_MARGIN, self.width - self.WALL_MARGIN)
            y = randint(self.WALL_MARGIN, self.height - self.WALL_MARGIN)
            group.target = Vector2(x, y)
            self.groups.append(group)

    def motivate(self, group, boid, seconds):
        # What direction should this boid move in?
        vector = (group.target - boid.position).unit()
        # Adjust velocity according to force and scale.
        boid.velocity += vector * self.TARGET_FORCE * seconds

    def check_target(self):
        for group in self.groups:
            # Is the center of the group within (100) pixels of target?
            if (group.center - group.target).magnitude <= self.TRIG_DIST:
                # Adjust target to be over (200) pixels away.
                while (group.center - group.target).magnitude <= self.MINI_DIST:
                    minimum = self.WALL_MARGIN
                    width = self.width - minimum
                    height = self.height - minimum
                    x = randint(minimum, width)
                    y = randint(minimum, height)
                    group.target = Vector2(x, y)
                # Change the ball colors if they are not random.
                if not self.RANDOM_BALL:
                    if self.PALETTE_MODE:
                        palette = choice(self.BALL_PALETTE)
                        self.BALL_PALETTE.remove(palette)
                        self.BALL_PALETTE.append(group.palette)
                        # Assign colors from new palette.
                        for boid, color in zip(group.boids, palette):
                            boid.color = color
                        group.palette = palette
                    else:
                        # Assign a random color from palette.
                        for boid in group.boids:
                            boid.color = choice(self.COLORS)
                    

    def force_wall(self, group, boid, seconds):
        # Left and Right walls.
        if boid.position.x < self.WALL_MARGIN:
            boid.velocity.x += self.WALL_FORCE * seconds
        elif boid.position.x > self.width - self.WALL_FORCE:
            boid.velocity.x -= self.WALL_FORCE * seconds
        # Upper and Lower walls.
        if boid.position.y < self.WALL_MARGIN:
            boid.velocity.y += self.WALL_FORCE * seconds
        elif boid.position.y > self.height - self.WALL_FORCE:
            boid.velocity.y -= self.WALL_FORCE * seconds

    def bounce_wall(self, group, boid, seconds):
        # Left and Right walls.
        if boid.position.x < self.WALL_MARGIN:
            if boid.velocity.x < 0:
                boid.velocity.x *= -1
        elif boid.position.x > self.width - self.WALL_MARGIN:
            if boid.velocity.x > 0:
                boid.velocity.x *= -1
        # Upper and Lower walls.
        if boid.position.y < self.WALL_MARGIN:
            if boid.velocity.y < 0:
                boid.velocity.y *= -1
        elif boid.position.y > self.height - self.WALL_MARGIN:
            if boid.velocity.y > 0:
                boid.velocity.y *= -1

    def update_screen(self):
        # Clear the screen.
        self.delete(ALL)
        for group in self.groups:
            # Draw the group's target if enabled.
            if self.DRAW_TARGET:
                center = group.center
                target = group.target
                self.create_line(center.x, center.y, target.x, target.y,
                                 fill=choice(self.PALETTE), width=3)
            # Draw all boids in the current group.
            for boid in group.boids:
                # Select correct fill color for drawing.
                fill = choice(self.PALETTE) if self.RANDOM_BALL else boid.color
                if self.BAL_NOT_VEC:
                    # Draw a ball (oval).
                    x1 = boid.position.x - boid.radius
                    y1 = boid.position.y - boid.radius
                    x2 = boid.position.x + boid.radius
                    y2 = boid.position.y + boid.radius
                    self.create_oval((x1, y1, x2, y2), fill=fill)
                else:
                    # Draw a direction pointer.
                    start = boid.position
                    end = boid.velocity.unit() * (boid.radius * 3) + start
                    self.create_line(start.x, start.y, end.x, end.y,
                                     fill=fill, width=3)
        # Randomize the background color if enabled.
        if self.RANDOM_BACK:
            self['background'] = choice(self.PALETTE)
        # Update all group targets as needed.
        self.check_target()
        # Run through the updating routines on the groups.
        time = clock()
        delta = time - self.last_time
        for group in self.groups:
            group.run_controls(delta)
            group.update_velocity()
            group.update_position(delta)
        self.last_time = time
        # Schedule for the next run of this method.
        plus = time + self.time_diff
        over = plus % self.time_diff
        diff = plus - time - over
        self.after(round(diff * 1000), self.update_screen)

import _tkinter # Properly set the GUI's update rate.
_tkinter.setbusywaitinterval(1000 // BoidGUI.MAX_FPS)

################################################################################

# This is where groups and world objects should live.
class BoidWorld:
    pass

################################################################################

class BoidGroup:

    # Simple collection for managing boid agents.

    def __init__(self):
        self.__boids = []
        self.__flag = False
        self.__controls = []
        self.__good_center = False
        self.__prop_center = Vector2(0, 0)
        self.__good_vector = False
        self.__prop_vector = Vector2(0, 0)

    def add_boid(self, boid):
        self.__boids.append(boid)

    def update_velocity(self):
        assert not self.__flag, 'Position must be updated first.'
        self.__flag = True
        for boid in self.__boids:
            boid.update_velocity(self, self.__boids)
        self.__good_vector = False

    def update_position(self, seconds):
        assert self.__flag, 'Velocity must be updated first.'
        self.__flag = False
        for boid in self.__boids:
            boid.update_position(seconds)
        self.__good_center = False

    def add_control(self, control):
        self.__controls.append(control)

    def run_controls(self, seconds):
        for control in self.__controls:
            for boid in self.__boids:
                control(self, boid, seconds)

    @property
    def boids(self):
        for boid in self.__boids:
            yield boid

    @property
    def center(self):
        if self.__good_center == False:
            self.__prop_center = Vector2(0, 0)
            for boid in self.__boids:
                self.__prop_center += boid.position
            self.__prop_center /= len(self.__boids)
            self.__good_center = True
        return self.__prop_center

    @property
    def vector(self):
        if self.__good_vector == False:
            self.__prop_vector = Vector2(0, 0)
            for boid in self.__boids:
                self.__prop_vector += boid.velocity
            self.__prop_vector /= len(self.__boids)
            self.__good_vector = True
        return self.__prop_vector

################################################################################

class BoidAgent:

    # Implements all three boid rules.

    RULE_1_SCALE = 100  # Scale the clumping factor.
    RULE_2_SCALE = 3    # Scale the avoiding factor.
    RULE_2_SPACE = 1    # Avoid when inside of space.
    RULE_3_SCALE = 100  # Scale the schooling factor.

    def __init__(self, position, velocity, radius, max_speed):
        self.position = position
        self.velocity = velocity
        self.__update = Vector2(0, 0)
        self.radius = radius
        self.max_speed = max_speed

    def update_velocity(self, group, boids):
        # Filter self out of boids.
        others = [boid for boid in boids if boid is not self]
        # Run through the boid rules.
        vector_1 = self.__rule_1(others)
        # vector_1 = (group.center - self.position) / 100
        vector_2 = self.__rule_2(others)
        vector_3 = self.__rule_3(others)
        # vector_3 = (group.vector - self.velocity) / 100
        # Save the results.
        self.__update = vector_1 + vector_2 + vector_3

    def update_position(self, seconds):
        # Update to new velocity.
        self.velocity += self.__update
        # Limit the velocity as needed.
        if self.velocity.magnitude > self.max_speed:
            self.velocity /= self.velocity.magnitude / self.max_speed
        # Update our position variable.
        self.position += self.velocity * seconds

    def __rule_1(self, boids):
        # Simulate the clumping factor.
        vector = Vector2(0, 0)
        for boid in boids:
            vector += boid.position
        vector /= len(boids)
        return (vector - self.position) / self.RULE_1_SCALE

    def __rule_2(self, boids):
        # Simulate the avoiding factor.
        vector = Vector2(0, 0)
        for boid in boids:
            delta = (boid.position - self.position).magnitude
            space = (boid.radius + self.radius) * (self.RULE_2_SPACE + 1)
            if delta < space:
                vector += (self.position - boid.position)
        return vector / self.RULE_2_SCALE

    def __rule_3(self, boids):
        # Simulate the schooling factor.
        vector = Vector2(0, 0)
        weight = 0
        for boid in boids:
            r2 = boid.radius ** 2
            vector += boid.velocity * r2
            weight += r2
        vector /= len(boids) * weight
        return (vector - self.velocity) / self.RULE_3_SCALE

################################################################################

from math import *

################################################################################

def Polar2(magnitude, degrees):
    x = magnitude * sin(radians(degrees))
    y = magnitude * cos(radians(degrees))
    return Vector2(x, y)

################################################################################

class Vector2:

    # See all the nice vector operations above?
    # The following class implements those instructions.

    __slots__ = 'x', 'y'

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):
        return 'Vector2({!r}, {!r})'.format(self.x, self.y)

    def polar_repr(self):
        x, y = self.x, self.y
        magnitude = hypot(x, y)
        angle = degrees(atan2(x, y)) % 360
        return 'Polar2({!r}, {!r})'.format(magnitude, angle)

    # Rich Comparison Methods

    def __lt__(self, obj):
        if isinstance(obj, Vector2):
            x1, y1, x2, y2 = self.x, self.y, obj.x, obj.y
            return x1 * x1 + y1 * y1 < x2 * x2 + y2 * y2
        return hypot(self.x, self.y) < obj

    def __le__(self, obj):
        if isinstance(obj, Vector2):
            x1, y1, x2, y2 = self.x, self.y, obj.x, obj.y
            return x1 * x1 + y1 * y1 <= x2 * x2 + y2 * y2
        return hypot(self.x, self.y) <= obj

    def __eq__(self, obj):
        if isinstance(obj, Vector2):
            return self.x == obj.x and self.y == obj.y
        return hypot(self.x, self.y) == obj

    def __ne__(self, obj):
        if isinstance(obj, Vector2):
            return self.x != obj.x or self.y != obj.y
        return hypot(self.x, self.y) != obj

    def __gt__(self, obj):
        if isinstance(obj, Vector2):
            x1, y1, x2, y2 = self.x, self.y, obj.x, obj.y
            return x1 * x1 + y1 * y1 > x2 * x2 + y2 * y2
        return hypot(self.x, self.y) > obj

    def __ge__(self, obj):
        if isinstance(obj, Vector2):
            x1, y1, x2, y2 = self.x, self.y, obj.x, obj.y
            return x1 * x1 + y1 * y1 >= x2 * x2 + y2 * y2
        return hypot(self.x, self.y) >= obj

    # Boolean Operation

    def __bool__(self):
        return self.x != 0 or self.y != 0

    # Container Methods

    def __len__(self):
        return 2

    def __getitem__(self, index):
        return (self.x, self.y)[index]

    def __setitem__(self, index, value):
        temp = [self.x, self.y]
        temp[index] = value
        self.x, self.y = temp

    def __iter__(self):
        yield self.x
        yield self.y

    def __reversed__(self):
        yield self.y
        yield self.x

    def __contains__(self, obj):
        return obj in (self.x, self.y)

    # Binary Arithmetic Operations

    def __add__(self, obj):
        if isinstance(obj, Vector2):
            return Vector2(self.x + obj.x, self.y + obj.y)
        return Vector2(self.x + obj, self.y + obj)

    def __sub__(self, obj):
        if isinstance(obj, Vector2):
            return Vector2(self.x - obj.x, self.y - obj.y)
        return Vector2(self.x - obj, self.y - obj)

    def __mul__(self, obj):
        if isinstance(obj, Vector2):
            return Vector2(self.x * obj.x, self.y * obj.y)
        return Vector2(self.x * obj, self.y * obj)

    def __truediv__(self, obj):
        if isinstance(obj, Vector2):
            return Vector2(self.x / obj.x, self.y / obj.y)
        return Vector2(self.x / obj, self.y / obj)

    def __floordiv__(self, obj):
        if isinstance(obj, Vector2):
            return Vector2(self.x // obj.x, self.y // obj.y)
        return Vector2(self.x // obj, self.y // obj)

    def __mod__(self, obj):
        if isinstance(obj, Vector2):
            return Vector2(self.x % obj.x, self.y % obj.y)
        return Vector2(self.x % obj, self.y % obj)

    def __divmod__(self, obj):
        if isinstance(obj, Vector2):
            return (Vector2(self.x // obj.x, self.y // obj.y),
                    Vector2(self.x % obj.x, self.y % obj.y))
        return (Vector2(self.x // obj, self.y // obj),
                Vector2(self.x % obj, self.y % obj))

    def __pow__(self, obj):
        if isinstance(obj, Vector2):
            return Vector2(self.x ** obj.x, self.y ** obj.y)
        return Vector2(self.x ** obj, self.y ** obj)

    def __lshift__(self, obj):
        if isinstance(obj, Vector2):
            return Vector2(self.x << obj.x, self.y << obj.y)
        return Vector2(self.x << obj, self.y << obj)

    def __rshift__(self, obj):
        if isinstance(obj, Vector2):
            return Vector2(self.x >> obj.x, self.y >> obj.y)
        return Vector2(self.x >> obj, self.y >> obj)

    def __and__(self, obj):
        if isinstance(obj, Vector2):
            return Vector2(self.x & obj.x, self.y & obj.y)
        return Vector2(self.x & obj, self.y & obj)

    def __xor__(self, obj):
        if isinstance(obj, Vector2):
            return Vector2(self.x ^ obj.x, self.y ^ obj.y)
        return Vector2(self.x ^ obj, self.y ^ obj)

    def __or__(self, obj):
        if isinstance(obj, Vector2):
            return Vector2(self.x | obj.x, self.y | obj.y)
        return Vector2(self.x | obj, self.y | obj)

    # Binary Arithmetic Operations (with reflected operands)

    def __radd__(self, obj):
        return Vector2(obj + self.x, obj + self.y)

    def __rsub__(self, obj):
        return Vector2(obj - self.x, obj - self.y)

    def __rmul__(self, obj):
        return Vector2(obj * self.x, obj * self.y)

    def __rtruediv__(self, obj):
        return Vector2(obj / self.x, obj / self.y)

    def __rfloordiv__(self, obj):
        return Vector2(obj // self.x, obj // self.y)

    def __rmod__(self, obj):
        return Vector2(obj % self.x, obj % self.y)

    def __rdivmod__(self, obj):
        return (Vector2(obj // self.x, obj // self.y),
                Vector2(obj % self.x, obj % self.y))

    def __rpow__(self, obj):
        return Vector2(obj ** self.x, obj ** self.y)

    def __rlshift__(self, obj):
        return Vector2(obj << self.x, obj << self.y)

    def __rrshift__(self, obj):
        return Vector2(obj >> self.x, obj >> self.y)

    def __rand__(self, obj):
        return Vector2(obj & self.x, obj & self.y)

    def __rxor__(self, obj):
        return Vector2(obj ^ self.x, obj ^ self.y)

    def __ror__(self, obj):
        return Vector2(obj | self.x, obj | self.y)

    # Augmented Arithmetic Assignments

    def __iadd__(self, obj):
        if isinstance(obj, Vector2):
            self.x += obj.x
            self.y += obj.y
        else:
            self.x += obj
            self.y += obj
        return self

    def __isub__(self, obj):
        if isinstance(obj, Vector2):
            self.x -= obj.x
            self.y -= obj.y
        else:
            self.x -= obj
            self.y -= obj
        return self

    def __imul__(self, obj):
        if isinstance(obj, Vector2):
            self.x *= obj.x
            self.y *= obj.y
        else:
            self.x *= obj
            self.y *= obj
        return self

    def __itruediv__(self, obj):
        if isinstance(obj, Vector2):
            self.x /= obj.x
            self.y /= obj.y
        else:
            self.x /= obj
            self.y /= obj
        return self

    def __ifloordiv__(self, obj):
        if isinstance(obj, Vector2):
            self.x //= obj.x
            self.y //= obj.y
        else:
            self.x //= obj
            self.y //= obj
        return self

    def __imod__(self, obj):
        if isinstance(obj, Vector2):
            self.x %= obj.x
            self.y %= obj.y
        else:
            self.x %= obj
            self.y %= obj
        return self

    def __ipow__(self, obj):        
        if isinstance(obj, Vector2):
            self.x **= obj.x
            self.y **= obj.y
        else:
            self.x **= obj
            self.y **= obj
        return self

    def __ilshift__(self, obj):
        if isinstance(obj, Vector2):
            self.x <<= obj.x
            self.y <<= obj.y
        else:
            self.x <<= obj
            self.y <<= obj
        return self

    def __irshift__(self, obj):
        if isinstance(obj, Vector2):
            self.x >>= obj.x
            self.y >>= obj.y
        else:
            self.x >>= obj
            self.y >>= obj
        return self

    def __iand__(self, obj):
        if isinstance(obj, Vector2):
            self.x &= obj.x
            self.y &= obj.y
        else:
            self.x &= obj
            self.y &= obj
        return self

    def __ixor__(self, obj):
        if isinstance(obj, Vector2):
            self.x ^= obj.x
            self.y ^= obj.y
        else:
            self.x ^= obj
            self.y ^= obj
        return self

    def __ior__(self, obj):
        if isinstance(obj, Vector2):
            self.x |= obj.x
            self.y |= obj.y
        else:
            self.x |= obj
            self.y |= obj
        return self

    # Unary Arithmetic Operations

    def __pos__(self):
        return Vector2(+self.x, +self.y)

    def __neg__(self):
        return Vector2(-self.x, -self.y)

    def __invert__(self):
        return Vector2(~self.x, ~self.y)

    def __abs__(self):
        return Vector2(abs(self.x), abs(self.y))

    # Virtual "magnitude" Attribute
    
    def __fg_ma(self):
        return hypot(self.x, self.y)

    def __fs_ma(self, value):
        x, y = self.x, self.y
        temp = value / hypot(x, y)
        self.x, self.y = x * temp, y * temp

    magnitude = property(__fg_ma, __fs_ma, doc='Virtual "magnitude" Attribute')

    # Virtual "direction" Attribute
    
    def __fg_di(self):
        return atan2(self.y, self.x)

    def __fs_di(self, value):
        temp = hypot(self.x, self.y)
        self.x, self.y = cos(value) * temp, sin(value) * temp

    direction = property(__fg_di, __fs_di, doc='Virtual "direction" Attribute')

    # Virtual "degrees" Attribute
    
    def __fg_de(self):
        return degrees(atan2(self.x, self.y)) % 360

    def __fs_de(self, value):
        temp = hypot(self.x, self.y)
        self.x, self.y = sin(radians(value)) * temp, cos(radians(value)) * temp

    degrees = property(__fg_de, __fs_de, doc='Virtual "degrees" Attribute')

    # Virtual "xy" Attribute

    def __fg_xy(self):
        return self.x, self.y

    def __fs_xy(self, value):
        self.x, self.y = value

    xy = property(__fg_xy, __fs_xy, doc='Virtual "xy" Attribute')

    # Virtual "yx" Attribute

    def __fg_yx(self):
        return self.y, self.x

    def __fs_yx(self, value):
        self.y, self.x = value

    yx = property(__fg_yx, __fs_yx, doc='Virtual "yx" Attribute')

    # Unit Vector Operations

    def unit_vector(self):
        x, y = self.x, self.y
        temp = hypot(x, y)
        return Vector2(x / temp, y / temp)

    def normalize(self):
        x, y = self.x, self.y
        temp = hypot(x, y)
        self.x, self.y = x / temp, y / temp
        return self

    # Vector Multiplication Operations

    def dot_product(self, vec):
        return self.x * vec.x + self.y * vec.y

    def cross_product(self, vec):
        return self.x * vec.y - self.y * vec.x

    # Geometric And Physical Reflections

    def reflect(self, vec):
        x1, y1, x2, y2 = self.x, self.y, vec.x, vec.y
        temp = 2 * (x1 * x2 + y1 * y2) / (x2 * x2 + y2 * y2)
        return Vector2(x2 * temp - x1, y2 * temp - y1)

    def bounce(self, vec):
        x1, y1, x2, y2 = self.x, self.y, +vec.y, -vec.x
        temp = 2 * (x1 * x2 + y1 * y2) / (x2 * x2 + y2 * y2)
        return Vector2(x2 * temp - x1, y2 * temp - y1)

    # Standard Vector Operations

    def project(self, vec):
        x, y = vec.x, vec.y
        temp = (self.x * x + self.y * y) / (x * x + y * y)
        return Vector2(x * temp, y * temp)

    def rotate(self, vec):
        x1, y1, x2, y2 = self.x, self.y, vec.x, vec.y
        return Vector2(x1 * x2 + y1 * y2, y1 * x2 - x1 * y2)

    def interpolate(self, vec, bias):
        a = 1 - bias
        return Vector2(self.x * a + vec.x * bias, self.y * a + vec.y * bias)

    # Other Useful Methods

    def near(self, vec, dist):
        x, y = self.x, self.y
        return x * x + y * y <= dist * dist

    def perpendicular(self):
        return Vector2(+self.y, -self.x)

    def subset(self, vec1, vec2):
        x1, x2 = vec1.x, vec2.x
        if x1 <= x2:
            if x1 <= self.x <= x2:
                y1, y2 = vec1.y, vec2.y
                if y1 <= y2:
                    return y1 <= self.y <= y2
                return y2 <= self.y <= y1
        else:
            if x2 <= self.x <= x1:
                y1, y2 = vec1.y, vec2.y
                if y1 <= y2:
                    return y1 <= self.y <= y2
                return y2 <= self.y <= y1
        return False

    # Synonymous Definitions

    copy = __pos__

    inverse = __neg__

    unit = unit_vector

    dot = dot_product

    cross = cross_product

    lerp = interpolate

    perp = perpendicular

################################################################################

# If this code is run directly,
# run the program's entry point.
if __name__ == '__main__':
    main()