"""This represents any physical object that can appear in an Environment.

def __repr__(self):

return '<{}>'.format(getattr(self, '__name__', self.__class__.__name__))

def is_alive(self):

"""Things that are 'alive' should return true."""

return hasattr(self, 'alive') and self.alive

def show_state(self):

"""Display the agent's internal state. Subclasses should override."""

print("I don't know how to show_state.")

def display(self, canvas, x, y, width, height):

"""Display an image of this Thing on the canvas."""

# Do we need this?

"""An Agent is a subclass of Thing with one required slot,

def __init__(self, program=None):

self.alive = True

self.bump = False

self.holding = []

self.performance = 0

if program is None or not isinstance(program, collections.Callable):

print("Can't find a valid program for {}, falling back to default.".format(

self.__class__.__name__))

def program(percept):

return eval(input('Percept={}; action? '.format(percept)))

self.program = program

def can_grab(self, thing):

"""Return True if this agent can grab this thing.

"""Wrap the agent's program to print its input and output. This will let

old_program = agent.program

def new_program(percept):

action = old_program(percept)

print('{} perceives {} and does {}'.format(agent, percept, action))

return action

agent.program = new_program

"""This agent selects an action based on the percept sequence.

percepts = []

def program(percept):

percepts.append(percept)

action = table.get(tuple(percepts))

return action

"""An agent that chooses an action at random, ignoring all percepts.

"""This agent takes action based solely on the percept. [Figure 2.10]"""

def program(percept):

state = interpret_input(percept)

rule = rule_match(state, rules)

action = rule.action

return action

"""This agent takes action based on the percept and state. [Figure 2.12]"""

def program(percept):

program.state = update_state(program.state, program.action, percept, trainsition_model, sensor_model)

rule = rule_match(program.state, rules)

action = rule.action

return action

program.state = program.action = None

"""Find the first rule that matches state."""

for rule in rules:

if rule.matches(state):

"""Randomly choose one of the actions from the vacuum environment.

"""[Figure 2.3]"""

table = {((loc_A, 'Clean'),): 'Right',

((loc_A, 'Dirty'),): 'Suck',

((loc_B, 'Clean'),): 'Left',

((loc_B, 'Dirty'),): 'Suck',

((loc_A, 'Dirty'), (loc_A, 'Clean')): 'Right',

((loc_A, 'Clean'), (loc_B, 'Dirty')): 'Suck',

((loc_B, 'Clean'), (loc_A, 'Dirty')): 'Suck',

((loc_B, 'Dirty'), (loc_B, 'Clean')): 'Left',

((loc_A, 'Dirty'), (loc_A, 'Clean'), (loc_B, 'Dirty')): 'Suck',

((loc_B, 'Dirty'), (loc_B, 'Clean'), (loc_A, 'Dirty')): 'Suck'

}

"""A reflex agent for the two-state vacuum environment. [Figure 2.8]

def program(percept):

location, status = percept

if status == 'Dirty':

return 'Suck'

elif location == loc_A:

return 'Right'

elif location == loc_B:

return 'Left'

"""An agent that keeps track of what locations are clean or dirty.

model = {loc_A: None, loc_B: None}

def program(percept):

"""Same as ReflexVacuumAgent, except if everything is clean, do NoOp."""

location, status = percept

model[location] = status # Update the model here

if model[loc_A] == model[loc_B] == 'Clean':

return 'NoOp'

elif status == 'Dirty':

return 'Suck'

elif location == loc_A:

return 'Right'

elif location == loc_B:

return 'Left'

"""Abstract class representing an Environment. 'Real' Environment classes

def __init__(self):

self.things = []

self.agents = []

def thing_classes(self):

return [] # List of classes that can go into environment

def percept(self, agent):

"""Return the percept that the agent sees at this point. (Implement this.)"""

raise NotImplementedError

def execute_action(self, agent, action):

"""Change the world to reflect this action. (Implement this.)"""

raise NotImplementedError

def default_location(self, thing):

"""Default location to place a new thing with unspecified location."""

return None

def exogenous_change(self):

"""If there is spontaneous change in the world, override this."""

pass

def is_done(self):

"""By default, we're done when we can't find a live agent."""

return not any(agent.is_alive() for agent in self.agents)

def step(self):

"""Run the environment for one time step. If the

if not self.is_done():

actions = []

for agent in self.agents:

if agent.alive:

actions.append(agent.program(self.percept(agent)))

else:

actions.append("")

for (agent, action) in zip(self.agents, actions):

self.execute_action(agent, action)

self.exogenous_change()

def run(self, steps=1000):

"""Run the Environment for given number of time steps."""

for step in range(steps):

if self.is_done():

return

self.step()

def list_things_at(self, location, tclass=Thing):

"""Return all things exactly at a given location."""

return [thing for thing in self.things

if thing.location == location and isinstance(thing, tclass)]

def some_things_at(self, location, tclass=Thing):

"""Return true if at least one of the things at location

return self.list_things_at(location, tclass) != []

def add_thing(self, thing, location=None):

"""Add a thing to the environment, setting its location. For

if not isinstance(thing, Thing):

thing = Agent(thing)

if thing in self.things:

print("Can't add the same thing twice")

else:

thing.location = location if location is not None else self.default_location(thing)

self.things.append(thing)

if isinstance(thing, Agent):

thing.performance = 0

self.agents.append(thing)

def delete_thing(self, thing):

"""Remove a thing from the environment."""

try:

self.things.remove(thing)

except ValueError as e:

print(e)

print(" in Environment delete_thing")

print(" Thing to be removed: {} at {}".format(thing, thing.location))

print(" from list: {}".format([(thing, thing.location) for thing in self.things]))

if thing in self.agents:

"""A direction class for agents that want to move in a 2D plane

R = "right"

L = "left"

U = "up"

D = "down"

def __init__(self, direction):

self.direction = direction

def __add__(self, heading):

"""

if self.direction == self.R:

return{

self.R: Direction(self.D),

self.L: Direction(self.U),

}.get(heading, None)

elif self.direction == self.L:

return{

self.R: Direction(self.U),

self.L: Direction(self.D),

}.get(heading, None)

elif self.direction == self.U:

return{

self.R: Direction(self.R),

self.L: Direction(self.L),

}.get(heading, None)

elif self.direction == self.D:

return{

self.R: Direction(self.L),

self.L: Direction(self.R),

}.get(heading, None)

def move_forward(self, from_location):

"""

x, y = from_location

if self.direction == self.R:

return (x + 1, y)

elif self.direction == self.L:

return (x - 1, y)

elif self.direction == self.U:

return (x, y - 1)

elif self.direction == self.D:

"""This class is for environments on a 2D plane, with locations

def __init__(self, width=10, height=10):

super().__init__()

self.width = width

self.height = height

self.observers = []

# Sets iteration start and end (no walls).

self.x_start, self.y_start = (0, 0)

self.x_end, self.y_end = (self.width, self.height)

perceptible_distance = 1

def things_near(self, location, radius=None):

"""Return all things within radius of location."""

if radius is None:

radius = self.perceptible_distance

radius2 = radius * radius

return [(thing, radius2 - distance_squared(location, thing.location))

for thing in self.things if distance_squared(

location, thing.location) <= radius2]

def percept(self, agent):

"""By default, agent perceives things within a default radius."""

return self.things_near(agent.location)

def execute_action(self, agent, action):

agent.bump = False

if action == 'TurnRight':

agent.direction += Direction.R

elif action == 'TurnLeft':

agent.direction += Direction.L

elif action == 'Forward':

agent.bump = self.move_to(agent, agent.direction.move_forward(agent.location))

elif action == 'Release':

if agent.holding:

agent.holding.pop()

def default_location(self, thing):

return (random.choice(self.width), random.choice(self.height))

def move_to(self, thing, destination):

"""Move a thing to a new location. Returns True on success or False if there is an Obstacle.

thing.bump = self.some_things_at(destination, Obstacle)

if not thing.bump:

thing.location = destination

for o in self.observers:

o.thing_moved(thing)

for t in thing.holding:

self.delete_thing(t)

self.add_thing(t, destination)

t.location = destination

return thing.bump

def add_thing(self, thing, location=(1, 1), exclude_duplicate_class_items=False):

"""Add things to the world. If (exclude_duplicate_class_items) then the item won't be

if (self.is_inbounds(location)):

if (exclude_duplicate_class_items and

any(isinstance(t, thing.__class__) for t in self.list_things_at(location))):

return

super().add_thing(thing, location)

def is_inbounds(self, location):

"""Checks to make sure that the location is inbounds (within walls if we have walls)"""

x, y = location

return not (x < self.x_start or x >= self.x_end or y < self.y_start or y >= self.y_end)

def random_location_inbounds(self, exclude=None):

"""Returns a random location that is inbounds (within walls if we have walls)"""

location = (random.randint(self.x_start, self.x_end),

random.randint(self.y_start, self.y_end))

if exclude is not None:

while(location == exclude):

location = (random.randint(self.x_start, self.x_end),

random.randint(self.y_start, self.y_end))

return location

def delete_thing(self, thing):

"""Deletes thing, and everything it is holding (if thing is an agent)"""

if isinstance(thing, Agent):

for obj in thing.holding:

super().delete_thing(obj)

for obs in self.observers:

obs.thing_deleted(obj)

super().delete_thing(thing)

for obs in self.observers:

obs.thing_deleted(thing)

def add_walls(self):

"""Put walls around the entire perimeter of the grid."""

for x in range(self.width):

self.add_thing(Wall(), (x, 0))

self.add_thing(Wall(), (x, self.height - 1))

for y in range(1, self.height-1):

self.add_thing(Wall(), (0, y))

self.add_thing(Wall(), (self.width - 1, y))

# Updates iteration start and end (with walls).

self.x_start, self.y_start = (1, 1)

self.x_end, self.y_end = (self.width - 1, self.height - 1)

def add_observer(self, observer):

"""Adds an observer to the list of observers.

self.observers.append(observer)

def turn_heading(self, heading, inc):

"""Return the heading to the left (inc=+1) or right (inc=-1) of heading."""

def __init__(self, width=10, height=10, boundary=True, color={}, display=False):

"""Define all the usual XYEnvironment characteristics,

super().__init__(width, height)

self.grid = BlockGrid(width, height, fill=(200, 200, 200))

if display:

self.grid.show()

self.visible = True

else:

self.visible = False

self.bounded = boundary

self.colors = color

def get_world(self):

"""Returns all the items in the world in a format

result = []

x_start, y_start = (0, 0)

x_end, y_end = self.width, self.height

for x in range(x_start, x_end):

row = []

for y in range(y_start, y_end):

row.append(self.list_things_at([x, y]))

result.append(row)

return result

"""

def run(self, steps=1000, delay=1):

"""Run the Environment for given number of time steps,

for step in range(steps):

self.update(delay)

if self.is_done():

break

self.step()

self.update(delay)

def update(self, delay=1):

sleep(delay)

if self.visible:

self.conceal()

self.reveal()

else:

self.reveal()

def reveal(self):

"""Display the BlockGrid for this world - the last thing to be added

self.draw_world()

self.grid.show()

self.visible = True

def draw_world(self):

self.grid[:] = (200, 200, 200)

world = self.get_world()

for x in range(0, len(world)):

for y in range(0, len(world[x])):

if len(world[x][y]):

self.grid[y, x] = self.colors[world[x][y][-1].__class__.__name__]

def conceal(self):

"""Hide the BlockGrid for this world"""

self.visible = False

"""Model for Continuous World"""

def __init__(self, width=10, height=10):

super().__init__()

self.width = width

self.height = height

def add_obstacle(self, coordinates):

def __init__(self, coordinates):

"""Coordinates is a list of tuples."""

super().__init__()

"""The environment of [Ex. 2.12]. Agent perceives dirty or clean,

def __init__(self, width=10, height=10):

super().__init__(width, height)

self.add_walls()

def thing_classes(self):

return [Wall, Dirt, ReflexVacuumAgent, RandomVacuumAgent,

TableDrivenVacuumAgent, ModelBasedVacuumAgent]

def percept(self, agent):

"""The percept is a tuple of ('Dirty' or 'Clean', 'Bump' or 'None').

status = ('Dirty' if self.some_things_at(

agent.location, Dirt) else 'Clean')

bump = ('Bump' if agent.bump else'None')

return (status, bump)

def execute_action(self, agent, action):

agent.bump = False

if action == 'Suck':

dirt_list = self.list_things_at(agent.location, Dirt)

if dirt_list != []:

dirt = dirt_list[0]

agent.performance += 100

self.delete_thing(dirt)

else:

super().execute_action(agent, action)

if action != 'NoOp':

"""This environment has two locations, A and B. Each can be Dirty

def __init__(self):

super().__init__()

self.status = {loc_A: random.choice(['Clean', 'Dirty']),

loc_B: random.choice(['Clean', 'Dirty'])}

def thing_classes(self):

return [Wall, Dirt, ReflexVacuumAgent, RandomVacuumAgent,

TableDrivenVacuumAgent, ModelBasedVacuumAgent]

def percept(self, agent):

"""Returns the agent's location, and the location status (Dirty/Clean)."""

return (agent.location, self.status[agent.location])

def execute_action(self, agent, action):

"""Change agent's location and/or location's status; track performance.

if action == 'Right':

agent.location = loc_B

agent.performance -= 1

elif action == 'Left':

agent.location = loc_A

agent.performance -= 1

elif action == 'Suck':

if self.status[agent.location] == 'Dirty':

agent.performance += 10

self.status[agent.location] = 'Clean'

def default_location(self, thing):

"""Agents start in either location at random."""

def __eq__(self, rhs):

"""All Gold are equal"""

return rhs.__class__ == Gold

holding = []

has_arrow = True

killed_by = ""

direction = Direction("right")

def can_grab(self, thing):

"""Explorer can only grab gold"""

pit_probability = 0.2 # Probability to spawn a pit in a location. (From Chapter 7.2)

# Room should be 4x4 grid of rooms. The extra 2 for walls

def __init__(self, agent_program, width=6, height=6):

super().__init__(width, height)

self.init_world(agent_program)

def init_world(self, program):

"""Spawn items in the world based on probabilities from the book"""

"WALLS"

self.add_walls()

"PITS"

for x in range(self.x_start, self.x_end):

for y in range(self.y_start, self.y_end):

if random.random() < self.pit_probability:

self.add_thing(Pit(), (x, y), True)

self.add_thing(Breeze(), (x - 1, y), True)

self.add_thing(Breeze(), (x, y - 1), True)

self.add_thing(Breeze(), (x + 1, y), True)

self.add_thing(Breeze(), (x, y + 1), True)

"WUMPUS"

w_x, w_y = self.random_location_inbounds(exclude=(1, 1))

self.add_thing(Wumpus(lambda x: ""), (w_x, w_y), True)

self.add_thing(Stench(), (w_x - 1, w_y), True)

self.add_thing(Stench(), (w_x + 1, w_y), True)

self.add_thing(Stench(), (w_x, w_y - 1), True)

self.add_thing(Stench(), (w_x, w_y + 1), True)

"GOLD"

self.add_thing(Gold(), self.random_location_inbounds(exclude=(1, 1)), True)

"AGENT"

self.add_thing(Explorer(program), (1, 1), True)

def get_world(self, show_walls=True):

"""Return the items in the world"""

result = []

x_start, y_start = (0, 0) if show_walls else (1, 1)

if show_walls:

x_end, y_end = self.width, self.height

else:

x_end, y_end = self.width - 1, self.height - 1

for x in range(x_start, x_end):

row = []

for y in range(y_start, y_end):

row.append(self.list_things_at((x, y)))

result.append(row)

return result

def percepts_from(self, agent, location, tclass=Thing):

"""Return percepts from a given location,

thing_percepts = {

Gold: Glitter(),

Wall: Bump(),

Wumpus: Stench(),

Pit: Breeze()}

"""Agents don't need to get their percepts"""

thing_percepts[agent.__class__] = None

"""Gold only glitters in its cell"""

if location != agent.location:

thing_percepts[Gold] = None

result = [thing_percepts.get(thing.__class__, thing) for thing in self.things

if thing.location == location and isinstance(thing, tclass)]

return result if len(result) else [None]

def percept(self, agent):

"""Return things in adjacent (not diagonal) cells of the agent.

x, y = agent.location

result = []

result.append(self.percepts_from(agent, (x - 1, y)))

result.append(self.percepts_from(agent, (x + 1, y)))

result.append(self.percepts_from(agent, (x, y - 1)))

result.append(self.percepts_from(agent, (x, y + 1)))

result.append(self.percepts_from(agent, (x, y)))

"""The wumpus gives out a loud scream once it's killed."""

wumpus = [thing for thing in self.things if isinstance(thing, Wumpus)]

if len(wumpus) and not wumpus[0].alive and not wumpus[0].screamed:

result[-1].append(Scream())

wumpus[0].screamed = True

return result

def execute_action(self, agent, action):

"""Modify the state of the environment based on the agent's actions.

if isinstance(agent, Explorer) and self.in_danger(agent):

return

agent.bump = False

if action == 'TurnRight':

agent.direction += Direction.R

agent.performance -= 1

elif action == 'TurnLeft':

agent.direction += Direction.L

agent.performance -= 1

elif action == 'Forward':

agent.bump = self.move_to(agent, agent.direction.move_forward(agent.location))

agent.performance -= 1

elif action == 'Grab':

things = [thing for thing in self.list_things_at(agent.location)

if agent.can_grab(thing)]

if len(things):

print("Grabbing", things[0].__class__.__name__)

if len(things):

agent.holding.append(things[0])

agent.performance -= 1

elif action == 'Climb':

if agent.location == (1, 1): # Agent can only climb out of (1,1)

agent.performance += 1000 if Gold() in agent.holding else 0

self.delete_thing(agent)

elif action == 'Shoot':

"""The arrow travels straight down the path the agent is facing"""

if agent.has_arrow:

arrow_travel = agent.direction.move_forward(agent.location)

while(self.is_inbounds(arrow_travel)):

wumpus = [thing for thing in self.list_things_at(arrow_travel)

if isinstance(thing, Wumpus)]

if len(wumpus):

wumpus[0].alive = False

break

arrow_travel = agent.direction.move_forward(agent.location)

agent.has_arrow = False

def in_danger(self, agent):

"""Check if Explorer is in danger (Pit or Wumpus), if he is, kill him"""

for thing in self.list_things_at(agent.location):

if isinstance(thing, Pit) or (isinstance(thing, Wumpus) and thing.alive):

agent.alive = False

agent.performance -= 1000

agent.killed_by = thing.__class__.__name__

return True

return False

def is_done(self):

"""The game is over when the Explorer is killed

explorer = [agent for agent in self.agents if isinstance(agent, Explorer)]

if len(explorer):

if explorer[0].alive:

return False

else:

print("Death by {} [-1000].".format(explorer[0].killed_by))

else:

print("Explorer climbed out {}."

.format(

"with Gold [+1000]!" if Gold() not in self.things else "without Gold [+0]"))

return True

"""See how well each of several agents do in n instances of an environment.