def post_connect(self, agent_id, entities, config):
self.entity_id = agent_id
self.world_model = WorldModel()
self.world_model.add_entities(entities)
#todo: check whether we need to merge agent config and the config coming from kernel
self.config = config
print('post_connect agent_id:' + str(agent_id.get_value()))
def _update_receive_ball(self):
ball_pose = WorldModel.get_pose('Ball')
ball_vel = WorldModel.get_velocity('Ball')
result = False
if WorldModel.ball_is_moving():
angle_velocity = tool.getAngleFromCenter(ball_vel)
trans = tool.Trans(ball_pose, angle_velocity)
role_pose = WorldModel.get_pose(self._my_role)
if role_pose is None:
return False
tr_pose = trans.transform(role_pose)
fabs_y = math.fabs(tr_pose.y)
if self._receiving == False and \
fabs_y < self._can_receive_dist - self._can_receive_hysteresis:
self._receiving = True
elif self._receiving == True and \
fabs_y > self._can_receive_dist + self._can_receive_hysteresis:
self._receiving = False
if self._receiving and tr_pose.x > 0.0:
tr_pose.y = 0.0
inv_pose = trans.invertedTransform(tr_pose)
angle_to_ball = tool.getAngle(inv_pose, ball_pose)
self.pose = Pose(inv_pose.x, inv_pose.y, angle_to_ball)
result = True
return result
def _update_interpose(self):
base_pose = WorldModel.get_pose(self._base)
target_pose = WorldModel.get_pose(self._target)
if base_pose is None or target_pose is None:
return False
angle_to_target = tool.getAngle(base_pose, target_pose)
interposed_pose = Pose(0, 0, 0)
if not self._to_dist is None:
trans = tool.Trans(base_pose, angle_to_target)
tr_interposed_pose = Pose(self._to_dist, 0.0, 0)
interposed_pose = trans.invertedTransform(tr_interposed_pose)
elif not self._from_dist is None:
angle_to_base = tool.getAngle(target_pose, base_pose)
trans = tool.Trans(target_pose, angle_to_base)
tr_interposed_pose = Pose(self._from_dist, 0.0, 0)
interposed_pose = trans.invertedTransform(tr_interposed_pose)
interposed_pose.theta = angle_to_target
self.pose = interposed_pose
return True
def connect(self, host, port, teamname, version=11):
"""
Gives us a connection to the server as one player on a team. This
immediately connects the agent to the server and starts receiving and
parsing the information it sends.
"""
# if already connected, raise an error since user may have wanted to
# connect again to a different server.
if self.__connected:
msg = "Cannot connect while already connected, disconnect first."
raise sp_exceptions.AgentConnectionStateError(msg)
# the pipe through which all of our communication takes place
self.__sock = sock.Socket(host, port)
# our models of the world and our body
self.wm = WorldModel(handler.ActionHandler(self.__sock))
# set the team name of the world model to the given name
self.wm.teamname = teamname
# handles all messages received from the server
self.msg_handler = handler.MessageHandler(self.wm)
# set up our threaded message receiving system
self.__parsing = True # tell thread that we're currently running
self.__msg_thread = threading.Thread(target=self.__message_loop,
name="message_loop")
self.__msg_thread.daemon = True # dies when parent thread dies
# start processing received messages. this will catch the initial server
# response and all subsequent communication.
self.__msg_thread.start()
# send the init message and allow the message handler to handle further
# responses.
init_address = self.__sock.address
init_msg = "(init %s (version %d))"
self.__sock.send(init_msg % (teamname, version))
# wait until the socket receives a response from the server and gets its
# assigned port.
while self.__sock.address == init_address:
time.sleep(0.0001)
# create our thinking thread. this will perform the actions necessary
# to play a game of robo-soccer.
self.__thinking = False
self.__think_thread = threading.Thread(target=self.__think_loop,
name="think_loop")
self.__think_thread.daemon = True
# set connected state. done last to prevent state inconsistency if
# something goes wrong beforehand.
self.__connected = True
def update(self):
WorldModel.update_world()
self._select_play()
WorldModel.update_assignments(self._play.assignment_type)
self._execute_play()
self._evaluate_play()
def run_simulated_mission(model, display=None, use_delays=False):
print("Simulated mission running.")
world_model = WorldModel(BLUEPRINT, CONFIG_FILE, simulated=True)
ticks_left = 5 * MAX_EPISODE_TIME
total_reward = 0
current_r = 0
while (ticks_left > 0 and world_model.is_mission_running()):
ticks_left -= 1
current_r = world_model.reward()
action = model.act(current_r, world_model.get_observation())
if display is not None:
display.update(world_model)
total_reward += current_r
world_model.simulate(action)
if use_delays:
print(action)
time.sleep(ACTION_DELAY)
# Collect last reward, and give to model, then end the mission
current_r = world_model.reward()
model.act(current_r, world_model.get_observation())
total_reward += current_r
model.mission_ended()
print("Simulated mission ended")
return total_reward, (MAX_EPISODE_TIME - (ticks_left / 5))
def load(dir):
with open(f"{dir}/planner.pkl", 'rb') as f:
planner = pickle.load(f)
planner.world_model = WorldModel.load(dir)
return planner
def connect(self, host, port, teamname, version=11, goalie=False):
"""
Gives us a connection to the server as one player on a team. This
immediately connects the agent to the server and starts receiving and
parsing the information it sends.
"""
# if already connected, raise an error since user may have wanted to
# connect again to a different server.
if self.__connected:
msg = "Cannot connect while already connected, disconnect first."
raise sp_exceptions.AgentConnectionStateError(msg)
# the pipe through which all of our communication takes place
self.__sock = sock.Socket(host, port)
# our models of the world and our body
self.wm = WorldModel(handler.ActionHandler(self.__sock))
# set the team name of the world model to the given name
self.wm.teamname = teamname
# handles all messages received from the server
self.msg_handler = handler.MessageHandler(self.wm)
# set up our threaded message receiving system
self.__parsing = True # tell thread that we're currently running
self.__msg_thread = threading.Thread(target=self.__message_loop,
name="message_loop")
self.__msg_thread.daemon = True # dies when parent thread dies
# start processing received messages. this will catch the initial server
# response and all subsequent communication.
self.__msg_thread.start()
# send the init message and allow the message handler to handle further
# responses.
init_address = self.__sock.address
if goalie is True:
init_msg = "(init %s (version %d)(goalie))"
else:
init_msg = "(init %s (version %d))"
self.__sock.send(init_msg % (teamname, version))
# wait until the socket receives a response from the server and gets its
# assigned port.
while self.__sock.address == init_address:
time.sleep(0.0001)
# create our thinking thread. this will perform the actions necessary
# to play a game of robo-soccer.
self.__thinking = False
self.__think_thread = threading.Thread(target=self.__think_loop,
name="think_loop")
self.__think_thread.daemon = True
# set connected state. done last to prevent state inconsistency if
# something goes wrong beforehand.
self.__connected = True
async def on_start(self):
self.terminate = False
self.SUCCESS = False
self.verbose = False
# Initialization
self.beliefs = WorldModel() # B := B0; Initial Beliefs
self.goals = self.beliefs.current_world_model.goals
self.intentions = self.beliefs.current_world_model.goals # I := I0; Initial Intentions
self.htn_planner = HierarchicalTaskNetworkPlanner(self.beliefs)
self.perception = Perception(self.beliefs)
self.coordination = Coordination(self.beliefs)
self.monitoring = Monitoring()
self.what, self.why, self.how_well, self.what_else, self.why_failed = "", "", "", "", ""
self.plans = []
self.selected_plan = []
self.percept = {}
self.action = ""
self.start_time = datetime.datetime.now()
def _update_intersection(self):
target_pose = WorldModel.get_pose(self._target)
base_pose = WorldModel.get_pose(self._base)
if target_pose is None or base_pose is None:
return False
intersection = tool.get_intersection(base_pose, target_pose,
self._pose1, self._pose2)
angle = tool.getAngle(intersection, target_pose)
intersection.x = tool.limit(intersection.x, self._range_x[0],
self._range_x[1])
intersection.y = tool.limit(intersection.y, self._range_y[0],
self._range_y[1])
self.pose = Pose(intersection.x, intersection.y, angle)
return True
def run_simulated_mission(model, mission, cfg, demo=False):
print("Simulated mission running.")
world_model = WorldModel(mission.blueprint,
cfg,
simulated=True,
agent_pos=mission.start_position)
ticks_left = 5 * mission.max_episode_time
total_reward = 0
current_r = 0
use_delays = mission.action_delay > 0
while (ticks_left > 0 and world_model.is_mission_running()):
ticks_left -= 1
current_r = world_model.reward()
if demo:
action = model.demo_act(world_model.get_observation())
else:
action = model.act(current_r, world_model.get_observation())
if mission.display is not None:
mission.display.update(world_model)
total_reward += current_r
world_model.simulate(action)
if use_delays:
print(action)
time.sleep(mission.action_delay)
# Collect last reward, and give to model, then end the mission
if mission.display is not None:
mission.display.update(world_model)
current_r = world_model.reward()
if not demo:
model.act(current_r, world_model.get_observation())
total_reward += current_r
model.mission_ended()
print("Simulated mission ended")
return MissionStats(reward=total_reward,
length=(mission.max_episode_time - (ticks_left / 5)))
async def setup(self):
print(
f"--- arm_agent: PeriodicSenderAgent started at {datetime.datetime.now().time()}"
)
init_world_model = WorldModel()
start_at = datetime.datetime.now() + datetime.timedelta(
seconds=init_world_model.current_world_model.
init_delay_seconds["arm"])
bdi_behaviour = self.BDIBehaviour(
period=init_world_model.current_world_model.
real_time_clock_period_seconds["arm"],
start_at=start_at)
self.add_behaviour(bdi_behaviour)
async def on_start(self):
self.terminate = False
self.SUCCESS = False
self.verbose = False
# Initialization
self.htn_planner = HierarchicalTaskNetworkPlanner()
self.goal = [('transfer_target_object_to_container', 'arm',
'target_object', 'table', 'container')]
self.intentions = self.goal # I := I0; Initial Intentions
self.beliefs = WorldModel() # B := B0; Initial Beliefs
self.monitoring = Monitoring()
self.perception = Perception()
self.coordination = Coordination()
# Disable all 3 coordination switches for testing
self.coordination.control.send_requests = True
self.coordination.control.center_init = False
self.coordination.control.detect_last_position = True
self.what, self.why, self.how_well, self.what_else, self.why_failed = "", "", "", "", ""
self.plans = []
self.start_time = datetime.datetime.now()
def _update_keep_y(self):
target_pose = WorldModel.get_pose(self._target)
if target_pose is None:
return False
keep_pose = Pose(target_pose.x, self._keep_y, 0.0)
keep_pose.x = tool.limit(keep_pose.x, self._range_x[0],
self._range_x[1])
angle = tool.getAngle(keep_pose, target_pose)
self.pose = Pose(keep_pose.x, keep_pose.y, angle)
return True
def is_arrived(self, role):
# robotが目標位置に到着したかを判断する
# 厳し目につける
role_pose = WorldModel.get_pose(role)
if role_pose is None:
return False
arrived = False
distance = tool.getSize(self.pose, role_pose)
# 目標位置との距離、目標角度との差がtolerance以下であれば到着判定
if distance < self._arrived_position_tolerance:
diff_angle = tool.normalize(self.pose.theta - role_pose.theta)
if tool.normalize(diff_angle) < self._arrived_angle_tolerance:
arrived = True
return arrived
def _update_look_intersection(self):
target_pose = WorldModel.get_pose(self._target)
if target_pose is None:
return False
target_theta = target_pose.theta
dist = 300 # フィールドサイズが300 mを超えたら書き直す必要あり
look_pose = Pose(dist * math.cos(target_theta),
dist * math.sin(target_theta), 0)
intersection = tool.get_intersection(look_pose, target_pose,
self._pose1, self._pose2)
angle = tool.getAngle(intersection, target_pose)
intersection.x = tool.limit(intersection.x, self._range_x[0],
self._range_x[1])
intersection.y = tool.limit(intersection.y, self._range_y[0],
self._range_y[1])
self.pose = Pose(intersection.x, intersection.y, angle)
return True
class Agent:
def __init__(self):
# whether we're connected to a server yet or not
self.__connected = False
# set all variables and important objects to appropriate values for
# pre-connect state.
# the socket used to communicate with the server
self.__sock = None
# models and the message handler for parsing and storing information
self.wm = None
self.msg_handler = None
# parse thread and control variable
self.__parsing = False
self.__msg_thread = None
self.__thinking = False # think thread and control variable
self.__think_thread = None
# whether we should run the think method
self.__should_think_on_data = False
# whether we should send commands
self.__send_commands = False
self.goal_pos = None
def connect(self, host, port, teamname, version=11, goalie=False):
"""
Gives us a connection to the server as one player on a team. This
immediately connects the agent to the server and starts receiving and
parsing the information it sends.
"""
# if already connected, raise an error since user may have wanted to
# connect again to a different server.
if self.__connected:
msg = "Cannot connect while already connected, disconnect first."
raise sp_exceptions.AgentConnectionStateError(msg)
# the pipe through which all of our communication takes place
self.__sock = sock.Socket(host, port)
# our models of the world and our body
self.wm = WorldModel(handler.ActionHandler(self.__sock))
# set the team name of the world model to the given name
self.wm.teamname = teamname
# handles all messages received from the server
self.msg_handler = handler.MessageHandler(self.wm)
# set up our threaded message receiving system
self.__parsing = True # tell thread that we're currently running
self.__msg_thread = threading.Thread(target=self.__message_loop,
name="message_loop")
self.__msg_thread.daemon = True # dies when parent thread dies
# start processing received messages. this will catch the initial server
# response and all subsequent communication.
self.__msg_thread.start()
# send the init message and allow the message handler to handle further
# responses.
init_address = self.__sock.address
if goalie is True:
init_msg = "(init %s (version %d)(goalie))"
else:
init_msg = "(init %s (version %d))"
self.__sock.send(init_msg % (teamname, version))
# wait until the socket receives a response from the server and gets its
# assigned port.
while self.__sock.address == init_address:
time.sleep(0.0001)
# create our thinking thread. this will perform the actions necessary
# to play a game of robo-soccer.
self.__thinking = False
self.__think_thread = threading.Thread(target=self.__think_loop,
name="think_loop")
self.__think_thread.daemon = True
# set connected state. done last to prevent state inconsistency if
# something goes wrong beforehand.
self.__connected = True
def goto_kickoff_position(self):
"""
Return the Agent to the kickoff position
"""
# move player to kickoff location
self.wm.teleport_to_point(self.calc_kickoff_pos())
def calc_kickoff_pos(self):
"""
Calculate the Agent's kickoff position
on the soccer field
"""
# used to flip x coords for other side
side_mod = 1
if self.wm.side == WorldModel.SIDE_R:
side_mod = -1
if self.wm.uniform_number == 1:
return (-5 * side_mod, 30)
elif self.wm.uniform_number == 2:
return (-40 * side_mod, 15)
elif self.wm.uniform_number == 3:
return (-40 * side_mod, 00)
elif self.wm.uniform_number == 4:
return (-40 * side_mod, -15)
elif self.wm.uniform_number == 5:
return (-5 * side_mod, -30)
elif self.wm.uniform_number == 6:
return (-20 * side_mod, 20)
elif self.wm.uniform_number == 7:
return (-20 * side_mod, 0)
elif self.wm.uniform_number == 8:
return (-20 * side_mod, -20)
elif self.wm.uniform_number == 9:
return (-10 * side_mod, 0)
elif self.wm.uniform_number == 10:
return (-10 * side_mod, 20)
elif self.wm.uniform_number == 11:
return (-10 * side_mod, -20)
# an error occured, place the player at 0,0
return (0, 0)
def play(self):
"""
Kicks off the thread that does the agent's thinking, allowing it to play
during the game. Throws an exception if called while the agent is
already playing.
"""
# ensure we're connected before doing anything
if not self.__connected:
msg = "Must be connected to a server to begin play."
raise sp_exceptions.AgentConnectionStateError(msg)
# throw exception if called while thread is already running
if self.__thinking:
raise sp_exceptions.AgentAlreadyPlayingError(
"Agent is already playing.")
# run the method that sets up the agent's persistant variables
self.setup_environment()
# tell the thread that it should be running, then start it
self.__thinking = True
self.__should_think_on_data = True
self.__think_thread.start()
def disconnect(self):
"""
Tell the loop threads to stop and signal the server that we're
disconnecting, then join the loop threads and destroy all our inner
methods.
Since the message loop thread can conceiveably block indefinitely while
waiting for the server to respond, we only allow it (and the think loop
for good measure) a short time to finish before simply giving up.
Once an agent has been disconnected, it is 'dead' and cannot be used
again. All of its methods get replaced by a method that raises an
exception every time it is called.
"""
# don't do anything if not connected
if not self.__connected:
return
# tell the loops to terminate
self.__parsing = False
self.__thinking = False
# tell the server that we're quitting
self.__sock.send("(bye)")
# tell our threads to join, but only wait breifly for them to do so.
# don't join them if they haven't been started (this can happen if
# disconnect is called very quickly after connect).
if self.__msg_thread.is_alive():
self.__msg_thread.join(0.01)
if self.__think_thread.is_alive():
self.__think_thread.join(0.01)
# reset all standard variables in this object. self.__connected gets
# reset here, along with all other non-user defined internal variables.
Agent.__init__(self)
def __message_loop(self):
"""
Handles messages received from the server.
This SHOULD NOT be called externally, since it's used as a threaded loop
internally by this object. Calling it externally is a BAD THING!
"""
# loop until we're told to stop
while self.__parsing:
# receive message data from the server and pass it along to the
# world model as-is. the world model parses it and stores it within
# itself for perusal at our leisure.
raw_msg = self.__sock.recv()
msg_type = self.msg_handler.handle_message(raw_msg)
# we send commands all at once every cycle, ie. whenever a
# 'sense_body' command is received
if msg_type == handler.ActionHandler.CommandType.SENSE_BODY:
self.__send_commands = True
# flag new data as needing the think loop's attention
self.__should_think_on_data = True
def __think_loop(self):
"""
Performs world model analysis and sends appropriate commands to the
server to allow the agent to participate in the current game.
Like the message loop, this SHOULD NOT be called externally. Use the
play method to start play, and the disconnect method to end it.
"""
while self.__thinking:
# tell the ActionHandler to send its enqueued messages if it is time
if self.__send_commands:
self.__send_commands = False
self.wm.ah.send_commands()
# only think if new data has arrived
if self.__should_think_on_data:
# flag that data has been processed. this shouldn't be a race
# condition, since the only change would be to make it True
# before changing it to False again, and we're already going to
# process data, so it doesn't make any difference.
self.__should_think_on_data = False
# performs the actions necessary for the agent to play soccer
self.think()
else:
# prevent from burning up all the cpu time while waiting for data
time.sleep(0.0001)
def setup_environment(self):
"""
Called before the think loop starts, this allows the user to store any
variables/objects they'll want access to across subsequent calls to the
think method.
"""
# determine the enemy goal position
goal_pos = None
if self.wm.side == WorldModel.SIDE_R:
goal_pos = (-55, 0)
else:
goal_pos = (55, 0)
self.in_kick_off_formation = False
def ball_visible(self):
"""
Determine whether or not the ball is within the player's field of
vision. Is its location known?
"""
#TODO OR or AND?
return (self.wm.ball is None) or (self.wm.ball.direction is None)
def think(self):
"""
Performs a single step of thinking for our agent. Gets called on every
iteration of our think loop.
"""
# DEBUG: tells us if a thread dies
if not self.__think_thread.is_alive() or not self.__msg_thread.is_alive():
raise Exception("A thread died.")
# take places on the field by uniform number
if self.wm.is_before_kick_off:
# teleport if player has not already done so
if not self.in_kick_off_formation:
# increment kickoff flag
self.in_kick_off_formation = True
# go to kickoff position
self.goto_kickoff_position()
print "Teleport %i" % self.wm.uniform_number
# exit think loop, decision made
return
# decide to take kickoff or not
elif self.dec_take_kickoff():
# thake the kickoff
self.act_take_kickoff()
# exit think loop, decision made
return
# clear kickoff formation flag after kickoff occurs
if self.in_kick_off_formation:
self.in_kick_off_formation = False
# if the location of the ball is unkown, find it
if not self.ball_visible():
self.act_find_ball()
return
# attack!
else:
# find the ball
if self.wm.ball is None or self.wm.ball.direction is None:
self.wm.ah.turn(30)
return
# kick it at the enemy goal
if self.wm.is_ball_kickable():
self.wm.kick_to(self.goal_pos, 1.0)
return
else:
# move towards ball
if -7 <= self.wm.ball.direction <= 7:
self.wm.ah.dash(65)
else:
# face ball
self.wm.ah.turn(self.wm.ball.direction / 2)
return
# Helper methods below this line
def angle(self, point1, point2):
rel_point_dir = 0
ang_1 = self.wm.angle_between_points(point1, point2)
if self.wm.abs_body_dir is not None:
rel_point_dir = self.wm.abs_body_dir - ang_1
return rel_point_dir
# it will calculate all paths from the point
# expanding to possible points that are +- 6 from initial y
def get_clear_point(self, point):
result = None
if not self.can_opponents_intercept():
result = point
return result
# kicks to the point accurately
def kick(self, power, point):
self.wm.ah.kick(power, point)
return
def can_opponents_intercept(self):
opponent = self.wm.get_nearest_opponent_to_point(self.wm.get_absolute_coords(self.wm.ball))
distance = self.wm.get_distance_to_point(self.wm.get_object_absolute_coords(opponent))
if opponent is not None and distance >= 10:
return False
return True
# returns the power a shot should be taken with
# from current point
def get_power(self):
goal = abs(self.goal_pos[0])
x = abs(self.wm.abs_coords[0])
result = (((goal - x) << 2) + 0.0) / 10
return result
# act - action prefix
# scr - calculate action score returns score of (0 - 100)
# dec - boolean decision returns (True/False)
def act_move_to_ball(self):
"""
move towards the ball, if the player does not know where the ball is
call action_find_ball().
"""
if self.wm.ball is not None:
if (self.wm.ball.direction is not None) and (-7 <= self.wm.ball.direction <= 7):
self.wm.ah.dash(50)
else:
self.wm.turn_body_to_point((0, 0))
else:
action_find_ball()
def act_find_ball(self):
"""
spin the spin the player until the ball is within the players
field of vision
"""
self.wm.ah.turn(30) #using the 30 degree default angle
def dec_take_kickoff(self):
"""
Should this player take the kickoff?
"""
if not self.wm.is_kick_off_us():
return False
else:
# calculate ball position
(x,y) = get_object_absolute_coords(self.wm.ball)
if self.side == WorldModel.SIDE_L:
# if offensive player 1, and ball on opponent's side
if (self.uniform_number == 1) and (x >= -10):
return True
# if first defensive agent, take kickoff
elif (self.uniform_number == 8):
return True
else:
# if offensive player 1, and ball on opponent's side
if (self.uniform_number == 1) and (x <= 10):
return True
# if first defensive agent, take kickoff
elif (self.uniform_number == 8):
return True
return False
def act_take_kickoff(self):
"""
perform the kickoff
"""
if self.wm.is_ball_kickable():
# kick with 100% extra effort at enemy goal
self.wm.kick_to(goal_pos, 1.0)
else:
self.act_move_to_ball()
def scr_shoot_ball(self):
"""
Shoot the ball towards the enemy goal
"""
#TODO ian's task
score = 0
if self.wm.ball is not None and self.wm.is_ball_kickable():
score += 10
if not self.can_opponents_intercept():
score += 10
def act_shoot_ball(self):
"""
Shoot the ball towards the enemy goal
"""
if self.wm.is_ball_kickable() and self.wm.ball is not None:
self.wm.kick_to(self, self.get_clear_point(self.goal_pos), self.get_power())
#ian's task
def scr_dribble_ball(self):
"""
calculate score for dribbling to ???
direction?
goal?
point?
"""
score = 0
if not self.wm.is_ball_kickable():
return 0
if self.wm.is_ball_kickable():
score += 5
if not self.can_opponents_intercept():
score += 5
return score
#TODO ian's task
def act_dribble_ball(self):
"""
dirbble to ball to ???
direction?
goal?
point?
"""
if self.wm.is_ball_kickable():
self.wm.ah.turn(self.wm.ball.direction / 2)
for x in range(0, 7):
# get absolute direction to the point
angle = self.angle(self.wm.abs_coords, self.goal_pos)
self.wm.ah.kick(2, angle)
self.wm.ah.dash(2)
return
#TODO ian's task
def scr_pass_ball(self, target):
"""
Should the player pass the ball to player (param target)
calculate score 0-100
"""
#TODO john's task
def act_pass_ball(self, target):
"""
pass the ball to param taraget
"""
#TODO john's task
def scr_mark_player(self, target):
"""
Should the player (param target) be covered?
"""
#
def act_mark_player(self, target):
"""
Cover the player (param target)
"""
#TODO renan's task
def goto_ball(self):
pass
def intercept(self, target):
"""
Intercept ball or player? target
"""
pass
pickle.dump(transformer, f)
n_obs = transformer.rbf_dim if transformer else env.observation_space.shape[
0]
n_action = env.action_space.shape[0]
max_action = float(env.action_space.high[0])
critic = build_critic(n_obs, args.learning_rate)
if transformer:
critic = NetworkWithTransformer(critic, transformer)
# Initialize agent
if args.agent == "PIP":
copy_tree(f"world_models/{args.world_model}",
f"{model_path}/world_model")
world_model = WorldModel.load(model_path)
planner = PSOPlanner(
env.action_space,
world_model,
critic,
length=args.plan_length,
gamma=args.gamma,
particles=args.particles,
iterations=args.iterations,
c1=args.c1,
c2=args.c2,
w=args.w,
k=args.k,
)
agent = PIP(planner, critic, gamma=args.gamma)
goal,
verbose=self.verbose,
all_plans=True,
sort_asc=True)
else:
return ""
if __name__ == '__main__':
htn_planner = HierarchicalTaskNetworkPlanner()
end_goal = [('transfer_target_object_to_container', 'arm', 'target_object',
'table', 'container')]
intentions = end_goal # I := I0; Initial Intentions
from world_model import WorldModel
beliefs = WorldModel() # B := B0; Initial Beliefs
print()
beliefs.current_world_model.xyz["target_object"] = [-10, -10, 0]
htn_plans = htn_planner.get_plans(
beliefs.current_world_model,
intentions) # π := plan(B, I); MEANS_END REASONING
if not htn_plans:
print("-- No valid plan. Failure_reason: {}".format(
htn_planner.failure_reason))
else:
beliefs.current_world_model.plans = htn_plans
print("== Best current_world_model.plan: ",
beliefs.current_world_model.plans[0])
print()
def run_mission(model, display=None):
# Create default Malmo objects:
my_mission = MalmoPython.MissionSpec(MISSION_XML, True)
my_mission_record = MalmoPython.MissionRecordSpec()
world_model = WorldModel(BLUEPRINT, CONFIG_FILE, simulated=False)
# Attempt to start a mission:
for retry in range(MAX_RETRIES):
try:
AGENT_HOST.startMission(my_mission, my_mission_record)
break
except RuntimeError as e:
if retry == MAX_RETRIES - 1:
print("Error starting mission:", e)
exit(1)
else:
time.sleep(2**retry)
# Loop until mission starts:
print("Waiting for the mission to start ", end=' ')
world_state = AGENT_HOST.getWorldState()
while not world_state.has_mission_begun:
print(".", end="")
time.sleep(0.1)
world_state = AGENT_HOST.getWorldState()
for error in world_state.errors:
print("Error:", error.text)
print("\nMission running.")
total_reward = 0
current_r = 0
start = time.time()
# Loop until mission ends
while (world_state.is_mission_running
and world_model.is_mission_running()):
world_state = AGENT_HOST.getWorldState()
for error in world_state.errors:
print("Error:", error.text)
current_r += sum(r.getValue() for r in world_state.rewards)
if len(world_state.observations) > 0:
raw_obs = json.loads(world_state.observations[-1].text)
world_model.update(raw_obs)
current_r += world_model.reward()
action = model.act(current_r, world_model.get_observation())
if display is not None:
display.update(world_model)
total_reward += current_r
current_r = 0
if world_model.mission_complete(
) or not world_model.agent_in_arena():
AGENT_HOST.sendCommand('quit')
elif world_state.is_mission_running:
AGENT_HOST.sendCommand(action)
time.sleep(ACTION_DELAY)
end = time.time()
model.mission_ended()
print()
print("Mission ended")
return total_reward, end - start
def callback_friend_odom(msg, robot_id):
WorldModel.set_friend_odom(msg, robot_id)
elif action == ('close_hand', ):
action_successful = self.control.close_hand(
world_model.size["object_side_length"])
elif action == ('move_arm_above', 'container'):
action_successful = self.control.move_arm_above_xyz(
world_model.xyz["container"],
world_model.location["servo_values"], 14)
return action_successful
if __name__ == '__main__':
# Sequence for testing
from world_model import WorldModel
current_world_model = WorldModel()
coordination = Coordination(current_world_model)
coordination.control.control_world_model["send_requests"] = False
coordination.control.control_world_model["center_init"] = False
coordination.control.control_world_model["detect_last_position"] = False
coordination.execute_action(('initialize', 'arm'),
current_world_model.current_world_model)
coordination.execute_action(('open_hand', ),
current_world_model.current_world_model)
coordination.execute_action(('move_arm_above', 'target_object'),
current_world_model.current_world_model)
coordination.execute_action(('move_arm', 'target_object'),
current_world_model.current_world_model)
coordination.execute_action(('close_hand', ),
current_world_model.current_world_model)
coordination.execute_action(('move_arm_up', 'target_object'),
class BDIBehaviour(PeriodicBehaviour):
async def on_start(self):
self.terminate = False
self.SUCCESS = False
self.verbose = False
# Initialization
self.htn_planner = HierarchicalTaskNetworkPlanner()
self.goal = [('transfer_target_object_to_container', 'arm',
'target_object', 'table', 'container')]
self.intentions = self.goal # I := I0; Initial Intentions
self.beliefs = WorldModel() # B := B0; Initial Beliefs
self.monitoring = Monitoring()
self.perception = Perception()
self.coordination = Coordination()
# Disable all 3 coordination switches for testing
self.coordination.control.send_requests = True
self.coordination.control.center_init = False
self.coordination.control.detect_last_position = True
self.what, self.why, self.how_well, self.what_else, self.why_failed = "", "", "", "", ""
self.plans = []
self.start_time = datetime.datetime.now()
async def run(self):
# print(f"-- Sender Agent: PeriodicSenderBehaviour running at {datetime.datetime.now().time()}: {self.counter}")
print("run tick: {}".format(self.beliefs.current_world_model.tick))
# msg = Message(to="madks2@temp3rr0r-pc") # Instantiate the message
# msg.body = "Hello World: " + str(self.counter) # Set the message content
# await self.send(msg)
self.add_belief()
self.add_desire()
self.add_intention()
print("-- Sender Agent: Message sent!")
if self.beliefs.update_tick(
) > self.beliefs.current_world_model.max_ticks:
self.done()
self.kill()
else:
SUCCESS = True if self.intentions == "" else False
self.plans = self.htn_planner.get_plans(
self.beliefs.current_world_model,
self.intentions) # π := plan(B, I); MEANS_END REASONING
async def on_end(self):
print("-- on_end")
# stop agent from behaviour
await self.agent.stop()
# async def _step(self):
# # the bdi stuff
# pass
#
def add_belief(self):
print("-- Sender Agent: add_belief")
percept = self.perception.get_percept(text_engraving=(
self.why_failed,
self.how_well)) # get next percept ρ; OBSERVE the world
self.beliefs = self.perception.belief_revision(
self.beliefs, percept) # B:= brf(B, ρ);
self.beliefs = self.monitoring.fire_events(self.beliefs, percept)
def add_desire(self):
print("-- Sender Agent: add_desire")
def add_intention(self):
print("-- Sender Agent: add_intention")
self.intentions = self.deliberate(
self.beliefs, self.intentions
) # DELIBERATE about what INTENTION to achieve next
def done(self):
# the done evaluation
print("-- Sender Agent: Done")
def deliberate(self, current_beliefs, current_intentions):
"""
Decide WHAT sate of affairs you want to achieve.
:param current_beliefs: WordModel instance, the world model, information about the world.
:param current_intentions: List of tuples, tasks that the agent has COMMITTED to accomplish.
:return: List of tuples, filtered intentions that the agent COMMITS to accomplish.
"""
# 1. Option Generation: The agent generates a set of possible alternatives.
current_desires = current_intentions # TODO: D := option(B, I);
# 2. Filtering: Agent chooses between competing alternatives and commits to achieving them.
current_intentions = self.filter_intentions(
current_beliefs, current_desires,
current_intentions) # I := filter(B, D, I);
return current_intentions
def filter_intentions(self, current_beliefs, current_desires,
current_intentions):
"""
Choose between competing alternatives and COMMITTING to achieving them.
:param current_beliefs: WordModel instance, the world model, information about the world.
:param current_desires: List of tuples, tasks that the agent would like to accomplish.
:param current_intentions: List of tuples, tasks that the agent has COMMITTED to accomplish.
:return: List of tuples, filtered intentions that the agent COMMITS to accomplish.
"""
for current_intention in current_intentions:
if current_intention == (
'transfer_target_object_to_container', 'arm', 'target_object', 'table', 'container') \
and current_beliefs.current_world_model.location["target_object"] == "container":
current_intentions = "" # if goal(s) achieved, empty I
return current_intentions
def enemyIDCallback(msg):
WorldModel.set_existing_enemies_id(msg.data)
def ballCallback(msg):
WorldModel.set_ball_odom(msg)
def refboxCallback(msg):
WorldModel.set_refbox_command(msg.data)
class RescueAgent:
"""The base class for handling the rescue"""
request_id = 0
def __init__(self):
self.connection = None
self.name = ''
self.connect_request_id = None
self.world_model = None
self.config = None
self.random = None
self.entity_id = None
pass
def connect(self, _connection):
self.connection = _connection
self.connection.set_agent(self)
connect_msg = AKConnect()
connect_msg.set_message(RescueAgent.request_id, 1, self.name,
self.get_requested_entities())
self.connect_request_id = RescueAgent.request_id
RescueAgent.request_id += 1
self.connection.send_msg(connect_msg)
def message_received(self, msg):
if isinstance(msg, KAConnectOK):
self.handle_connect_ok(msg)
elif isinstance(msg, KAConnectError):
self.handle_connect_error(msg)
elif isinstance(msg, KASense):
self.process_sense(msg)
def process_sense(self, msg):
self.world_model.merge(msg.get_change_set())
heard = msg.get_hearing()
self.think(msg.get_time(), msg.get_change_set(), heard)
def think(self, timestep, change_set, heard):
print('think method is supposed to be overriden')
# that will be overriden by agents
def get_requested_entities(self):
return ''
# that will be overriden by agents
def post_connect(self, agent_id, entities, config):
self.entity_id = agent_id
self.world_model = WorldModel()
self.world_model.add_entities(entities)
#todo: check whether we need to merge agent config and the config coming from kernel
self.config = config
print('post_connect agent_id:' + str(agent_id.get_value()))
# print('config test comms.channels.count:' + self.config.get_value('comms.channels.count'))
def handle_connect_ok(self, msg):
if msg.request_id_comp.get_value() == self.connect_request_id:
# print("handle connect ok")
self.post_connect(msg.agent_id_comp.get_value(),
msg.world_comp.get_entities(),
msg.config_comp.get_config())
ack_msg = AKAcknowledge(self.connect_request_id,
msg.agent_id_comp.get_value())
self.connection.send_msg(ack_msg)
def handle_connect_error(self, msg):
if msg.request_id_comp.get_value() == self.connect_request_id:
print('KAConnectionError:' + msg.get_reason())
def random_walk(self, timestep):
# calculate 10 step path
path = []
start_pos = self.get_position()
print('random walk agent_pos:' + str(start_pos))
# construct random path
for i in range(10):
edges = self.world_model.get_entity(start_pos).get_edges()
neighbors = []
for edge in edges:
if edge.get_neighbor() is not None:
neighbors.append(edge.get_neighbor())
next = random.choice(neighbors)
path.append(next)
start_pos = next
move_msg = AKMove()
move_msg.agent_id.set_value(self.entity_id)
move_msg.time.set_value(timestep)
move_msg.path.set_ids(path)
self.send_kernel_msg(move_msg)
def get_location(self):
return self.world_model.get_entity(self.entity_id).get_location(
self.world_model)
def get_position(self):
# print('agent pos:' + str(self.world_model.get_entity(self.entity_id)))
return self.world_model.get_entity(self.entity_id).get_position()
def send_kernel_msg(self, msg):
self.connection.send_msg(msg)
def callback_test_name(msg):
WorldModel.set_test_name(msg.data)
def callback_yellow_info(msg):
WorldModel.set_yellow_info(msg)
class Agent:
def __init__(self):
# whether we're connected to a server yet or not
self.__connected = False
# set all variables and important objects to appropriate values for
# pre-connect state.
# the socket used to communicate with the server
self.__sock = None
# models and the message handler for parsing and storing information
self.wm = None
self.msg_handler = None
# parse thread and control variable
self.__parsing = False
self.__msg_thread = None
self.__thinking = False # think thread and control variable
self.__think_thread = None
# whether we should run the think method
self.__should_think_on_data = False
# whether we should send commands
self.__send_commands = False
def connect(self, host, port, teamname, version=11):
"""
Gives us a connection to the server as one player on a team. This
immediately connects the agent to the server and starts receiving and
parsing the information it sends.
"""
# if already connected, raise an error since user may have wanted to
# connect again to a different server.
if self.__connected:
msg = "Cannot connect while already connected, disconnect first."
raise sp_exceptions.AgentConnectionStateError(msg)
# the pipe through which all of our communication takes place
self.__sock = sock.Socket(host, port)
# our models of the world and our body
self.wm = WorldModel(handler.ActionHandler(self.__sock))
# set the team name of the world model to the given name
self.wm.teamname = teamname
# handles all messages received from the server
self.msg_handler = handler.MessageHandler(self.wm)
# set up our threaded message receiving system
self.__parsing = True # tell thread that we're currently running
self.__msg_thread = threading.Thread(target=self.__message_loop,
name="message_loop")
self.__msg_thread.daemon = True # dies when parent thread dies
# start processing received messages. this will catch the initial server
# response and all subsequent communication.
self.__msg_thread.start()
# send the init message and allow the message handler to handle further
# responses.
init_address = self.__sock.address
init_msg = "(init %s (version %d))"
self.__sock.send(init_msg % (teamname, version))
# wait until the socket receives a response from the server and gets its
# assigned port.
while self.__sock.address == init_address:
time.sleep(0.0001)
# create our thinking thread. this will perform the actions necessary
# to play a game of robo-soccer.
self.__thinking = False
self.__think_thread = threading.Thread(target=self.__think_loop,
name="think_loop")
self.__think_thread.daemon = True
# set connected state. done last to prevent state inconsistency if
# something goes wrong beforehand.
self.__connected = True
def play(self):
"""
Kicks off the thread that does the agent's thinking, allowing it to play
during the game. Throws an exception if called while the agent is
already playing.
"""
# ensure we're connected before doing anything
if not self.__connected:
msg = "Must be connected to a server to begin play."
raise sp_exceptions.AgentConnectionStateError(msg)
# throw exception if called while thread is already running
if self.__thinking:
raise sp_exceptions.AgentAlreadyPlayingError(
"Agent is already playing.")
# run the method that sets up the agent's persistant variables
self.setup_environment()
# tell the thread that it should be running, then start it
self.__thinking = True
self.__should_think_on_data = True
self.__think_thread.start()
def disconnect(self):
"""
Tell the loop threads to stop and signal the server that we're
disconnecting, then join the loop threads and destroy all our inner
methods.
Since the message loop thread can conceiveably block indefinitely while
waiting for the server to respond, we only allow it (and the think loop
for good measure) a short time to finish before simply giving up.
Once an agent has been disconnected, it is 'dead' and cannot be used
again. All of its methods get replaced by a method that raises an
exception every time it is called.
"""
# don't do anything if not connected
if not self.__connected:
return
# tell the loops to terminate
self.__parsing = False
self.__thinking = False
# tell the server that we're quitting
self.__sock.send("(bye)")
# tell our threads to join, but only wait breifly for them to do so.
# don't join them if they haven't been started (this can happen if
# disconnect is called very quickly after connect).
if self.__msg_thread.is_alive():
self.__msg_thread.join(0.01)
if self.__think_thread.is_alive():
self.__think_thread.join(0.01)
# reset all standard variables in this object. self.__connected gets
# reset here, along with all other non-user defined internal variables.
Agent.__init__(self)
def __message_loop(self):
"""
Handles messages received from the server.
This SHOULD NOT be called externally, since it's used as a threaded loop
internally by this object. Calling it externally is a BAD THING!
"""
# loop until we're told to stop
while self.__parsing:
# receive message data from the server and pass it along to the
# world model as-is. the world model parses it and stores it within
# itself for perusal at our leisure.
raw_msg = self.__sock.recv()
msg_type = self.msg_handler.handle_message(raw_msg)
# we send commands all at once every cycle, ie. whenever a
# 'sense_body' command is received
if msg_type == handler.ActionHandler.CommandType.SENSE_BODY:
self.__send_commands = True
# flag new data as needing the think loop's attention
self.__should_think_on_data = True
def __think_loop(self):
"""
Performs world model analysis and sends appropriate commands to the
server to allow the agent to participate in the current game.
Like the message loop, this SHOULD NOT be called externally. Use the
play method to start play, and the disconnect method to end it.
"""
while self.__thinking:
# tell the ActionHandler to send its enqueued messages if it is time
if self.__send_commands:
self.__send_commands = False
self.wm.ah.send_commands()
# only think if new data has arrived
if self.__should_think_on_data:
# flag that data has been processed. this shouldn't be a race
# condition, since the only change would be to make it True
# before changing it to False again, and we're already going to
# process data, so it doesn't make any difference.
self.__should_think_on_data = False
# performs the actions necessary for the agent to play soccer
self.think()
else:
# prevent from burning up all the cpu time while waiting for data
time.sleep(0.0001)
def setup_environment(self):
"""
Called before the think loop starts, this allows the user to store any
variables/objects they'll want access to across subsequent calls to the
think method.
"""
self.in_kick_off_formation = False
def player1(self):
self.player10()
#play
xxxx = 0
def player2(self):
self.player10()
#play
xxxx = 0
def player3(self):
self.player10()
#play
xxxx = 0
def player4(self):
self.player10()
#play
xxxx = 0
def player5(self):
self.player10()
#play
xxxx = 0
def player6(self):
self.player10()
#play
xxxx = 0
def player7(self):
self.player10()
#play
xxxx = 0
def player8(self):
self.player10()
#play
xxxx = 0
def player9(self):
#play atacante
self.player10()
if False:
time.sleep(0.1)
#determinando o gol inimigo
enemy_goal_pos = None
enemy_goal_pos = (
55, 0) if self.wm.side != WorldModel.SIDE_R else (-55, 0)
# attack!
# find the ball
if self.wm.ball is None or self.wm.ball.direction is None:
self.wm.ah.turn(30)
return
# kick it at the enemy goal
if self.wm.is_ball_kickable():
self.wm.kick_to((55, 0), 1.0)
return
else:
# move towards ball
if -7 <= self.wm.ball.direction <= 7:
self.wm.ah.dash(65)
else:
# face ball
self.wm.ah.turn(self.wm.ball.direction / 2)
return
def player10(self):
if True:
print(self.cont)
if self.cont % 10 > 0:
self.wm.ah.dash(65)
else:
self.wm.ah.turn(90)
self.cont += 1
time.sleep(0.1)
def player11(self):
self.player10()
def think(self):
"""
Performs a single step of thinking for our agent. Gets called on every
iteration of our think loop.
"""
# DEBUG: tells us if a thread dies
if not self.__think_thread.is_alive(
) or not self.__msg_thread.is_alive():
raise Exception("A thread died.")
# take places on the field by uniform number
if not self.in_kick_off_formation:
# used to flip x coords for other side
side_mod = 1
#COCDQTL Logica nao funciona, nao sei pq
#if self.wm.side == WorldModel.SIDE_R:
# side_mod = -1
if self.wm.uniform_number == 1:
self.wm.teleport_to_point((-45 * side_mod, 0))
elif self.wm.uniform_number == 2:
self.wm.teleport_to_point((-40 * side_mod, 15))
elif self.wm.uniform_number == 3:
self.wm.teleport_to_point((-40 * side_mod, 00))
elif self.wm.uniform_number == 4:
self.wm.teleport_to_point((-40 * side_mod, -15))
elif self.wm.uniform_number == 5:
self.wm.teleport_to_point((-15 * side_mod, -25))
elif self.wm.uniform_number == 6:
self.wm.teleport_to_point((-15 * side_mod, 25))
elif self.wm.uniform_number == 7:
self.wm.teleport_to_point((-20 * side_mod, 12))
elif self.wm.uniform_number == 8:
self.wm.teleport_to_point((-20 * side_mod, -12))
elif self.wm.uniform_number == 9:
self.wm.teleport_to_point((-18 * side_mod, 0))
elif self.wm.uniform_number == 10:
self.wm.teleport_to_point((-18 * side_mod, 10))
elif self.wm.uniform_number == 11:
self.wm.teleport_to_point((-18 * side_mod, -10))
self.in_kick_off_formation = True
return
# determine the enemy goal position
if self.wm.uniform_number == 1:
self.player1()
elif self.wm.uniform_number == 2:
self.player2()
elif self.wm.uniform_number == 3:
self.player3()
elif self.wm.uniform_number == 4:
self.player4()
elif self.wm.uniform_number == 5:
self.player5()
elif self.wm.uniform_number == 6:
self.player6()
elif self.wm.uniform_number == 7:
self.player7()
elif self.wm.uniform_number == 8:
self.player8()
elif self.wm.uniform_number == 9:
self.player9()
elif self.wm.uniform_number == 10:
self.player10()
elif self.wm.uniform_number == 11:
self.player11()
class Agent:
#variables
goal_pos = None
#Start of methods
#############################################################################################
"""@_init_
see if server is connected
initialize self
"""
def __init__(self):
# whether we're connected to a server yet or not
self.__connected = False
# set all variables and important objects to appropriate values for
# pre-connect state.
# the socket used to communicate with the server
self.__sock = None
# models and the message handler for parsing and storing information
self.wm = None
self.msg_handler = None
# parse thread and control variable
self.__parsing = False
self.__msg_thread = None
self.__thinking = False # think thread and control variable
self.__think_thread = None
# whether we should run the think method
self.__should_think_on_data = False
# whether we should send commands
self.__send_commands = False
#end of method
"""@connect
Gives us a connection to the server as one player on a team. This
immediately connects the agent to the server and starts receiving and
parsing the information it sends.
"""
def connect(self, host, port, teamname, version=11):
# if already connected, raise an error since user may have wanted to
# connect again to a different server.
if self.__connected:
msg = "Cannot connect while already connected, disconnect first."
raise sp_exceptions.AgentConnectionStateError(msg)
# the pipe through which all of our communication takes place
self.__sock = sock.Socket(host, port)
# our models of the world and our body
self.wm = WorldModel(handler.ActionHandler(self.__sock))
# set the team name of the world model to the given name
self.wm.teamname = teamname
# handles all messages received from the server
self.msg_handler = handler.MessageHandler(self.wm)
# set up our threaded message receiving system
self.__parsing = True # tell thread that we're currently running
self.__msg_thread = threading.Thread(target=self.__message_loop,
name="message_loop")
self.__msg_thread.daemon = True # dies when parent thread dies
# start processing received messages. this will catch the initial server
# response and all subsequent communication.
self.__msg_thread.start()
# send the init message and allow the message handler to handle further
# responses.
init_address = self.__sock.address
init_msg = "(init %s (version %d))"
self.__sock.send(init_msg % (teamname, version))
# wait until the socket receives a response from the server and gets its
# assigned port.
while self.__sock.address == init_address:
time.sleep(0.0001)
# create our thinking thread. this will perform the actions necessary
# to play a game of robo-soccer.
self.__thinking = False
self.__think_thread = threading.Thread(target=self.__think_loop,
name="think_loop")
self.__think_thread.daemon = True
# set connected state. done last to prevent state inconsistency if
# something goes wrong beforehand.
self.__connected = True
#end of method
"""@starting_field_position
get all the player to the field
"""
def starting_field_position(self):
self.wm.teleport_to_point(self.set_starting_postion())
#end of method
"""@set_starting_position
sets the initial positions of the players
according to jersey number
"""
def set_starting_postion(self):
# used to flip x coords for other side
if self.wm.side == WorldModel.SIDE_L:
side_mod = 1
elif self.wm.side == WorldModel.SIDE_R:
side_mod = 1
if self.wm.uniform_number == 1:
print "UNIFORM 1 %d " % (-50 * side_mod)
return(-50 * side_mod, 0)
elif self.wm.uniform_number == 2:
return(-35 * side_mod, 20)
elif self.wm.uniform_number == 3:
return(-35 * side_mod, 5)
elif self.wm.uniform_number == 4:
return(-35 * side_mod, -5)
elif self.wm.uniform_number == 5:
return(-35 * side_mod, -20)
elif self.wm.uniform_number == 6:
return(-20 * side_mod, -27)
elif self.wm.uniform_number == 7:
return(-20 * side_mod, 10)
elif self.wm.uniform_number == 8:
return(-20 * side_mod, -10)
elif self.wm.uniform_number == 9:
return(-20 * side_mod, 27)
elif self.wm.uniform_number == 10:
return(-10 * side_mod, 5)
elif self.wm.uniform_number == 11:
return(-10 * side_mod, -5)
#if an error
return (0,0)
"""@play
Kicks off the thread that does the agent's thinking, allowing it to play
during the game. Throws an exception if called while the agent is
already playing.
"""
def play(self):
# ensure we're connected before doing anything
if not self.__connected:
msg = "Must be connected to a server to begin play."
raise sp_exceptions.AgentConnectionStateError(msg)
# throw exception if called while thread is already running
if self.__thinking:
raise sp_exceptions.AgentAlreadyPlayingError(
"Agent is already playing.")
# run the method that sets up the agent's persistant variables
self.setup_environment()
# tell the thread that it should be running, then start it
self.__thinking = True
self.__should_think_on_data = True
self.__think_thread.start()
#end of method
"""@disconnect
Tell the loop threads to stop and signal the server that we're
disconnecting, then join the loop threads and destroy all our inner
methods.
Since the message loop thread can conceiveably block indefinitely while
waiting for the server to respond, we only allow it (and the think loop
for good measure) a short time to finish before simply giving up.
Once an agent has been disconnected, it is 'dead' and cannot be used
again. All of its methods get replaced by a method that raises an
exception every time it is called.
"""
def disconnect(self):
# don't do anything if not connected
if not self.__connected:
return
# tell the loops to terminate
self.__parsing = False
self.__thinking = False
# tell the server that we're quitting
self.__sock.send("(bye)")
# tell our threads to join, but only wait breifly for them to do so.
# don't join them if they haven't been started (this can happen if
# disconnect is called very quickly after connect).
if self.__msg_thread.is_alive():
self.__msg_thread.join(0.01)
if self.__think_thread.is_alive():
self.__think_thread.join(0.01)
# reset all standard variables in this object. self.__connected gets
# reset here, along with all other non-user defined internal variables.
Agent.__init__(self)
#end of method
"""@_message_loop
Handles messages received from the server.
This SHOULD NOT be called externally, since it's used as a threaded loop
internally by this object. Calling it externally is a BAD THING!
"""
def __message_loop(self):
# loop until we're told to stop
while self.__parsing:
# receive message data from the server and pass it along to the
# world model as-is. the world model parses it and stores it within
# itself for perusal at our leisure.
raw_msg = self.__sock.recv()
msg_type = self.msg_handler.handle_message(raw_msg)
# we send commands all at once every cycle, ie. whenever a
# 'sense_body' command is received
if msg_type == handler.ActionHandler.CommandType.SENSE_BODY:
self.__send_commands = True
# flag new data as needing the think loop's attention
self.__should_think_on_data = True
#end of method
"""@_think_loop
Performs world model analysis and sends appropriate commands to the
server to allow the agent to participate in the current game.
Like the message loop, this SHOULD NOT be called externally. Use the
play method to start play, and the disconnect method to end it.
"""
def __think_loop(self):
while self.__thinking:
# tell the ActionHandler to send its enqueued messages if it is time
if self.__send_commands:
self.__send_commands = False
self.wm.ah.send_commands()
# only think if new data has arrived
if self.__should_think_on_data:
# flag that data has been processed. this shouldn't be a race
# condition, since the only change would be to make it True
# before changing it to False again, and we're already going to
# process data, so it doesn't make any difference.
self.__should_think_on_data = False
# performs the actions necessary for the agent to play soccer
self.think()
else:
# prevent from burning up all the cpu time while waiting for data
time.sleep(0.0001)
#end of method
"""@setup_environment
Called before the think loop starts, this allows the user to store any
variables/objects they'll want access to across subsequent calls to the
think method.
"""
def setup_environment(self):
# determine the enemy goal position
#goal_pos = None
if self.wm.side == WorldModel.SIDE_R:
self.goal_pos = (-55, 0)
else:
self.goal_pos = (55, 0)
self.in_kick_off_formation = False
#end of method
"""@think
Performs a single step of thinking for our agent. Gets called on every
iteration of our think loop.
"""
def think(self):
# DEBUG: tells us if a thread dies
if not self.__think_thread.is_alive() or not self.__msg_thread.is_alive():
raise Exception("A thread died.")
# take places on the field by uniform number
if self.wm.is_before_kick_off():
# take places on the field by uniform number
if not self.in_kick_off_formation:
#set the players on the field
self.starting_field_position()
self.in_kick_off_formation = True
return
# Referee started Kick Off
if self.wm.is_before_kick_off():
# player 10 takes the kick off
if self.wm.uniform_number == 10:
if self.wm.is_ball_kickable():
# kick with 100% extra effort at enemy goal
self.wm.kick_to(self.goal_pos, 1.0)
else:
# move towards ball
if self.wm.ball is not None:
if (self.wm.ball.direction is not None and
-7 <= self.wm.ball.direction <= 7):
self.wm.ah.dash(50)
else:
self.wm.turn_body_to_point((0, 0))
# turn to ball if we can see it, else face the enemy goal
if self.wm.ball is not None:
self.wm.turn_neck_to_object(self.wm.ball)
return
# attack!
else:
# find the ball
if self.wm.ball is None or self.wm.ball.direction is None:
self.wm.ah.turn(30)
return
# kick it at the enemy goal if agent is within range of goal
if self.wm.is_ball_kickable():
self.wm.kick_to(self.goal_pos, 1.0)
return
else:
# move towards ball
if -7 <= self.wm.ball.direction <= 7:
self.wm.ah.dash(65)
else:
# face ball
self.wm.ah.turn(self.wm.ball.direction / 2)
return
def callback_blue_info(msg):
WorldModel.set_blue_info(msg)
def callback_enemy_odom(msg, robot_id):
WorldModel.set_enemy_odom(msg, robot_id)
