def check_distance(self, world):
"""
Checks the if there is an object is within the vision cone. Does not return coordinates!
Args:\n
world - The 3d list of the world.
Returns:\n
Normalized distance to the closest object (0-1). 1 if there is no object in range.
"""
if isinstance(self.x, float) or isinstance(
self.y, float) or isinstance(self.z, float):
print(
"Matt, you screwed up somewhere. Why is the sensor coordinates a float"
)
shortest_distance = 1
#Right now is starting from coordnates 1
for i in range(1, self.view_distance + 1): #Forward-Back
for j in range(-1 * math.floor(self.view_height / 2),
math.floor(self.view_height / 2) + 1): #Up-Down
for k in range(-1 * math.floor(self.view_width / 2),
math.floor(self.view_width / 2) +
1): #Left-Right
coords = Direction.calculate_coords(
self.direction, i, self.x, self.y, self.z)
d = Direction.calculate_distance(self.direction, self.x,
self.y, self.z, coords[0],
coords[1], coords[2])
if (not (coords[0] >= len(world.tunnel_world))
and not world.check_space(coords)):
temp = d / self.view_distance
if (temp < shortest_distance):
shortest_distance = temp
return shortest_distance
def check_touch(self, world):
"""
Returns:
True if the sensor is touching something,
False if the sensor is not.
"""
return (Direction.calculate_coords(self.direction, 1, self.x, self.y,
self.z) == 1)
def generate_moves(self, world):
"""
Generates all the possible moves of the agent.
Args:\n
world - A 3d list representing the world
"""
self.moves = []
#init_coords = tuple((self.x, self.y, self.z))
# Goes through each direction
for direction in Direction:
# We can add everything to the list because we are just checking to see if that move is possible
if direction == Direction.NORTH:
current = math.ceil(self.x)
elif direction == Direction.SOUTH:
current = math.floor(self.x)
elif direction == Direction.UP:
current = math.ceil(self.y)
elif direction == Direction.DOWN:
current = math.floor(self.y)
elif direction == Direction.WEST:
current = math.ceil(self.z)
elif direction == Direction.EAST:
current = math.floor(self.z)
# Future at the end of this block will contain the furtherest possible move
future = tuple((self.x, self.y, self.z))
# Facing determines if we are going in a positive or negative direction
facing = numpy.sign(direction.value)
if facing == 0:
facing = 1
# Dim hold the (length, height, width) relative to the direction that it is facing
dim = Direction.calculate_dimensions_by_direction(
direction, self.agent_length, self.agent_height,
self.agent_width)
# This for loop checks v (velocity-value) spaces ahead. Checks the path forward by one unit in each iteration. Accounts for morphology
for dis in range(current, current + facing * self.velocity,
facing):
# Coords holds the range of coords, that represents the path of the block. Vital for accounting for its morphology
#BUG: Problem is here. The calculation doesn't account for "left/right/up/down" "length" when looking that direction
if direction == Direction.NORTH: #Positive X
temp = math.floor(future[0] + dim[0] / 2)
temp_coords = tuple((temp, future[1], future[2]))
elif direction == Direction.SOUTH: #Negative X
temp = math.ceil(future[0] - dim[0] / 2)
temp_coords = tuple((temp, future[1], future[2]))
elif direction == Direction.UP: #Positive Y
temp = math.floor(future[1] + dim[0] / 2)
temp_coords = tuple((future[0], temp, future[2]))
elif direction == Direction.DOWN: #Negative Y
temp = math.ceil(future[1] - dim[0] / 2)
temp_coords = tuple((future[0], temp, future[2]))
elif direction == Direction.WEST: #Positive Z
temp = math.floor(future[2] + dim[0] / 2)
temp_coords = tuple((future[0], future[1], temp))
elif direction == Direction.EAST: #Negative XZ
temp = math.ceil(future[2] - dim[0] / 2)
temp_coords = tuple((future[0], future[1], temp))
coords = Direction.calculate_range(direction, 1,
temp_coords[0],
temp_coords[1],
temp_coords[2], dim[1],
dim[2])
# Checks to see if the path is possible. Re-sets the future coords if possible
if (world.check_spaces(coords[0], coords[1])):
future = Direction.calculate_coords(
direction, 1, future[0], future[1], future[2])
else:
break
# Append the latest possible move of the direciton
self.moves.append(future)
