iframe-proxy | Sunbelt Computer Software

199 lines (150 loc) · 5.24 KB
""" Code example from Complexity and Computation, a book about
exploring complexity science with Python.  Available free from
http://greenteapress.com/complexity
Copyright 2011 Allen B. Downey.
Distributed under the GNU General Public License at gnu.org/licenses/gpl.html.
import math
import random
from swampy.TurtleWorld import TurtleWorld, Turtle
import color_list
class Highway(TurtleWorld):
    """A circular Highway with one lane that spirals down the canvas.
    Attributes:
    rows: the number of rows that spiral down the canvas.
    delay: time between steps in seconds
    colors: list of RGB strings
    def __init__(self):
        TurtleWorld.__init__(self)
        self.rows = 2.0
        self.delay = 0.01
        self.colors = color_list.make_color_dict().values()
    def random_color(self):
        """Returns a random RGB string in #RRGGBB format."""
        return random.choice(self.colors)
    def get_length(self):
        """Returns the total length of this highway."""
        return self.ca_width * self.rows
    def project(self, turtle):
        """Project the turtle onto the highway.
        Reads the Turtle's position position and returns its
        x,y coordinates.
        """
        p = 1.0 * turtle.position % self.get_length()
        x = p % self.ca_width
        y = p / self.ca_width * self.ca_height / self.rows
        return x, y
    def lane_heading(self):
        """Returns the heading that aligns the turtle with the lane."""
        x = self.ca_width
        y = 1.0 * self.ca_height / self.rows
        angle = math.atan2(y, x)
        heading = angle * 180 / math.pi
        return heading
    def step(self):
        """Performs one time step."""
        TurtleWorld.step(self)
        # compute average turtle speed
        total = 0.0
        for turtle in self.animals:
            total += turtle.speed
        print total / len(self.animals)
    def make_drivers(self, n, constructor):
        """Make drivers at random positions.
        Args:
            n: number of Drivers
            constructor: function that returns a Driver
        Returns:
            a list of Drivers.
        """
        t = []
        for i in range(n):
            turtle = constructor(self)
            t.append((turtle.position, turtle))
        # link up the drivers so each has an attribute (next) that
        # refers to the driver in front
        t.sort()
        turtles = [t[1] for t in t]
        for i in range(n-1):
            turtles[i].next = turtles[i+1]
        turtles[-1].next = turtles[0]
        return turtles
class Driver(Turtle):
    """A Turtle with a random position, speed and color."""
    def __init__(self, *args, **kwds):
        Turtle.__init__(self, *args, **kwds)
        self.delay = 0
        self.color = self.world.random_color()
        self.position = random.randrange(0, self.world.get_length())
        self.speed_limit = 4
        self.speed = random.randrange(0, self.speed_limit)
        self.safe_distance = 30
        self.heading = self.world.lane_heading()
        self.next = None
        self.project()
        self.redraw()
    def project(self):
        """Sets x and y according to position."""
        self.x, self.y = self.world.project(self)
    def accelerate(self, change):
        """Speeds up the Turtle by the given amount, within bounds."""
        self.speed += change
        if self.speed < 0:
            self.speed = 0
        if self.speed > self.speed_limit:
            self.speed = self.speed_limit
    def brake(self, change):
        """Slows down the Turtle by the given amount, within bounds."""
        self.accelerate(-change)
    def step(self):
        """Checks the distance to the next driver, adjusts speed, and moves.
        This function enforces the rules for all drivers.
        Driver decision-making is in choose_acceleration().
        """
        dist = self.find_distance()
        # get acceleration
        change = self.choose_acceleration(dist)
        self.accelerate(change)
        # if the resulting speed would cause a collision, jam on the brakes
        if self.speed > dist:
            self.speed = 0
        # move
        self.position += self.speed
        self.project()
        self.redraw()
    def find_distance(self):
        """Finds the distance between this Turtle and the next."""
        dist = self.next.position - self.position
        # deal with wrap-around
        if dist < 0:
            dist += self.world.get_length()
        return dist
    def choose_acceleration(self, dist):
        """Adjusts the speed of the Driver."""
        if dist < self.safe_distance:
            return -1
        else:
            return 0.3
def make_highway(n, driver=Driver):
    """Make the highway and drivers, then run the simulation.
        n: number of Drivers
        driver: constructor
    # create the highway
    world = Highway()
    world.canvas.clear_transforms()
    world.setup_run()
    # create (n) drivers
    world.make_drivers(n, driver)
    # start the simulation, then wait for user events
    print len(world.animals)
    world.run()
    world.mainloop()
def main(script, n=20):
    n = int(n)
    make_highway(n)
if __name__ == '__main__':
    import sys
    main(*sys.argv)
Sunbelt Computer Software

PL/B Language Development and Support

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Sunbelt Computer Software

PL/B Language Development and Support

FilesExpand file tree

Highway.py

Latest commit

History

Highway.py

File metadata and controls
