def Qtesting(self):
self.resetGameForTraining()
while self.isGameOver() == False:
for event in pygame.event.get():
if event.type == pygame.QUIT:
gameExit = True
self.sendStateVars()
self.calc_receive()
for keeper in self.keeperArray:
keeper.isInTraining = False
keeper.decisionFlowChart()
for taker in self.takerArray:
taker.decisionFlowChart()
newBallPoint = kUtil.addVectorToPoint(self.fieldBall.trueBallPos, kUtil.scalarMultiply(self.maxBallSpeed, kUtil.unitVector(self.fieldBall.trueBallDirection)))
self.fieldBall.updateCoordinate(newBallPoint)
for i in range(len(self.takerArray)):
self.takerArray[i].noisyBallPos = kUtil.getNoisyVals(self.fieldBall.trueBallPos, self.takerArray[i].sigma)
for i in range(len(self.keeperArray)):
self.keeperArray[i].noisyBallPos = kUtil.getNoisyVals(self.fieldBall.trueBallPos, self.keeperArray[i].sigma)
self.updateBallPosession()
self.updateScore()
self.drawWorld ()
self.displayScore()
pygame.display.update()
#this specifies frames per second
self.clock.tick(self.fps)
if self.isGameOver() == True:
gameExit = True
print("final score: ", self.keeperScore)
self.finish()
#self.pause("Game Over: Final Score %d" % self.keeperScore)
self.exitSim()
def resetGameForTraining(self):
#reset the ball variables
row = random.randint(0, int(self.display_height/2))
col = random.randint(int(self.display_width/4), int (self.display_width/4 * 3))
self.fieldBall.updateCoordinate((row,col))
self.fieldBall.update((0.0,0.0))
#reset the score
self.keeperScore = 0
#now reset the agent variables:
self.keeperArray[0].true_pos = (12.5, 12.5)
self.keeperArray[1].true_pos = (25, self.display_width - 37.5)
self.keeperArray[2].true_pos = (self.display_height - 37.5, self.display_width - 37.5)
self.takerArray[0].true_pos = (self.display_height - 25, 25)
self.takerArray[1].true_pos = (self.display_height - 37.5, 50)
for i in range(len(self.keeperArray)):
self.keeperArray[i].noisy_pos = kUtil.getNoisyVals(self.keeperArray[i].true_pos, self.keeperArray[i].sigma)
self.keeperArray[i].noisyBallPos = kUtil.getNoisyVals(self.fieldBall.trueBallPos,self.keeperArray[i].sigma)
self.keeperArray[i].inPosession = False
self.keeperArray[i].isKicking = False
for i in range(len(self.takerArray)):
self.takerArray[i].noisy_pos = kUtil.getNoisyVals(self.takerArray[i].true_pos, self.takerArray[i].sigma)
self.takerArray[i].noisyBallPos = kUtil.getNoisyVals(self.fieldBall.trueBallPos, self.takerArray[i].sigma)
self.takerArray[i].inPosession = False
self.takerArray[i].isKicking = False
def __boundSimpleVars(self, noisySimpleStateVars):
"""
For the sake of simulating sensor error, some noise is added to the state variables
that are calculated. However, the last 2 state variables are cosine values. Cosine values
are bounded [-1.0, 1.0], so this function was made to ensure that the last 2 state variables are
bounded by [-1.0, 1.0] after noise is added to it. This is important because the arccos
of these 2 state variables is calculated sometimes, and if the value input into arccos
just so happens to be out of this range,the program will crash.
:param noisySimpleStateVars: The noisy version of the simple state variables. This should
be calculated in the sendSimpleStateVars function of keepaway.py.
:type noisySimpleStateVars: tuple or list of floats
:returns: the noisySimpleStateVars, but with the last 2 parameters bounded by [-1.0, 1.0]
:rtype: tuple or list of floats
"""
varIndex11 = noisySimpleStateVars[11]
varIndex12 = noisySimpleStateVars[12]
while (varIndex11 > 1.0 or varIndex11 < -1.0):
varIndex11 = kUtil.getNoisyVals(noisySimpleStateVars[11], self.agentSigmaError)
while (varIndex12 > 1.0 or varIndex12 < -1.0):
varIndex12 = kUtil.getNoisyVals(noisySimpleStateVars[12], self.agentSigmaError)
if varIndex11 > 1.0 or varIndex11 < -1.0 or varIndex12 > 1.0 or varIndex12 < -1.0:
print("Values still out of range: varIndex11 = ", varIndex11, ", varIndex12 = ", varIndex12)
return noisySimpleStateVars[:11] + (varIndex11, varIndex12)
def __moveAgent(self, inputAgent, movementVector): """ This is a private function that is called by the moveAttempt function. this function is only called if a move is determined to be legal. Once the move is determined to be legal, this function will go and update the position of the agent on the field. :param inputAgent: a reference to the agent that is is being moved. :param movementVector: the vector that will be added to the inputAgent's current position. The sum of the current position and the movementVector will be the new position of the inputAgent. :type inputAgent: agent :type movementVector: a tuple of floats :returns: no return .. note:: This is a private function that the user shouldn't worry about calling. Only the move_attempt() function should be called. """ if inputAgent.getAgentType() == "keeper": newNoiseFreePos = kUtil.addVectorToPoint(self.keeperTruePosArray[inputAgent.getSimIndex()], movementVector) self.keeperTruePosArray[inputAgent.getSimIndex()] = newNoiseFreePos elif inputAgent.getAgentType() == "taker": newNoiseFreePos = kUtil.addVectorToPoint(self.takerTruePosArray[inputAgent.getSimIndex()], movementVector) self.takerTruePosArray[inputAgent.getSimIndex()] = newNoiseFreePos inputAgent.updateAgentPosition(kUtil.getNoisyVals(newNoiseFreePos, self.agentSigmaError))
def _passBall(self, pointToPassTo):
'''
If a keeper currently has the ball, then it has the option to hold the ball,
or pass it. Call this function to pass the ball. pointToPassTo is the coordinate that
the keeper can pass to. these are pixel values
:param pointToPassTo: the tile that the agent is passing to. It is an XY coordinate defined to be the top left
corner of the tile you're trying to pass to
:type pointToPassTo: typle of int
:returns: no return
'''
if self.fieldBall == None:
print("ERROR: trying to hold ball without actually having ball")
return
#pass to team mate integerK. if integerK = 1, then it's the 2nd element in array
selfToTargetDirection = kUtil.unitVector(kUtil.getVector(self.__getBallCenter(self.noisyBallPos), pointToPassTo))
selfToTargetVector = (kUtil.scalarMultiply(self.fieldBall.maxBallSpeed, selfToTargetDirection))
#at this point, you've determined the angle you wanna pass, and you pass.
#set ball's possesion to false, and update to new point. ball class handles direction vector
self.fieldBall.updatePosession(False)
self.inPosession = False
self.isKicking = True
#kUtil.addVectorToPoint(self.fieldBall.trueBallPos, selfToTeammateVector)
self.fieldBall.updateDirection(kUtil.getNoisyVals(selfToTargetVector, self.getSigma()))
def sendCalcReceiveDecision(self):
"""
This public function will send all keepers the receive decision. For more information
on what the receive decision is, refer to the documentation of the module "calcReceive"
:returns: no return
"""
rDecision = calcReceive.calc_receive(self)
print("rDecision decided upon:")
print(rDecision)
for i in range(len(self.keeperArray)):
rNoisyDecision = (rDecision[0], kUtil.getNoisyVals(rDecision[1], self.agentSigmaError))
self.keeperArray[i].receiveDecision(rNoisyDecision)
for i in range(len(self.takerArray)):
rNoisyDecision = (rDecision[0], kUtil.getNoisyVals(rDecision[1], self.agentSigmaError))
self.takerArray[i].receiveDecision(rNoisyDecision)
def _sendCalcReceiveDecision(self):
"""
This public function will send all keepers the receive decision. For more information
on what the receive decision is, refer to the documentation of the module "calcReceive"
:returns: no return
"""
#note: rDecision is only global so that it can be debugged. Once debugging is done, make it local again
rDecision = calcReceive.calc_receive(self)
#print("rDecision decided upon:")
#print(rDecision)
for i in range(len(self.keeperArray)):
rNoisyDecision= (rDecision[0], kUtil.getNoisyVals(rDecision[1], self.agentSigmaError))
self.keeperArray[i].receiveDecision(rNoisyDecision)
for i in range(len(self.takerArray)):
rNoisyDecision= (rDecision[0], kUtil.getNoisyVals(rDecision[1], self.agentSigmaError))
self.takerArray[i].receiveDecision(rNoisyDecision)
def __init__(self, worldRef, pos, sigma, agentType, trueBallPos, maxPlayerSpeed, maxBallSpeed, inPossession = False):
self.sigma = sigma
self.true_pos = pos
self.noisy_pos = kUtil.getNoisyVals(self.true_pos, self.sigma)
self.agentType = agentType
self.maxPlayerSpeed = maxPlayerSpeed
self.keeperArray = None
self.takerArray = None
self.agentListIndex = None
self.stateVariables = None
self.onReceiveDecision = None #receive variables
self.worldRef = worldRef
#BALL VARIABLES
self.noisyBallPos = kUtil.getNoisyVals(trueBallPos, self.sigma)
self.maxBallSpeed = maxBallSpeed
self.fieldBall = None
self.inPosession = False
self.isKicking = False
def _sendSimpleStateVars(self): """ This public function will send all keepers the simple state variables. This function should be called for intelligent agents such as NEAT, or Sarsa. This function will NOT be called for hyperNEAT, which will instead, get a birds eye view of the entire field :returns: no return """ #get the state variables self.simpleStateVars = getSimpleStateVars.getStateVarsKeepers(self.keeperArray, self.takerArray, self.__field_center) #send the state variables to each keeper and taker for i in range(len(self.keeperArray)): noisyCurrVars = kUtil.getNoisyVals(self.simpleStateVars, self.agentSigmaError) noisyCurrVars = self.__boundSimpleVars(noisyCurrVars) self.keeperArray[i].receiveSimpleStateVariables(noisyCurrVars) for i in range(len(self.takerArray)): noisyCurrVars = kUtil.getNoisyVals(self.simpleStateVars, self.agentSigmaError) noisyCurrVars = self.__boundSimpleVars(noisyCurrVars) self.takerArray[i].receiveSimpleStateVariables(noisyCurrVars)
def resetGameForTraining(self):
"""
This is a public function that is meant for resetting the simulator when in
training mode. Training mode will be used by the intelligent agents such as
SARSA, NEAT, hyperNEAT, etc.
:returns: no return
"""
# reset the ball variables
row = random.randint(0, int(self.display_height / 2))
col = random.randint(int(self.__display_width / 4), int(self.__display_width / 4 * 3))
self.fieldBall.updateCoordinate((row, col))
self.fieldBall.update((0.0, 0.0))
# reset the score
self.keeperScore = 0
# now reset the agent positions:
self.keeperTruePosArray[0] = (12.5, 12.5)
self.keeperTruePosArray[1] = (25, self.__display_width - 37.5)
self.keeperTruePosArray[2] = (self.display_height - 37.5, self.__display_width - 37.5)
self.takerTruePosArray[0] = (self.display_height - 25, 25)
self.takerTruePosArray[1] = (self.display_height - 37.5, 50)
for i in range(len(self.keeperArray)):
self.keeperArray[i].updateAgentPosition(
kUtil.getNoisyVals(self.keeperTruePosArray[i], self.agentSigmaError)
)
self.keeperArray[i].noisyBallPos = kUtil.getNoisyVals(
self.fieldBall.trueBallPos, self.keeperArray[i].getSigma()
)
self.keeperArray[i].inPosession = False
self.keeperArray[i].isKicking = False
for i in range(len(self.takerArray)):
self.takerArray[i].updateAgentPosition(kUtil.getNoisyVals(self.takerTruePosArray[i], self.agentSigmaError))
self.takerArray[i].noisyBallPos = kUtil.getNoisyVals(
self.fieldBall.trueBallPos, self.takerArray[i].getSigma()
)
self.takerArray[i].inPosession = False
self.takerArray[i].isKicking = False
def QTraining(self,totalTraining):
for training in range(totalTraining):
print("Training number :",training)
if training%100 == 0:
self.displayGraphics = True
else:
self.displayGraphics = False
self.resetGameForTraining()
while self.isGameOver() == False:
for event in pygame.event.get():
if event.type == pygame.QUIT:
gameExit = True
self.sendStateVars()
reward = 100000
for keeper in self.keeperArray:
keeper.updateReward(reward)
self.calc_receive()
for keeper in self.keeperArray:
keeper.isInTraining = True
keeper.decisionFlowChart()
for taker in self.takerArray:
taker.decisionFlowChart()
newBallPoint = kUtil.addVectorToPoint(self.fieldBall.trueBallPos, kUtil.scalarMultiply(self.maxBallSpeed, kUtil.unitVector(self.fieldBall.trueBallDirection)))
self.fieldBall.updateCoordinate(newBallPoint)
for i in range(len(self.takerArray)):
self.takerArray[i].noisyBallPos = kUtil.getNoisyVals(self.fieldBall.trueBallPos, self.takerArray[i].sigma)
for i in range(len(self.keeperArray)):
self.keeperArray[i].noisyBallPos = kUtil.getNoisyVals(self.fieldBall.trueBallPos, self.keeperArray[i].sigma)
self.updateBallPosession()
self.updateScore()
if(self.displayGraphics == True):
self.drawWorld ()
self.displayScore()
pygame.display.update()
if self.isGameOver():
reward = -100
self.sendStateVars()
for keeper in self.keeperArray:
keeper.updateFinalReward(reward)
self.clock.tick(10000)
def commonFunctionality(self, mode, showDisplay = True, turnOnGrid = False, prettyGrid = False): #this is common code that will occur regardless of what agent you picked #if (self.fieldBall.inPosession == False): newBallPoint = kUtil.addVectorToPoint(self.fieldBall.trueBallPos, kUtil.scalarMultiply(self.maxBallSpeed, kUtil.unitVector(self.fieldBall.trueBallDirection))) self.fieldBall.updateCoordinate(newBallPoint) for i in range(len(self.takerArray)): self.takerArray[i].noisyBallPos = kUtil.getNoisyVals(self.fieldBall.trueBallPos, self.takerArray[i].getSigma()) for i in range(len(self.keeperArray)): self.keeperArray[i].noisyBallPos = kUtil.getNoisyVals(self.fieldBall.trueBallPos, self.keeperArray[i].getSigma()) self.__updateBallPosession() self.__updateScore() #remove this line if you don't want the grid to be drawn if showDisplay: if (turnOnGrid): gridList = self.bev.getBirdsEyeViewAsList(self.keeperArray, self.takerArray) substrate = self.bev.getSubstrate(self.keeperArray, self.takerArray) self.__drawWorld (mode, gridList, substrate, prettyGrid) else: self.__drawWorld(mode) self.__displayScore() pygame.display.update()
def resetGameForTraining(self): """ This is a public function that is meant for resetting the simulator when in training mode. Training mode will be used by the intelligent agents such as SARSA, NEAT, hyperNEAT, etc. All it does is reset the ball position, the agent positions, and also sets the individual agents "inPosession", and "isKicking" flags to false, to indicate that there are no agents that have posession of the ball, nor are there any agents kicking the ball. :returns: no return """ #reset the ball variables #row = random.randint(0, int(self.__display_height/2)) #col = random.randint(int(self.__display_width/4), int (self.__display_width/4 * 3)) self.fieldBall.updateCoordinate((self.__field_center[0]/4, self.__field_center[1]/4)) self.fieldBall.updateDirection((0.0,0.0)) #reset the score self.keeperScore = 0 #now reset the agent positions: self.keeperTruePosArray[0] = (12.5, 12.5) self.keeperTruePosArray[1] = (25, self.__display_width - 37.5) self.keeperTruePosArray[2] = (self.__display_height - 37.5, self.__display_width - 37.5) self.takerTruePosArray[0] = (self.__display_height - 25, 25) self.takerTruePosArray[1] = (self.__display_height - 37.5, 50) for i in range(len(self.keeperArray)): self.keeperArray[i].updateAgentPosition(kUtil.getNoisyVals(self.keeperTruePosArray[i], self.agentSigmaError)) self.keeperArray[i].noisyBallPos = kUtil.getNoisyVals(self.fieldBall.trueBallPos,self.keeperArray[i].getSigma()) self.keeperArray[i].inPosession = False self.keeperArray[i].isKicking = False for i in range(len(self.takerArray)): self.takerArray[i].updateAgentPosition(kUtil.getNoisyVals(self.takerTruePosArray[i], self.agentSigmaError)) self.takerArray[i].noisyBallPos = kUtil.getNoisyVals(self.fieldBall.trueBallPos, self.takerArray[i].getSigma()) self.takerArray[i].inPosession = False self.takerArray[i].isKicking = False
def gameLoop(self, mode):
"""
This is the main game loop. Each iteration of this counts as a tick.
With each tick, an agent can move keepAway.maxPlayerSpeed units, and the
ball can move keepAway.maxBallSpeed units. At the end of each tick, the
pygame screen is updated to the next frame.
:returns: no return
"""
self.__drawWorld()
gameExit = False
pygame.display.update()
experimentAgent = self.keeperArray[0]
# each occurance of this loop is treated as one simulation cycle
while not gameExit:
if mode == "manual":
for event in pygame.event.get():
if event.type == pygame.QUIT:
gameExit = True
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
self.moveAttempt(experimentAgent, ((0, -1), self.maxPlayerSpeed))
elif event.key == pygame.K_RIGHT:
self.moveAttempt(experimentAgent, ((0, 1), self.maxPlayerSpeed))
elif event.key == pygame.K_UP:
self.moveAttempt(experimentAgent, ((-1, 0), self.maxPlayerSpeed))
elif event.key == pygame.K_DOWN:
self.moveAttempt(experimentAgent, ((1, 0), self.maxPlayerSpeed))
elif event.key == pygame.K_1:
self.moveAttempt(experimentAgent, ((-1, -1), self.maxPlayerSpeed))
elif event.key == pygame.K_2:
self.moveAttempt(experimentAgent, ((-1, 1), self.maxPlayerSpeed))
elif event.key == pygame.K_3:
self.moveAttempt(experimentAgent, ((1, -1), self.maxPlayerSpeed))
elif event.key == pygame.K_4:
self.moveAttempt(experimentAgent, ((1, 1), self.maxPlayerSpeed))
elif mode == "hand_coded":
for event in pygame.event.get():
if event.type == pygame.QUIT:
gameExit = True
self.sendCalcReceiveDecision()
self.sendSimpleStateVars()
for keeper in self.keeperArray:
keeper.decisionFlowChart()
for taker in self.takerArray:
taker.decisionFlowChart()
elif mode == "sarsa":
for event in pygame.event.get():
if event.type == pygame.QUIT:
gameExit = True
self.sendCalcReceiveDecision()
self.sendSimpleStateVars()
# this is common code that will occur regardless of what agent you picked
# if (self.fieldBall.inPosession == False):
newBallPoint = kUtil.addVectorToPoint(
self.fieldBall.trueBallPos,
kUtil.scalarMultiply(self.maxBallSpeed, kUtil.unitVector(self.fieldBall.trueBallDirection)),
)
self.fieldBall.updateCoordinate(newBallPoint)
for i in range(len(self.takerArray)):
self.takerArray[i].noisyBallPos = kUtil.getNoisyVals(
self.fieldBall.trueBallPos, self.takerArray[i].getSigma()
)
for i in range(len(self.keeperArray)):
self.keeperArray[i].noisyBallPos = kUtil.getNoisyVals(
self.fieldBall.trueBallPos, self.keeperArray[i].getSigma()
)
self.__updateBallPosession()
self.__updateScore()
self.__drawWorld()
self.__displayScore()
pygame.display.update()
if self.isGameOver() == True:
gameExit = True
print("final score: ", self.keeperScore)
# this specifies frames per second
self.clock.tick(self.test_fps)
self.__finish()
# self.pause("Game Over: Final Score %d" % self.keeperScore)
self.__exitSim()
def __init__(self, inputAgentSigmaNoise = .1, alreadyTrained = True, bevCustomTileSize = None):
pygame.init()
#RGB color
self.__white = (255,255,255)
self.__black = (0,0,0)
self.__red = (255,0,0)
self.__green = (0,155,0)
self.__blue = (0,0,255)
#give the game a title
pygame.display.set_caption('Keepaway')
self.keeperScore = 0
#these are more or less global variables..
#I'm not sure if this is bad or not.
self.__worldImage = pygame.image.load('images/soccer_field.png')
self.__ballImage = pygame.image.load('images/ball.png')
self.__keeperImage = pygame.image.load('images/keeper.png')
self.__keeperGoldImage = pygame.image.load('images/keeperGold.png')
self.__takerImage = pygame.image.load('images/taker.png')
self.__predictedImage = pygame.image.load('images/x.png')
self.__debugYellowDotImage = pygame.image.load('images/yellow_dot.png')
self.__debugRedDotImage = pygame.image.load('images/red_dot.png')
self.__debugBlackDotImage = pygame.image.load('images/black_dot.png')
self.__debugWhiteDotImage = pygame.image.load('images/white_dot.png')
self.__debugBlueDotImage = pygame.image.load('images/blue_dot.png')
self.__debugTakerPathTile = pygame.image.load('images/takerPathSquare.png')
self.__debugKeeperPathTile = pygame.image.load('images/keeperPathSquare.png')
self.__debugKeeperTile = pygame.image.load('images/keeperSquare.png')
self.__debugTakerTile = pygame.image.load('images/takerSquare.png')
self.__debugEmptyTile = pygame.image.load('images/emptySquare.png')
self.__debugTakerPathTileTwo = pygame.image.load('images/takerPathSquare2.png')
self.__debugKeeperPathTileTwo = pygame.image.load('images/keeperPathSquare2.png')
#block sizes are used for collision detection
#only 1 size per element because all blocks are squares. block size = side length
self.__agent_block_size = 23
self.__ball_block_size = 12
self.maxBallSpeed= 4
self.maxPlayerSpeed = 2
#self.rDecision = None
#dimensions of the game are the same as the soccer field image
self.__display_width = 550
self.__display_height = 357
self.displayGraphics = True
self.__field_center = (self.__display_width / 2 , self.__display_height / 2)
#gameDisplay is a pygame.surface object. it's your screen
self.gameDisplay = pygame.display.set_mode((self.__display_width,self.__display_height))
self.test_fps = 60
self.train_fps = 10000
self.clock = pygame.time.Clock()
#start the ball kinda close to the keeper in the upper left corner
self.fieldBall = ball.ball( (self.__field_center[0]/4, self.__field_center[1]/4), self.maxBallSpeed)
#the simple state variables for agents like NEAT, novelty search, and maybe sarsa
self.simpleStateVars = None
self.alreadyTrained = alreadyTrained #False if you want agent to learn and True if you want to demo
#setup all the initial keepers and takers. They are all starting at different field positions, which is why
#you can't have a for loop just iterate and declare all of them
types = ["keeper", "taker"]
self.agentSigmaError = inputAgentSigmaNoise
self.keeperArray = []
self.keeperTruePosArray = []
self.keeperTruePosArray.append((12.5, 12.5))
self.keeperTruePosArray.append((25, self.__display_width - 37.5))
self.keeperTruePosArray.append((self.__display_height - 37.5, self.__display_width - 37.5))
self.keeperArray.append(agent.agent(self, 0, kUtil.getNoisyVals( self.keeperTruePosArray[0], self.agentSigmaError), self.agentSigmaError, types[0], kUtil.getNoisyVals(self.fieldBall.trueBallPos, self.agentSigmaError), self.maxPlayerSpeed, self.maxBallSpeed))
self.keeperArray.append(agent.agent(self, 1, kUtil.getNoisyVals( self.keeperTruePosArray[1], self.agentSigmaError), self.agentSigmaError, types[0], kUtil.getNoisyVals(self.fieldBall.trueBallPos, self.agentSigmaError), self.maxPlayerSpeed, self.maxBallSpeed))
self.keeperArray.append(agent.agent(self, 2, kUtil.getNoisyVals( self.keeperTruePosArray[2], self.agentSigmaError), self.agentSigmaError, types[0], kUtil.getNoisyVals(self.fieldBall.trueBallPos, self.agentSigmaError), self.maxPlayerSpeed, self.maxBallSpeed))
self.takerArray = []
self.takerTruePosArray = []
self.takerTruePosArray.append((self.__display_height - 25, 25))
self.takerTruePosArray.append((self.__display_height - 37.5, 50))
self.takerArray.append(agent.agent(self, 0, self.takerTruePosArray[0], self.agentSigmaError, types[1], kUtil.getNoisyVals(self.fieldBall.trueBallPos, self.agentSigmaError), self.maxPlayerSpeed, self.maxBallSpeed))
self.takerArray.append(agent.agent(self, 1, self.takerTruePosArray[1], self.agentSigmaError, types[1], kUtil.getNoisyVals(self.fieldBall.trueBallPos, self.agentSigmaError), self.maxPlayerSpeed, self.maxBallSpeed))
#3 different font sizes
self.smallfont = pygame.font.SysFont("comicsansms",25) #25 is font sizes
self.medfont = pygame.font.SysFont("comicsansms",50)
self.largefont = pygame.font.SysFont("comicsansms",80)
self.verysmallfont = pygame.font.SysFont("comicsansms", 12)
#birdsEyeView generator for agents like hyperNEAT:
if bevCustomTileSize == None:
bevCustomTileSize = self.__agent_block_size
self.bev = birdsEyeView.birdsEyeView(self.__display_width, self.__display_height, bevCustomTileSize, self.__ball_block_size )
self.bev_grid_as_grid = self.bev.getBirdsEyeView(self.keeperArray, self.takerArray);
self.bev_grid_as_list = self.bev.getBirdsEyeViewAsList(self.keeperArray, self.takerArray);
self.bev_substrate = self.bev.getSubstrate(self.keeperArray, self.takerArray);
self.bev_keeper_sub_index = self.bev.getBallHolderTile(self.keeperArray)
def gameLoop(self, mode):
self.drawWorld ()
gameExit = False
if(self.displayGraphics == True):
pygame.display.update()
experimentAgent = self.takerArray[0]
#each occurance of this loop is treated as one simulation cycle
while not gameExit:
if(mode == "manual"):
for event in pygame.event.get():
if event.type == pygame.QUIT:
gameExit = True
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
self.moveAttempt(experimentAgent, ((0,-1), self.maxPlayerSpeed))
elif event.key == pygame.K_RIGHT:
self.moveAttempt(experimentAgent, ((0,1), self.maxPlayerSpeed))
elif event.key == pygame.K_UP:
self.moveAttempt(experimentAgent, ((-1,0), self.maxPlayerSpeed))
elif event.key == pygame.K_DOWN:
self.moveAttempt(experimentAgent, ((1,0), self.maxPlayerSpeed))
elif event.key == pygame.K_1:
self.moveAttempt(experimentAgent, ((-1,-1), self.maxPlayerSpeed))
elif event.key == pygame.K_2:
self.moveAttempt(experimentAgent, ((-1,1), self.maxPlayerSpeed))
elif event.key == pygame.K_3:
self.moveAttempt(experimentAgent, ((1,-1), self.maxPlayerSpeed))
elif event.key == pygame.K_4:
self.moveAttempt(experimentAgent, ((1,1), self.maxPlayerSpeed))
elif (mode == "hand_coded"):
for event in pygame.event.get():
if event.type == pygame.QUIT:
gameExit = True
self.sendStateVars()
self.calc_receive()
for keeper in self.keeperArray:
keeper.decisionFlowChart()
for taker in self.takerArray:
taker.decisionFlowChart()
elif(mode == "q_learning"):
totalTraining = 5
flag = False
for index in range(len(self.keeperArray)):
if self.keeperArray[index].load_obj("dict",index, mode) == None:
flag = True
if flag:
print("no files exist")
self.QTraining(totalTraining)
for index in range(len(self.keeperArray)):
self.keeperArray[index].save_obj(self.keeperArray[index].q_values,"dict",index, mode)
#for key in list(self.keeperArray[index].q_values.keys())[:10]:
#print("QValues of ",index," agent is: key=",key," value=",self.keeperArray[index].q_values[key])
self.Qtesting()
else:
print("files exist, continue training")
totalTraining = 0
for index in range(len(self.keeperArray)):
self.keeperArray[index].q_values = self.keeperArray[index].load_obj("dict",index, mode)
#for key in list(self.keeperArray[index].q_values.keys())[:10]:
#print("QValues of ",index," agent is: key=",key," value=",self.keeperArray[index].q_values[key])
self.QTraining(totalTraining)
for index in range(len(self.keeperArray)):
self.keeperArray[index].save_obj(self.keeperArray[index].q_values,"dict",index, mode)
self.Qtesting()
elif(mode == "sarsa"):
totalTraining = 5
flag = False
for index in range(len(self.keeperArray)):
if self.keeperArray[index].load_obj("dict",index, mode) == None:
flag = True
if flag:
print("no files exist")
self.QTraining(totalTraining)
for index in range(len(self.keeperArray)):
self.keeperArray[index].save_obj(self.keeperArray[index].q_values,"dict",index, mode)
#for key in list(self.keeperArray[index].q_values.keys())[:10]:
#print("QValues of ",index," agent is: key=",key," value=",self.keeperArray[index].q_values[key])
self.Qtesting()
else:
print("files exist, continue training")
totalTraining = 0
for index in range(len(self.keeperArray)):
self.keeperArray[index].q_values = self.keeperArray[index].load_obj("dict",index, mode)
#for key in list(self.keeperArray[index].q_values.keys())[:10]:
#print("QValues of ",index," agent is: key=",key," value=",self.keeperArray[index].q_values[key])
self.QTraining(totalTraining)
for index in range(len(self.keeperArray)):
self.keeperArray[index].save_obj(self.keeperArray[index].q_values,"dict",index, mode)
self.Qtesting()
#this is common code that will occur regardless of what agent you picked
#if (self.fieldBall.inPosession == False):
newBallPoint = kUtil.addVectorToPoint(self.fieldBall.trueBallPos, kUtil.scalarMultiply(self.maxBallSpeed, kUtil.unitVector(self.fieldBall.trueBallDirection)))
self.fieldBall.updateCoordinate(newBallPoint)
for i in range(len(self.takerArray)):
self.takerArray[i].noisyBallPos = kUtil.getNoisyVals(self.fieldBall.trueBallPos, self.takerArray[i].sigma)
for i in range(len(self.keeperArray)):
self.keeperArray[i].noisyBallPos = kUtil.getNoisyVals(self.fieldBall.trueBallPos, self.keeperArray[i].sigma)
self.updateBallPosession()
self.updateScore()
self.drawWorld ()
self.displayScore()
pygame.display.update()
if self.isGameOver() == True:
gameExit = True
print("final score: ", self.keeperScore)
#this specifies frames per second
self.clock.tick(self.fps)
self.finish()
#self.pause("Game Over: Final Score %d" % self.keeperScore)
self.exitSim()
def updateAgentPosition(self, truePosition):
self.true_pos = truePosition
self.noisy_pos = kUtil.getNoisyVals(truePosition, self.sigma)
def __init__(self, inputAgentSigmaNoise=0.1):
pygame.init()
# RGB color
self.__white = (255, 255, 255)
self.__black = (0, 0, 0)
self.__red = (255, 0, 0)
self.__green = (0, 155, 0)
self.__blue = (0, 0, 255)
# give the game a title
pygame.display.set_caption("Keepaway")
self.keeperScore = 0
# these are more or less global variables..
# I'm not sure if this is bad or not.
self.__worldImage = pygame.image.load("images/soccer_field.png")
self.__ballImage = pygame.image.load("images/ball.png")
self.__keeperImage = pygame.image.load("images/keeper.png")
self.__takerImage = pygame.image.load("images/taker.png")
self.__predictedImage = pygame.image.load("images/x.png")
self.__debugYellowDotImage = pygame.image.load("images/yellow_dot.png")
self.__debugRedDotImage = pygame.image.load("images/red_dot.png")
# block sizes are used for collision detection
# only 1 size per element because all blocks are squares. block size = side length
self.__agent_block_size = 23
self.ball_block_size = 12
self.maxBallSpeed = 4
self.maxPlayerSpeed = 2
# dimensions of the game are the same as the soccer field image
self.__display_width = 550
self.display_height = 357
self.__field_center = (self.__display_width / 2, self.display_height / 2)
# gameDisplay is a pygame.surface object. it's your screen
self.gameDisplay = pygame.display.set_mode((self.__display_width, self.display_height))
self.test_fps = 60
self.train_fps = 10000
self.clock = pygame.time.Clock()
# start the ball kinda close to the keeper in the upper left corner
self.fieldBall = ball.ball((self.__field_center[0] / 4, self.__field_center[1] / 4), self.maxBallSpeed)
# setup all the initial keepers and takers. They are all starting at different field positions, which is why
# you can't have a for loop just iterate and declare all of them
types = ["keeper", "taker"]
self.agentSigmaError = inputAgentSigmaNoise
self.keeperArray = []
self.keeperTruePosArray = []
self.keeperTruePosArray.append((12.5, 12.5))
self.keeperTruePosArray.append((25, self.__display_width - 37.5))
self.keeperTruePosArray.append((self.display_height - 37.5, self.__display_width - 37.5))
self.keeperArray.append(
agent.agent(
self,
0,
kUtil.getNoisyVals(self.keeperTruePosArray[0], self.agentSigmaError),
self.agentSigmaError,
types[0],
kUtil.getNoisyVals(self.fieldBall.trueBallPos, self.agentSigmaError),
self.maxPlayerSpeed,
self.maxBallSpeed,
)
)
self.keeperArray.append(
agent.agent(
self,
1,
kUtil.getNoisyVals(self.keeperTruePosArray[1], self.agentSigmaError),
self.agentSigmaError,
types[0],
kUtil.getNoisyVals(self.fieldBall.trueBallPos, self.agentSigmaError),
self.maxPlayerSpeed,
self.maxBallSpeed,
)
)
self.keeperArray.append(
agent.agent(
self,
2,
kUtil.getNoisyVals(self.keeperTruePosArray[2], self.agentSigmaError),
self.agentSigmaError,
types[0],
kUtil.getNoisyVals(self.fieldBall.trueBallPos, self.agentSigmaError),
self.maxPlayerSpeed,
self.maxBallSpeed,
)
)
self.takerArray = []
self.takerTruePosArray = []
self.takerTruePosArray.append((self.display_height - 25, 25))
self.takerTruePosArray.append((self.display_height - 37.5, 50))
self.takerArray.append(
agent.agent(
self,
0,
self.takerTruePosArray[0],
self.agentSigmaError,
types[1],
kUtil.getNoisyVals(self.fieldBall.trueBallPos, self.agentSigmaError),
self.maxPlayerSpeed,
self.maxBallSpeed,
)
)
self.takerArray.append(
agent.agent(
self,
1,
self.takerTruePosArray[1],
self.agentSigmaError,
types[1],
kUtil.getNoisyVals(self.fieldBall.trueBallPos, self.agentSigmaError),
self.maxPlayerSpeed,
self.maxBallSpeed,
)
)
# 3 different font sizes
self.smallfont = pygame.font.SysFont("comicsansms", 25) # 25 is font sizes
self.medfont = pygame.font.SysFont("comicsansms", 50)
self.largefont = pygame.font.SysFont("comicsansms", 80)
self.verysmallfont = pygame.font.SysFont("comicsansms", 12)
def _passBall(self, integerK):
"""
If a keeper currently has the ball, then it has the option to hold the ball,
or pass it. Call this function to pass the ball. integerK represents the
keeper that the ball holder is passing to. integerK = 1 means pass to the
keeper that is closest to the ball besides the ball holder. integerK = 2
means pass to the 2nd closest, and so on. Only subclasses of agent should
be calling this function.
:param integerK: this represents the
keeper that the ball holder is passing to. integerK = 1 means pass to the
keeper that is closest to the ball besides the ball holder. integerK = 2
means pass to the 2nd closest, and so on.
:type integerK: integer
:returns: no return
"""
#print("passing to keeper " + str(integerK) + ", indexed by distance. ")
#if you're passing to integerK = 1, then that means pass to the keeper that's closer to you
#if you're passing ot integerK = 2, then that means pass to the keeper that's farther to you
#0 is an invalid input
sortedKeepers = sorted(self.keeperArray)
if integerK == 0:
print("Invalid input for integerK! integerK not allowed to be", integerK)
return
if self.fieldBall == None:
print("ERROR: trying to hold ball without actually having ball")
return
#pass to team mate integerK. if integerK = 1, then it's the 2nd element in array
selfToTeammateDirection = kUtil.unitVector(kUtil.getVector(self.noisyBallPos, sortedKeepers[integerK].get_noisy_pos()))
selfToTeammateVector = (kUtil.scalarMultiply(self.fieldBall.maxBallSpeed, selfToTeammateDirection))
"""
#this code segment is for determining which angle you'd rather pass to. it's all deterministic
ballPos = self.noisyBallPos
passVectorsToConsider = []
passVectorsToConsider.append(selfToTeammateDirection)
for i in range(len(self.cosinesOfInterest)):
passVectorsToConsider = passVectorsToConsider + self.__getRotatedVectors(selfToTeammateDirection, self.cosinesOfInterest[i])
#now sort the vectors based on how open they are:
self.worldRef.debugPassVectors(ballPos, passVectorsToConsider)
passVectorsToConsider = sorted(passVectorsToConsider,
key = lambda vector: max ( kUtil.cosTheta(self.worldRef.takerArray[0].getNoisyMidPoint(), ballPos, kUtil.addVectorToPoint(ballPos, vector)),
kUtil.cosTheta(self.worldRef.takerArray[1].getNoisyMidPoint(), ballPos, kUtil.addVectorToPoint(ballPos, vector))),
)
#iterate over the sorted list until you find a pass that you can do
for i in range(len(passVectorsToConsider)):
if( calcReceive.calc_receive(self.worldRef, passVectorsToConsider[i]) != None):
selfToTeammateDirection = passVectorsToConsider[i]
selfToTeammateVector = (kUtil.scalarMultiply(self.fieldBall.maxBallSpeed, selfToTeammateDirection))
print "PASS USING ANGLE ACHEIVED AT i=", i
break
"""
#at this point, you've determined the angle you wanna pass, and you pass.
#set ball's possesion to false, and update to new point. ball class handles direction vector
self.fieldBall.updatePosession(False)
self.inPosession = False
self.isKicking = True
#kUtil.addVectorToPoint(self.fieldBall.trueBallPos, selfToTeammateVector)
self.fieldBall.updateDirection(kUtil.getNoisyVals(selfToTeammateVector, self.__sigma))
def receiveDecision(self, rDecision):
self.onReceiveDecision = rDecision
self.onReceiveDecision[1] = kUtil.getNoisyVals(self.onReceiveDecision[1], self.sigma)