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
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:
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