class App:
screen_size = (160, 120)
margin = 10
@property
def objects(self):
yield self.paddle
def __init__(self):
pyxel.init(*App.screen_size)
self.background = Background(App.screen_size, App.margin)
self.ball = Ball(App.screen_size, App.margin)
self.paddle = Paddle(App.screen_size, App.margin)
pyxel.run(self.update, self.draw)
def update(self):
if pyxel.btnp(pyxel.KEY_Q):
pyxel.quit()
self.ball.update()
for obj in self.objects:
obj.update()
if obj.ball_collide(self.ball) and obj == 'rectangle':
obj.alive = False
def draw(self):
self.background.draw()
self.ball.draw()
for obj in self.objects:
obj.draw()
class Brain(object):
"""
Class brings all of our components together and runs the behaviors
"""
def __init__(self):
"""
Class constructor
"""
self.counter = 0
self.time = time.time()
self.on = True
# Output Class
self.out = NaoOutput.NaoOutput(self)
# Setup nao modules inside brain for easy access
self.vision = vision.vision
self.sensors = sensors.sensors
self.logger = loggingBoard.loggingBoard
self.comm = comm.inst
self.comm.gc.team = TeamConfig.TEAM_NUMBER
self.comm.gc.player = TeamConfig.PLAYER_NUMBER
#initalize the leds
#print leds
self.leds = Leds.Leds(self)
self.speech = _speech.speech
# Initialize motion interface and module references
self.motion = motion.MotionInterface()
self.motionModule = motion
# Get the pointer to the C++ RoboGuardian object for use with Python
self.roboguardian = _roboguardian.roboguardian
self.roboguardian.enableFallProtection(True)
# Get our reference to the C++ localization system
self.loc = Loc()
# Retrieve our robot identification and set per-robot parameters
self.CoA = robots.get_certificate()
self.CoA.setRobotGait(self.motion)
# coa is Certificate of Authenticity (to keep things short)
self.out.printf(self.CoA)
self.out.printf("GC: I am on team "+str(TeamConfig.TEAM_NUMBER))
self.out.printf("GC: I am player "+str(TeamConfig.PLAYER_NUMBER))
# Initialize various components
self.my = MyInfo(self.loc)
# Functional Variables
self.my.playerNumber = self.comm.gc.player
if self.comm.gc.color == GameController.TEAM_BLUE:
self.my.teamColor = Constants.teamColor.TEAM_BLUE
else:
self.my.teamColor = Constants.teamColor.TEAM_RED
# Information about the environment
self.initFieldObjects()
self.initTeamMembers()
self.ball = Ball(self.vision.ball, self.loc, self.my)
self.play = Play.Play()
self.sonar = Sonar.Sonar()
if Constants.LOG_COMM:
self.out.startCommLog()
# Stability data
self.stability = Stability.Stability(self.sensors)
# FSAs
self.player = Switch.selectedPlayer.SoccerPlayer(self)
self.tracker = HeadTracking.HeadTracking(self)
self.nav = Navigator.Navigator(self)
self.playbook = PBInterface.PBInterface(self)
self.kickDecider = KickDecider.KickDecider(self)
self.gameController = GameController.GameController(self)
self.fallController = FallController.FallController(self)
def initFieldObjects(self):
"""
Build our set of Field Objects which are team specific compared
to the generic forms used in the vision system
"""
# Build instances of the vision based field objects
# Left post is on that goalie's left
# Note: As of 6/8/12, ygrp holds info about ambiguous posts
# Yellow goal left and right posts
self.yglp = FieldObject(self.vision.yglp,
Constants.vis_landmark.VISION_YGLP,
self.loc)
self.ygrp = FieldObject(self.vision.ygrp,
Constants.vis_landmark.VISION_YGRP,
self.loc)
# Blue Goal left and right posts
self.bglp = FieldObject(self.vision.bglp,
Constants.vis_landmark.VISION_BGLP,
self.loc)
self.bgrp = FieldObject(self.vision.bgrp,
Constants.vis_landmark.VISION_BGRP,
self.loc)
# Now we build the field objects to be based on our team color
self.makeFieldObjectsRelative()
def makeFieldObjectsRelative(self):
"""
Builds a list of fieldObjects based on their relative names to the robot
Needs to be called when team color is determined
"""
# Note: corner directions are relative to perspective of own goalie
# Blue team setup
if self.my.teamColor == Constants.teamColor.TEAM_BLUE:
# Yellow goal
self.oppGoalRightPost = self.yglp
self.oppGoalLeftPost = self.ygrp
# Blue Goal
self.myGoalLeftPost = self.bglp
self.myGoalRightPost = self.bgrp
# Yellow team setup
else:
# Yellow goal
self.myGoalLeftPost = self.yglp
self.myGoalRightPost = self.ygrp
# Blue Goal
self.oppGoalRightPost = self.bglp
self.oppGoalLeftPost = self.bgrp
# Since, for ex. bgrp points to the same things as myGoalLeftPost,
# we can set these regardless of our team color
self.myGoalLeftPost.associateWithRelativeLandmark(
Constants.LANDMARK_MY_GOAL_LEFT_POST)
self.myGoalRightPost.associateWithRelativeLandmark(
Constants.LANDMARK_MY_GOAL_RIGHT_POST)
self.oppGoalLeftPost.associateWithRelativeLandmark(
Constants.LANDMARK_OPP_GOAL_LEFT_POST)
self.oppGoalRightPost.associateWithRelativeLandmark(
Constants.LANDMARK_OPP_GOAL_RIGHT_POST)
# Build a list of all of the field objects with respect to team color
self.myFieldObjects = [self.yglp, self.ygrp, self.bglp, self.bgrp]
def initTeamMembers(self):
self.teamMembers = []
for i in xrange(Constants.NUM_PLAYERS_PER_TEAM):
mate = TeamMember.TeamMember(self)
mate.playerNumber = i + 1
self.teamMembers.append(mate)
##
##--------------CONTROL METHODS---------------##
##
def profile(self):
if self.counter == 0:
cProfile.runctx('self.run()', self.__dict__, locals(),
'pythonStats')
self.p = pstats.Stats('pythonStats')
elif self.counter < 3000:
self.p.add('pythonStats')
cProfile.runctx('self.run()', self.__dict__, locals(),
'pythonStats')
elif self.counter == 3000:
self.p.strip_dirs()
self.p.sort_stats('cumulative')
## print 'PYTHON STATS:'
## self.p.print_stats()
## print 'OUTGOING CALLEES:'
## self.p.print_callees()
## print 'OUTGOING CALLEES:'
## self.p.print_callers()
self.p.dump_stats('pythonStats')
self.counter += 1
def run(self):
"""
Main control loop called every TIME_STEP milliseconds
"""
# order here is very important
# Update Environment
self.time = time.time()
self.sonar.updateSensors(self.sensors)
# Communications update
self.updateComm()
# Update objects
self.updateObjects()
# Behavior stuff
self.gameController.run()
self.fallController.run()
self.updatePlaybook()
self.player.run()
self.tracker.run()
self.nav.run()
# Kinda of a hack...
# check and set loc boolean
if ((self.my.teamColor == Constants.teamColor.TEAM_BLUE and
self.loc.x > Constants.MIDFIELD_X - Constants.CENTER_CIRCLE_RADIUS) or
(self.my.teamColor == Constants.teamColor.TEAM_RED and
self.loc.x < Constants.MIDFIELD_X + Constants.CENTER_CIRCLE_RADIUS)):
self.onOwnFieldSide = False
#Set LEDS
self.leds.processLeds()
# Broadcast Report for Teammates
self.setPacketData()
# Update any logs we have
self.out.updateLogs()
def updateComm(self):
temp = self.comm.latestComm()
for packet in temp:
if len(packet) == Constants.NUM_PACKET_ELEMENTS:
packet = Packet.Packet(packet)
if packet.playerNumber != self.my.playerNumber:
self.teamMembers[packet.playerNumber-1].update(packet)
if Constants.LOG_COMM:
self.out.logRComm(packet)
# update the activity of our teammates here
# active field is set to true upon recipt of a new packet.
for mate in self.teamMembers:
if (mate.active and mate.isDead()):
mate.active = False
def updateObjects(self):
"""
Update estimates of robot and ball positions on the field
"""
self.ball.update()
self.my.update()
self.yglp.setBest()
self.ygrp.setBest()
self.bglp.setBest()
self.bgrp.setBest()
def updatePlaybook(self):
"""
updates self.play to the new play
"""
self.playbook.update(self.play)
# move to comm
def setPacketData(self):
# Team color, team number, and player number are all appended to this
# list by the underlying comm module implemented in C++
loc = self.loc
self.comm.setData(loc.x,
loc.y,
loc.h,
loc.xUncert,
loc.yUncert,
loc.hUncert,
loc.ballX,
loc.ballY,
loc.ballXUncert,
loc.ballYUncert,
self.ball.loc.dist,
self.ball.loc.bearing,
self.ball.vis.on,
self.play.role,
self.play.subRole,
self.playbook.pb.me.chaseTime,
loc.ballVelX,
loc.ballVelY)
# TODO: remove this and log through C++ and the Logger instead.
if Constants.LOG_COMM:
packet = Packet.Packet((TeamConfig.TEAM_NUMBER,
TeamConfig.PLAYER_NUMBER,
self.my.teamColor,
loc.x,
loc.y,
loc.h,
loc.xUncert,
loc.yUncert,
loc.hUncert,
loc.ballX,
loc.ballY,
loc.ballXUncert,
loc.ballYUncert,
self.ball.loc.dist,
self.ball.loc.bearing,
self.ball.vis.on,
self.play.role,
self.play.subRole,
self.playbook.pb.me.chaseTime,
loc.ballVelX,
loc.ballVelY))
self.out.logSComm(packet)
# TODO: Take this out once new comm is in...
def activeTeamMates(self):
activeMates = 0
for i in xrange(Constants.NUM_PLAYERS_PER_TEAM):
mate = self.teamMembers[i]
if mate.active:
activeMates += 1
return activeMates
def resetInitialLocalization(self):
"""
Reset loc according to team number and team color.
Note: Loc uses truly global coordinates.
"""
if self.my.teamColor == Constants.teamColor.TEAM_BLUE:
if self.my.playerNumber == 1:
self.loc.resetLocTo(Constants.BLUE_GOALBOX_RIGHT_X,
Constants.FIELD_WHITE_BOTTOM_SIDELINE_Y,
Constants.HEADING_UP,
_localization.LocNormalParams(15.0, 15.0, 1.0))
elif self.my.playerNumber == 2:
self.loc.resetLocTo(Constants.BLUE_GOALBOX_RIGHT_X,
Constants.FIELD_WHITE_TOP_SIDELINE_Y,
Constants.HEADING_DOWN,
_localization.LocNormalParams(15.0, 15.0, 1.0))
elif self.my.playerNumber == 3:
self.loc.resetLocTo(Constants.LANDMARK_BLUE_GOAL_CROSS_X,
Constants.FIELD_WHITE_TOP_SIDELINE_Y,
Constants.HEADING_DOWN,
_localization.LocNormalParams(15.0, 15.0, 1.0))
elif self.my.playerNumber == 4:
self.loc.resetLocTo(Constants.LANDMARK_BLUE_GOAL_CROSS_X,
Constants.FIELD_WHITE_BOTTOM_SIDELINE_Y,
Constants.HEADING_UP,
_localization.LocNormalParams(15.0, 15.0, 1.0))
else:
if self.my.playerNumber == 1:
self.loc.resetLocTo(Constants.YELLOW_GOALBOX_LEFT_X,
Constants.FIELD_WHITE_TOP_SIDELINE_Y,
Constants.HEADING_DOWN,
_localization.LocNormalParams(15.0, 15.0, 1.0))
elif self.my.playerNumber == 2:
self.loc.resetLocTo(Constants.YELLOW_GOALBOX_LEFT_X,
Constants.FIELD_WHITE_BOTTOM_SIDELINE_Y,
Constants.HEADING_UP,
_localization.LocNormalParams(15.0, 15.0, 1.0))
elif self.my.playerNumber == 3:
self.loc.resetLocTo(Constants.LANDMARK_YELLOW_GOAL_CROSS_X,
Constants.FIELD_WHITE_BOTTOM_SIDELINE_Y,
Constants.HEADING_UP,
_localization.LocNormalParams(15.0, 15.0, 1.0))
elif self.my.playerNumber == 4:
self.loc.resetLocTo(Constants.LANDMARK_YELLOW_GOAL_CROSS_X,
Constants.FIELD_WHITE_TOP_SIDELINE_Y,
Constants.HEADING_DOWN,
_localization.LocNormalParams(15.0, 15.0, 1.0))
# Loc knows the side of the field now. Reset accordingly.
self.onOwnFieldSide = True
#@todo: HACK HACK HACK Mexico 2012 to make sure we still re-converge properly even if
#we get manually positioned
#should make this nicer (or at least the locations)
def resetSetLocalization(self):
gameSetResetUncertainties = _localization.LocNormalParams(50, 200, 1.0)
if self.my.teamColor == Constants.teamColor.TEAM_BLUE:
# # if self.my.playerNumber == 1:
# # self.loc.resetLocTo(Constants.BLUE_GOALBOX_RIGHT_X,
# # Constants.FIELD_WHITE_BOTTOM_SIDELINE_Y,
# # Constants.HEADING_UP)
# if self.gameController.ownKickOff:
# self.loc.resetLocTo(Constants.LANDMARK_BLUE_GOAL_CROSS_X,
# Constants.CENTER_FIELD_Y,
# 0,
# gameSetResetUncertainties)
# else:
# self.loc.resetLocTo(Constants.BLUE_GOALBOX_RIGHT_X,
# Constants.CENTER_FIELD_Y,
# 0,
# gameSetResetUncertainties)
self.loc.resetLocToSide(True)
else:
# if self.gameController.ownKickOff:
# self.loc.resetLocTo(Constants.LANDMARK_YELLOW_GOAL_CROSS_X,
# Constants.CENTER_FIELD_Y,
# 180,
# gameSetResetUncertainties)
# else:
# self.loc.resetLocTo(Constants.YELLOW_GOALBOX_LEFT_X,
# Constants.CENTER_FIELD_Y,
# 180,
# gameSetResetUncertainties)
self.loc.resetLocToSide(False)
def resetLocalizationFromPenalty(self):
"""
Resets localization to both possible locations, depending on team color.
"""
if self.my.teamColor == Constants.teamColor.TEAM_BLUE:
self.loc.resetLocTo(Constants.LANDMARK_BLUE_GOAL_CROSS_X,
Constants.FIELD_WHITE_BOTTOM_SIDELINE_Y,
Constants.HEADING_UP,
Constants.LANDMARK_BLUE_GOAL_CROSS_X,
Constants.FIELD_WHITE_TOP_SIDELINE_Y,
Constants.HEADING_DOWN,
_localization.LocNormalParams(15.0, 15.0, 1.0),
_localization.LocNormalParams(15.0, 15.0, 1.0))
else:
self.loc.resetLocTo(Constants.LANDMARK_YELLOW_GOAL_CROSS_X,
Constants.FIELD_WHITE_BOTTOM_SIDELINE_Y,
Constants.HEADING_UP,
Constants.LANDMARK_YELLOW_GOAL_CROSS_X,
Constants.FIELD_WHITE_TOP_SIDELINE_Y,
Constants.HEADING_DOWN,
_localization.LocNormalParams(15.0, 15.0, 1.0),
_localization.LocNormalParams(15.0, 15.0, 1.0))
# Loc knows the side of the field now. Reset accordingly.
self.onOwnFieldSide = True
def resetGoalieLocalization(self):
"""
Resets the goalie's localization to the manual position in the goalbox.
"""
if self.my.teamColor == Constants.teamColor.TEAM_BLUE:
self.loc.resetLocTo(Constants.FIELD_WHITE_LEFT_SIDELINE_X,
Constants.MIDFIELD_Y,
Constants.HEADING_RIGHT,
_localization.LocNormalParams(15.0, 15.0, 1.0))
else:
self.loc.resetLocTo(Constants.FIELD_WHITE_RIGHT_SIDELINE_X,
Constants.MIDFIELD_Y,
Constants.HEADING_LEFT,
_localization.LocNormalParams(15.0, 15.0, 1.0))
# Loc knows the side of the field now. Reset accordingly.
self.onOwnFieldSide = True
#TODO: write this method!
def resetPenaltyKickLocalization(self):
pass
class Brain(object):
"""
Class brings all of our components together and runs the behaviors
"""
def __init__(self):
"""
Class constructor
"""
self.counter = 0
self.time = time.time()
self.on = True
# Output Class
self.out = NaoOutput.NaoOutput(self)
# Setup nao modules inside brain for easy access
self.vision = vision.vision
self.sensors = sensors.sensors
self.logger = loggingBoard.loggingBoard
self.comm = comm.inst
self.comm.gc.team = TeamConfig.TEAM_NUMBER
self.comm.gc.player = TeamConfig.PLAYER_NUMBER
#initalize the leds
#print leds
self.leds = Leds.Leds(self)
self.speech = _speech.speech
# Initialize motion interface and module references
self.motion = motion.MotionInterface()
self.motionModule = motion
# Get the pointer to the C++ RoboGuardian object for use with Python
self.roboguardian = _roboguardian.roboguardian
self.roboguardian.enableFallProtection(True)
# Get our reference to the C++ localization system
self.loc = Loc()
# Retrieve our robot identification and set per-robot parameters
self.CoA = robots.get_certificate()
self.CoA.setRobotGait(self.motion)
# coa is Certificate of Authenticity (to keep things short)
self.out.printf(self.CoA)
self.out.printf("GC: I am on team "+str(TeamConfig.TEAM_NUMBER))
self.out.printf("GC: I am player "+str(TeamConfig.PLAYER_NUMBER))
# Initialize various components
self.my = MyInfo(self.loc)
# Functional Variables
self.my.playerNumber = self.comm.gc.player
if self.comm.gc.color == GameController.TEAM_BLUE:
self.my.teamColor = Constants.teamColor.TEAM_BLUE
else:
self.my.teamColor = Constants.teamColor.TEAM_RED
# Information about the environment
self.initFieldObjects()
self.initTeamMembers()
self.ball = Ball(self.vision.ball, self.loc, self.my)
self.play = Play.Play()
self.sonar = Sonar.Sonar()
if Constants.LOG_COMM:
self.out.startCommLog()
# Stability data
self.stability = Stability.Stability(self.sensors)
# FSAs
self.player = Switch.selectedPlayer.SoccerPlayer(self)
self.tracker = HeadTracking.HeadTracking(self)
self.nav = Navigator.Navigator(self)
self.playbook = PBInterface.PBInterface(self)
self.kickDecider = KickDecider.KickDecider(self)
self.gameController = GameController.GameController(self)
self.fallController = FallController.FallController(self)
def initFieldObjects(self):
"""
Build our set of Field Objects which are team specific compared
to the generic forms used in the vision system
"""
# Build instances of the vision based field objects
# Left post is on that goalie's left
# Yellow goal left and right posts
self.yglp = FieldObject(self.vision.yglp,
Constants.vis_landmark.VISION_YGLP,
self.loc)
self.ygrp = FieldObject(self.vision.ygrp,
Constants.vis_landmark.VISION_YGRP,
self.loc)
# Blue Goal left and right posts
self.bglp = FieldObject(self.vision.bglp,
Constants.vis_landmark.VISION_BGLP,
self.loc)
self.bgrp = FieldObject(self.vision.bgrp,
Constants.vis_landmark.VISION_BGRP,
self.loc)
# Now we build the field objects to be based on our team color
self.makeFieldObjectsRelative()
def makeFieldObjectsRelative(self):
"""
Builds a list of fieldObjects based on their relative names to the robot
Needs to be called when team color is determined
"""
# Note: corner directions are relative to perspective of own goalie
# Blue team setup
if self.my.teamColor == Constants.teamColor.TEAM_BLUE:
# Yellow goal
self.oppGoalRightPost = self.yglp
self.oppGoalLeftPost = self.ygrp
# Blue Goal
self.myGoalLeftPost = self.bglp
self.myGoalRightPost = self.bgrp
# Yellow team setup
else:
# Yellow goal
self.myGoalLeftPost = self.yglp
self.myGoalRightPost = self.ygrp
# Blue Goal
self.oppGoalRightPost = self.bglp
self.oppGoalLeftPost = self.bgrp
# Since, for ex. bgrp points to the same things as myGoalLeftPost,
# we can set these regardless of our team color
self.myGoalLeftPost.associateWithRelativeLandmark(
Constants.LANDMARK_MY_GOAL_LEFT_POST)
self.myGoalRightPost.associateWithRelativeLandmark(
Constants.LANDMARK_MY_GOAL_RIGHT_POST)
self.oppGoalLeftPost.associateWithRelativeLandmark(
Constants.LANDMARK_OPP_GOAL_LEFT_POST)
self.oppGoalRightPost.associateWithRelativeLandmark(
Constants.LANDMARK_OPP_GOAL_RIGHT_POST)
# Build a list of all of the field objects with respect to team color
self.myFieldObjects = [self.yglp, self.ygrp, self.bglp, self.bgrp]
def initTeamMembers(self):
self.teamMembers = []
for i in xrange(Constants.NUM_PLAYERS_PER_TEAM):
mate = TeamMember.TeamMember(self)
mate.playerNumber = i + 1
self.teamMembers.append(mate)
##
##--------------CONTROL METHODS---------------##
##
def profile(self):
if self.counter == 0:
cProfile.runctx('self.run()', self.__dict__, locals(),
'pythonStats')
self.p = pstats.Stats('pythonStats')
elif self.counter < 3000:
self.p.add('pythonStats')
cProfile.runctx('self.run()', self.__dict__, locals(),
'pythonStats')
elif self.counter == 3000:
self.p.strip_dirs()
self.p.sort_stats('cumulative')
## print 'PYTHON STATS:'
## self.p.print_stats()
## print 'OUTGOING CALLEES:'
## self.p.print_callees()
## print 'OUTGOING CALLEES:'
## self.p.print_callers()
self.p.dump_stats('pythonStats')
self.counter += 1
def run(self):
"""
Main control loop called every TIME_STEP milliseconds
"""
# order here is very important
# Update Environment
self.time = time.time()
self.sonar.updateSensors(self.sensors)
# Communications update
self.updateComm()
# Update objects
self.update()
#Set LEDS
self.leds.processLeds()
# Behavior stuff
self.gameController.run()
self.fallController.run()
self.updatePlaybook()
self.player.run()
self.tracker.run()
self.nav.run()
# Broadcast Report for Teammates
self.setPacketData()
# Update any logs we have
self.out.updateLogs()
def updateComm(self):
temp = self.comm.latestComm()
for packet in temp:
if len(packet) == Constants.NUM_PACKET_ELEMENTS:
packet = Packet.Packet(packet)
if packet.playerNumber != self.my.playerNumber:
self.teamMembers[packet.playerNumber-1].update(packet)
if Constants.LOG_COMM:
self.out.logRComm(packet)
# update the activity of our teammates here
# active field is set to true upon recipt of a new packet.
for mate in self.teamMembers:
if (mate.active and mate.isDead()):
mate.active = False
def update(self):
"""
Update estimates of robot and ball positions on the field
"""
self.ball.update()
self.my.update()
self.yglp.setBest()
self.ygrp.setBest()
self.bglp.setBest()
self.bgrp.setBest()
def updatePlaybook(self):
"""
updates self.play to the new play
"""
self.playbook.update(self.play)
# move to comm
def setPacketData(self):
# Team color, team number, and player number are all appended to this
# list by the underlying comm module implemented in C++
loc = self.loc
self.comm.setData(loc.x,
loc.y,
loc.h,
loc.xUncert,
loc.yUncert,
loc.hUncert,
loc.ballX,
loc.ballY,
loc.ballXUncert,
loc.ballYUncert,
self.ball.dist,
self.ball.bearing,
self.play.role,
self.play.subRole,
self.playbook.pb.me.chaseTime,
loc.ballVelX,
loc.ballVelY)
if Constants.LOG_COMM:
packet = Packet.Packet((TeamConfig.TEAM_NUMBER,
TeamConfig.PLAYER_NUMBER,
self.my.teamColor,
loc.x,
loc.y,
loc.h,
loc.xUncert,
loc.yUncert,
loc.hUncert,
loc.ballX,
loc.ballY,
loc.ballXUncert,
loc.ballYUncert,
self.ball.dist,
self.ball.bearing,
self.play.role,
self.play.subRole,
self.playbook.pb.me.chaseTime,
loc.ballVelX,
loc.ballVelY))
self.out.logSComm(packet)
def resetLocalization(self):
"""
Reset our localization
"""
if self.out.loggingLoc:
self.out.stopLocLog()
self.out.startLocLog()
self.loc.reset()
def resetGoalieLocalization(self):
"""
Reset our localization
"""
if self.out.loggingLoc:
self.out.stopLocLog()
self.out.startLocLog()
if self.my.teamColor == Constants.teamColor.TEAM_BLUE:
self.loc.blueGoalieReset()
else:
self.loc.redGoalieReset()
class Brain(object):
"""
Class brings all of our components together and runs the behaviors
"""
def __init__(self):
"""
Class constructor
"""
self.counter = 0
self.time = time.time()
self.on = True
# Output Class
self.out = NaoOutput.NaoOutput(self)
# Setup nao modules inside brain for easy access
self.vision = vision.vision
self.sensors = sensors.sensors
self.logger = loggingBoard.loggingBoard
self.comm = comm.inst
self.comm.gc.team = TeamConfig.TEAM_NUMBER
self.comm.gc.player = TeamConfig.PLAYER_NUMBER
#initalize the leds
#print leds
self.leds = Leds.Leds(self)
self.speech = _speech.speech
# Initialize motion interface and module references
self.motion = motion.MotionInterface()
self.motionModule = motion
# Get the pointer to the C++ RoboGuardian object for use with Python
self.roboguardian = _roboguardian.roboguardian
self.roboguardian.enableFallProtection(True)
# Get our reference to the C++ localization system
self.loc = Loc()
# Retrieve our robot identification and set per-robot parameters
self.CoA = robots.get_certificate()
self.CoA.setRobotGait(self.motion)
# coa is Certificate of Authenticity (to keep things short)
self.out.printf(self.CoA)
self.out.printf("GC: I am on team " + str(TeamConfig.TEAM_NUMBER))
self.out.printf("GC: I am player " + str(TeamConfig.PLAYER_NUMBER))
# Initialize various components
self.my = MyInfo(self.loc)
# Functional Variables
self.my.playerNumber = self.comm.gc.player
if self.comm.gc.color == GameController.TEAM_BLUE:
self.my.teamColor = Constants.teamColor.TEAM_BLUE
else:
self.my.teamColor = Constants.teamColor.TEAM_RED
# Information about the environment
self.initFieldObjects()
self.initTeamMembers()
self.ball = Ball(self.vision.ball, self.loc, self.my)
self.play = Play.Play()
self.sonar = Sonar.Sonar()
if Constants.LOG_COMM:
self.out.startCommLog()
# Stability data
self.stability = Stability.Stability(self.sensors)
# FSAs
self.player = Switch.selectedPlayer.SoccerPlayer(self)
self.tracker = HeadTracking.HeadTracking(self)
self.nav = Navigator.Navigator(self)
self.playbook = PBInterface.PBInterface(self)
self.kickDecider = KickDecider.KickDecider(self)
self.gameController = GameController.GameController(self)
self.fallController = FallController.FallController(self)
def initFieldObjects(self):
"""
Build our set of Field Objects which are team specific compared
to the generic forms used in the vision system
"""
# Build instances of the vision based field objects
# Left post is on that goalie's left
# Note: As of 6/8/12, ygrp holds info about ambiguous posts
# Yellow goal left and right posts
self.yglp = FieldObject(self.vision.yglp,
Constants.vis_landmark.VISION_YGLP, self.loc)
self.ygrp = FieldObject(self.vision.ygrp,
Constants.vis_landmark.VISION_YGRP, self.loc)
# Blue Goal left and right posts
self.bglp = FieldObject(self.vision.bglp,
Constants.vis_landmark.VISION_BGLP, self.loc)
self.bgrp = FieldObject(self.vision.bgrp,
Constants.vis_landmark.VISION_BGRP, self.loc)
# Now we build the field objects to be based on our team color
self.makeFieldObjectsRelative()
def makeFieldObjectsRelative(self):
"""
Builds a list of fieldObjects based on their relative names to the robot
Needs to be called when team color is determined
"""
# Note: corner directions are relative to perspective of own goalie
# Blue team setup
if self.my.teamColor == Constants.teamColor.TEAM_BLUE:
# Yellow goal
self.oppGoalRightPost = self.yglp
self.oppGoalLeftPost = self.ygrp
# Blue Goal
self.myGoalLeftPost = self.bglp
self.myGoalRightPost = self.bgrp
# Yellow team setup
else:
# Yellow goal
self.myGoalLeftPost = self.yglp
self.myGoalRightPost = self.ygrp
# Blue Goal
self.oppGoalRightPost = self.bglp
self.oppGoalLeftPost = self.bgrp
# Since, for ex. bgrp points to the same things as myGoalLeftPost,
# we can set these regardless of our team color
self.myGoalLeftPost.associateWithRelativeLandmark(
Constants.LANDMARK_MY_GOAL_LEFT_POST)
self.myGoalRightPost.associateWithRelativeLandmark(
Constants.LANDMARK_MY_GOAL_RIGHT_POST)
self.oppGoalLeftPost.associateWithRelativeLandmark(
Constants.LANDMARK_OPP_GOAL_LEFT_POST)
self.oppGoalRightPost.associateWithRelativeLandmark(
Constants.LANDMARK_OPP_GOAL_RIGHT_POST)
# Build a list of all of the field objects with respect to team color
self.myFieldObjects = [self.yglp, self.ygrp, self.bglp, self.bgrp]
def initTeamMembers(self):
self.teamMembers = []
for i in xrange(Constants.NUM_PLAYERS_PER_TEAM):
mate = TeamMember.TeamMember(self)
mate.playerNumber = i + 1
self.teamMembers.append(mate)
##
##--------------CONTROL METHODS---------------##
##
def profile(self):
if self.counter == 0:
cProfile.runctx('self.run()', self.__dict__, locals(),
'pythonStats')
self.p = pstats.Stats('pythonStats')
elif self.counter < 3000:
self.p.add('pythonStats')
cProfile.runctx('self.run()', self.__dict__, locals(),
'pythonStats')
elif self.counter == 3000:
self.p.strip_dirs()
self.p.sort_stats('cumulative')
## print 'PYTHON STATS:'
## self.p.print_stats()
## print 'OUTGOING CALLEES:'
## self.p.print_callees()
## print 'OUTGOING CALLEES:'
## self.p.print_callers()
self.p.dump_stats('pythonStats')
self.counter += 1
def run(self):
"""
Main control loop called every TIME_STEP milliseconds
"""
# order here is very important
# Update Environment
self.time = time.time()
self.sonar.updateSensors(self.sensors)
# Communications update
self.updateComm()
# Update objects
self.updateObjects()
# Behavior stuff
self.gameController.run()
self.fallController.run()
self.updatePlaybook()
self.player.run()
self.tracker.run()
self.nav.run()
# Kinda of a hack...
# check and set loc boolean
if ((self.my.teamColor == Constants.teamColor.TEAM_BLUE and self.loc.x
> Constants.MIDFIELD_X - Constants.CENTER_CIRCLE_RADIUS) or
(self.my.teamColor == Constants.teamColor.TEAM_RED and self.loc.x <
Constants.MIDFIELD_X + Constants.CENTER_CIRCLE_RADIUS)):
self.onOwnFieldSide = False
#Set LEDS
self.leds.processLeds()
# Broadcast Report for Teammates
self.setPacketData()
# Update any logs we have
self.out.updateLogs()
def updateComm(self):
temp = self.comm.latestComm()
for packet in temp:
if len(packet) == Constants.NUM_PACKET_ELEMENTS:
packet = Packet.Packet(packet)
if packet.playerNumber != self.my.playerNumber:
self.teamMembers[packet.playerNumber - 1].update(packet)
if Constants.LOG_COMM:
self.out.logRComm(packet)
# update the activity of our teammates here
# active field is set to true upon recipt of a new packet.
for mate in self.teamMembers:
if (mate.active and mate.isDead()):
mate.active = False
def updateObjects(self):
"""
Update estimates of robot and ball positions on the field
"""
self.ball.update()
self.my.update()
self.yglp.setBest()
self.ygrp.setBest()
self.bglp.setBest()
self.bgrp.setBest()
def updatePlaybook(self):
"""
updates self.play to the new play
"""
self.playbook.update(self.play)
# move to comm
def setPacketData(self):
# Team color, team number, and player number are all appended to this
# list by the underlying comm module implemented in C++
loc = self.loc
self.comm.setData(loc.x, loc.y, loc.h, loc.xUncert, loc.yUncert,
loc.hUncert, loc.ballX, loc.ballY, loc.ballXUncert,
loc.ballYUncert, self.ball.loc.dist,
self.ball.loc.bearing, self.ball.vis.on,
self.play.role, self.play.subRole,
self.playbook.pb.me.chaseTime, loc.ballVelX,
loc.ballVelY)
# TODO: remove this and log through C++ and the Logger instead.
if Constants.LOG_COMM:
packet = Packet.Packet(
(TeamConfig.TEAM_NUMBER, TeamConfig.PLAYER_NUMBER,
self.my.teamColor, loc.x, loc.y, loc.h, loc.xUncert,
loc.yUncert, loc.hUncert, loc.ballX, loc.ballY,
loc.ballXUncert, loc.ballYUncert, self.ball.loc.dist,
self.ball.loc.bearing, self.ball.vis.on, self.play.role,
self.play.subRole, self.playbook.pb.me.chaseTime,
loc.ballVelX, loc.ballVelY))
self.out.logSComm(packet)
# TODO: Take this out once new comm is in...
def activeTeamMates(self):
activeMates = 0
for i in xrange(Constants.NUM_PLAYERS_PER_TEAM):
mate = self.teamMembers[i]
if mate.active:
activeMates += 1
return activeMates
def resetInitialLocalization(self):
"""
Reset loc according to team number and team color.
Note: Loc uses truly global coordinates.
"""
if self.my.teamColor == Constants.teamColor.TEAM_BLUE:
if self.my.playerNumber == 1:
self.loc.resetLocTo(
Constants.BLUE_GOALBOX_RIGHT_X,
Constants.FIELD_WHITE_BOTTOM_SIDELINE_Y,
Constants.HEADING_UP,
_localization.LocNormalParams(15.0, 15.0, 1.0))
elif self.my.playerNumber == 2:
self.loc.resetLocTo(
Constants.BLUE_GOALBOX_RIGHT_X,
Constants.FIELD_WHITE_TOP_SIDELINE_Y,
Constants.HEADING_DOWN,
_localization.LocNormalParams(15.0, 15.0, 1.0))
elif self.my.playerNumber == 3:
self.loc.resetLocTo(
Constants.LANDMARK_BLUE_GOAL_CROSS_X,
Constants.FIELD_WHITE_TOP_SIDELINE_Y,
Constants.HEADING_DOWN,
_localization.LocNormalParams(15.0, 15.0, 1.0))
elif self.my.playerNumber == 4:
self.loc.resetLocTo(
Constants.LANDMARK_BLUE_GOAL_CROSS_X,
Constants.FIELD_WHITE_BOTTOM_SIDELINE_Y,
Constants.HEADING_UP,
_localization.LocNormalParams(15.0, 15.0, 1.0))
else:
if self.my.playerNumber == 1:
self.loc.resetLocTo(
Constants.YELLOW_GOALBOX_LEFT_X,
Constants.FIELD_WHITE_TOP_SIDELINE_Y,
Constants.HEADING_DOWN,
_localization.LocNormalParams(15.0, 15.0, 1.0))
elif self.my.playerNumber == 2:
self.loc.resetLocTo(
Constants.YELLOW_GOALBOX_LEFT_X,
Constants.FIELD_WHITE_BOTTOM_SIDELINE_Y,
Constants.HEADING_UP,
_localization.LocNormalParams(15.0, 15.0, 1.0))
elif self.my.playerNumber == 3:
self.loc.resetLocTo(
Constants.LANDMARK_YELLOW_GOAL_CROSS_X,
Constants.FIELD_WHITE_BOTTOM_SIDELINE_Y,
Constants.HEADING_UP,
_localization.LocNormalParams(15.0, 15.0, 1.0))
elif self.my.playerNumber == 4:
self.loc.resetLocTo(
Constants.LANDMARK_YELLOW_GOAL_CROSS_X,
Constants.FIELD_WHITE_TOP_SIDELINE_Y,
Constants.HEADING_DOWN,
_localization.LocNormalParams(15.0, 15.0, 1.0))
# Loc knows the side of the field now. Reset accordingly.
self.onOwnFieldSide = True
#@todo: HACK HACK HACK Mexico 2012 to make sure we still re-converge properly even if
#we get manually positioned
#should make this nicer (or at least the locations)
def resetSetLocalization(self):
gameSetResetUncertainties = _localization.LocNormalParams(50, 200, 1.0)
if self.my.teamColor == Constants.teamColor.TEAM_BLUE:
# # if self.my.playerNumber == 1:
# # self.loc.resetLocTo(Constants.BLUE_GOALBOX_RIGHT_X,
# # Constants.FIELD_WHITE_BOTTOM_SIDELINE_Y,
# # Constants.HEADING_UP)
# if self.gameController.ownKickOff:
# self.loc.resetLocTo(Constants.LANDMARK_BLUE_GOAL_CROSS_X,
# Constants.CENTER_FIELD_Y,
# 0,
# gameSetResetUncertainties)
# else:
# self.loc.resetLocTo(Constants.BLUE_GOALBOX_RIGHT_X,
# Constants.CENTER_FIELD_Y,
# 0,
# gameSetResetUncertainties)
self.loc.resetLocToSide(True)
else:
# if self.gameController.ownKickOff:
# self.loc.resetLocTo(Constants.LANDMARK_YELLOW_GOAL_CROSS_X,
# Constants.CENTER_FIELD_Y,
# 180,
# gameSetResetUncertainties)
# else:
# self.loc.resetLocTo(Constants.YELLOW_GOALBOX_LEFT_X,
# Constants.CENTER_FIELD_Y,
# 180,
# gameSetResetUncertainties)
self.loc.resetLocToSide(False)
def resetLocalizationFromPenalty(self):
"""
Resets localization to both possible locations, depending on team color.
"""
if self.my.teamColor == Constants.teamColor.TEAM_BLUE:
self.loc.resetLocTo(Constants.LANDMARK_BLUE_GOAL_CROSS_X,
Constants.FIELD_WHITE_BOTTOM_SIDELINE_Y,
Constants.HEADING_UP,
Constants.LANDMARK_BLUE_GOAL_CROSS_X,
Constants.FIELD_WHITE_TOP_SIDELINE_Y,
Constants.HEADING_DOWN,
_localization.LocNormalParams(15.0, 15.0, 1.0),
_localization.LocNormalParams(15.0, 15.0, 1.0))
else:
self.loc.resetLocTo(Constants.LANDMARK_YELLOW_GOAL_CROSS_X,
Constants.FIELD_WHITE_BOTTOM_SIDELINE_Y,
Constants.HEADING_UP,
Constants.LANDMARK_YELLOW_GOAL_CROSS_X,
Constants.FIELD_WHITE_TOP_SIDELINE_Y,
Constants.HEADING_DOWN,
_localization.LocNormalParams(15.0, 15.0, 1.0),
_localization.LocNormalParams(15.0, 15.0, 1.0))
# Loc knows the side of the field now. Reset accordingly.
self.onOwnFieldSide = True
def resetGoalieLocalization(self):
"""
Resets the goalie's localization to the manual position in the goalbox.
"""
if self.my.teamColor == Constants.teamColor.TEAM_BLUE:
self.loc.resetLocTo(Constants.FIELD_WHITE_LEFT_SIDELINE_X,
Constants.MIDFIELD_Y, Constants.HEADING_RIGHT,
_localization.LocNormalParams(15.0, 15.0, 1.0))
else:
self.loc.resetLocTo(Constants.FIELD_WHITE_RIGHT_SIDELINE_X,
Constants.MIDFIELD_Y, Constants.HEADING_LEFT,
_localization.LocNormalParams(15.0, 15.0, 1.0))
# Loc knows the side of the field now. Reset accordingly.
self.onOwnFieldSide = True
#TODO: write this method!
def resetPenaltyKickLocalization(self):
pass
class Pong:
"""The class that sets up and runs the game."""
def __init__(self):
"""Initiate pyxel, set up initial game variables, and run."""
pyxel.init(WIDTH, HEIGHT, caption="Pong!", scale=8, fps=60)
self.music = Music()
self.reset_game()
pyxel.run(self.update, self.draw)
def reset_game(self):
"""Reset score and position."""
self.l_score = 0
self.r_score = 0
self.finish = False
self.music.start_music()
self.l_paddle = Paddle(
coordinates=(PADDLE_SIDE, (HEIGHT - PADDLE_HEIGHT) // 2),
colour=COL_PADDLE,
width=PADDLE_WIDTH,
height=PADDLE_HEIGHT,
control_up=pyxel.KEY_W,
control_down=pyxel.KEY_S,
move_speed=PADDLE_MOVE_SPEED,
dimensions=DIMENSIONS,
)
self.r_paddle = Paddle(
coordinates=(
WIDTH - PADDLE_SIDE - PADDLE_WIDTH,
(HEIGHT - PADDLE_HEIGHT) // 2,
),
colour=COL_PADDLE,
width=PADDLE_WIDTH,
height=PADDLE_HEIGHT,
control_up=pyxel.KEY_UP,
control_down=pyxel.KEY_DOWN,
move_speed=PADDLE_MOVE_SPEED,
dimensions=DIMENSIONS,
)
self.ball = Ball(
coordinates=(WIDTH // 2, HEIGHT // 2),
colour=COL_BALL,
width=BALL_SIDE,
height=BALL_SIDE,
initial_velocity=BALL_INITIAL_VELOCITY,
dimensions=DIMENSIONS,
)
self.sparkler = ParticleEmitter(self.ball)
pickup_types = {
"sparkle": PickupType(14, self.sparkler.turn_on, self.sparkler.turn_off),
"expand": PickupType(12, self.expand_paddle, self.contract_paddle),
"slow": PickupType(8, self.slow_paddle, self.speed_paddle),
"bounce": PickupType(11, self.ball.bounce_on, self.ball.bounce_off),
"giantball": PickupType(10, self.ball.giant_on, self.ball.giant_off),
}
self.expand_stack = []
self.speed_stack = []
pickup_side_buffer = PADDLE_WIDTH + PADDLE_SIDE + 2
self.pickups = Pickups(
pickup_types, self.music, pickup_side_buffer, WIDTH - pickup_side_buffer, 0, HEIGHT
)
self.reset_after_score()
def reset_after_score(self):
"""Reset paddles and ball."""
self.start = pyxel.frame_count + 50
self.speed_up = self.start + SPEED_PERIOD
self.ball.reset()
##############
# Game logic #
##############
def update(self):
"""Update logic of game. Updates the paddles, ball, and checks for scoring/win condition."""
self.l_paddle.update()
self.r_paddle.update()
self.sparkler.sparkle()
if pyxel.frame_count > self.start and not self.finish:
outcome = self.ball.update()
if outcome:
self.score(outcome)
self.check_speed()
if self.ball.check_collision([self.l_paddle, self.r_paddle]):
self.music.sfx_hit()
self.pickups.check_pickup()
self.pickups.check_collision(self.ball)
if pyxel.btn(pyxel.KEY_Q):
pyxel.quit()
if pyxel.btnp(pyxel.KEY_R):
self.reset_game()
def check_speed(self):
"""Adds velocity to the ball periodically."""
if pyxel.frame_count > self.speed_up:
self.speed_up += SPEED_PERIOD
self.ball.x_vol += SPEED_AMOUNT * sign(self.ball.x_vol)
self.ball.y_vol += SPEED_AMOUNT * sign(self.ball.y_vol)
def score(self, outcome):
"""Adds to the score if the ball hits the side. Check win condition."""
self.music.sfx_score()
if outcome == "l":
self.l_score += 1
elif outcome == "r":
self.r_score += 1
if self.l_score >= WIN_CONDITION or self.r_score >= WIN_CONDITION:
self.win_event()
self.reset_after_score()
def win_event(self):
"""What happens when someone wins the game!"""
self.finish = True
self.music.stop_music()
self.music.sfx_finish()
######################
# Pickup controllers #
######################
def expand_paddle(self):
"""Expand the pandle temporarily."""
if self.ball.x_vol > 0:
paddle = self.l_paddle
else:
paddle = self.r_paddle
paddle.height = PADDLE_HEIGHT_EXPANDED
paddle.y -= (PADDLE_HEIGHT_EXPANDED - PADDLE_HEIGHT) // 2
self.expand_stack.append(paddle)
def contract_paddle(self):
"""Revert paddle side to normal."""
paddle = self.expand_stack.pop(0)
if paddle not in self.expand_stack:
paddle.height = PADDLE_HEIGHT
paddle.y += (PADDLE_HEIGHT_EXPANDED - PADDLE_HEIGHT) // 2
def slow_paddle(self):
"""Slow the pandle temporarily."""
if self.ball.x_vol > 0:
paddle = self.l_paddle
else:
paddle = self.r_paddle
paddle.move_speed = PADDLE_MOVE_SPEED_SLOW
paddle.colour = COL_PADDLE_SLOW
self.speed_stack.append(paddle)
def speed_paddle(self):
"""Speed the paddle back up to normal speed."""
paddle = self.speed_stack.pop(0)
if paddle not in self.speed_stack:
paddle.move_speed = PADDLE_MOVE_SPEED
paddle.colour = COL_PADDLE
##############
# Draw logic #
##############
def draw(self):
"""Draw the paddles and ball OR the end screen."""
if self.finish:
self.draw_end_screen()
else:
pyxel.cls(COL_BACKGROUND)
self.sparkler.display()
self.l_paddle.display()
self.r_paddle.display()
self.pickups.display()
self.ball.display()
self.draw_score()
def draw_score(self):
"""Draw the score at the top."""
l_score = "{:01}".format(self.l_score)
r_score = "{:01}".format(self.r_score)
buffer = PADDLE_SIDE + PADDLE_WIDTH + 2
r_x_position = WIDTH - FONT_WIDTH - buffer
pyxel.text(x=buffer, y=2, s=l_score, col=COL_SCORE)
pyxel.text(x=r_x_position, y=2, s=r_score, col=COL_SCORE)
def draw_end_screen(self):
"""Draw the final screen with the winner!"""
pyxel.cls(col=COL_FINISH)
display_text = TEXT_FINISH[:]
if self.l_score >= WIN_CONDITION:
winner = "The LEFT player!"
else:
winner = "The RIGHT player!"
display_text.insert(1, winner)
for i, text in enumerate(display_text):
y_offset = (FONT_HEIGHT + 2) * i
text_x = self.center_text(text, WIDTH)
pyxel.text(text_x, HEIGHT_FINISH + y_offset, text, COL_FINISH_TEXT)
@staticmethod
def center_text(text, page_width, char_width=FONT_WIDTH):
"""Helper function for calcuating the start x value for centered text."""
text_width = len(text) * char_width
return (page_width - text_width) // 2
def main():
clock = pygame.time.Clock()
pygame.init()
# Some extra variables
asseleration = 0.025
speed_game = 30
points = 0
direction = "left_down"
# Initializing objects
player = Player()
ball = Ball()
# Adding ball to group balls (that's for collision)
balls = pygame.sprite.Group()
balls.add(ball)
# Making group of all sprites (to blit them later faster)
all_sprites = pygame.sprite.Group()
all_sprites.add(player)
all_sprites.add(ball)
running = True
screen = pygame.display.set_mode((C.SCREEN_WIDTH, C.SCREEN_HEIGHT))
pygame.display.set_caption("Ping-Pong")
font = pygame.font.SysFont('Arial', 800)
# Main loop
while running:
# Check wheather ball hits botoom
running = check_collision(player, ball, balls, direction)[0]
# Checking events for quiting
for event in pygame.event.get():
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
running = False
elif event.type == QUIT:
running = False
# User's input
pressed_keys = pygame.key.get_pressed()
# Updating ackground
screen.fill((25, 50, 50))
# Rendering text and drawing it
text_points = font.render('{0}'.format(points), True, (100, 100, 100))
text_points_rect = text_points.get_rect(center = (C.SCREEN_WIDTH/2, C.SCREEN_HEIGHT/2))
screen.blit(text_points, text_points_rect)
# Updating objects
player.update(pressed_keys)
ball.update(direction)
# Drawing objects
for sprite in all_sprites:
screen.blit(sprite.surf, sprite.rect)
points += check_collision(player, ball, balls, direction)[1]
direction = check_collision(player, ball, balls, direction)[2]
# flipping and asselereting of framerate
pygame.display.flip()
if speed_game <+ 120:
speed_game += asseleration
clock.tick(speed_game)
pygame.quit()
over.over(points)
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
screen.fill(cl_off_black)
screen.blit(update_fps(), (16, 5))
if ball.is_colliding_with(left_paddle) or left_paddle.is_colliding_with(
ball):
print("Colliding left")
ball.bounce_x()
keys = pygame.key.get_pressed()
if keys[pygame.K_w]:
left_paddle.move(dy=-PADDLE_SPEED)
if keys[pygame.K_s]:
left_paddle.move(dy=PADDLE_SPEED)
if keys[pygame.K_UP]:
left_paddle.move(dy=-PADDLE_SPEED)
if keys[pygame.K_DOWN]:
left_paddle.move(dy=PADDLE_SPEED)
ball.update()
left_paddle.draw(on=screen)
right_paddle.draw(on=screen)
ball.draw(on=screen)
# --- Limit to 60 frames per second
clock.tick(FPS)
pygame.display.flip()
angle = 45 * (2 * circle_count - 1)
x, y = get_circle_position(angle)
circle = Circle(x, y, circle_count, win)
circle_group.add(circle)
if event.type == pygame.MOUSEBUTTONDOWN:
clicked = False
if home_page:
image, rect, angle = rotate_image(r_msg, r_rect, angle)
win.blit(image, rect)
win.blit(otate_msg, (120, HEIGHT // 2 - 190))
win.blit(dash_msg, (140, HEIGHT // 2 - 140))
ball.alive = True
ball.update(color, True)
tap_to_play.update()
if score_page:
if score_bg > 40:
score_bg -= 1
win.fill((score_bg, score_bg, score_bg))
if score and score > high_score:
high_score = score
new_high_msg.update(shadow=False)
final_score_msg.update(score, color)
if close_btn.draw(win):
