示例#1
0
def test():
    argvList = "-q q3".split(" ")
    options = readCommand(argvList)
    if options.generateSolutions:
        confirmGenerate()
    codePaths = options.studentCode.split(',')

    moduleDict = {}
    for cp in codePaths:
        moduleName = re.match('.*?([^/]*)\.py', cp).group(1)
        moduleDict[moduleName] = loadModuleFile(
            moduleName, os.path.join(options.codeRoot, cp))
    moduleName = re.match('.*?([^/]*)\.py', options.testCaseCode).group(1)
    moduleDict['projectTestClasses'] = loadModuleFile(
        moduleName, os.path.join(options.codeRoot, options.testCaseCode))

    if options.runTest != None:
        runTest(options.runTest,
                moduleDict,
                printTestCase=options.printTestCase,
                display=getDisplay(True, options))
    else:
        evaluate(options.generateSolutions,
                 options.testRoot,
                 moduleDict,
                 gsOutput=options.gsOutput,
                 edxOutput=options.edxOutput,
                 muteOutput=options.muteOutput,
                 printTestCase=options.printTestCase,
                 questionToGrade=options.gradeQuestion,
                 display=getDisplay(options.gradeQuestion != None, options))
 def test(self):
     args = pacman.readCommand([
         '-p', 'RectangularRoomCleaner', '-l', layout, '-q',
         '--frameTime', '0', '--timeout', '1'
     ])
     games = pacman.runGames(**args)
     self.assertTrue(games[0].state.isWin())
示例#3
0
def main(pacman_agent):
    total_scores = 0.
    total_weight = 0.
    for n_case, case in enumerate(evaluation_cases):
        print('running game {} / {}, {}'.format(n_case + 1,
                                                len(evaluation_cases),
                                                case[0]))
        layout, score_weight = case

        # Run the pacman game and get its score
        pacman_cmd = 'python pacman.py --pacman {} -l {} -q'
        pacman_cmd_args = pacman_cmd.format(pacman_agent, layout)
        # skip 'python pacman.py' in the command line arguments above
        args = pacman.readCommand(pacman_cmd_args.split()[2:])
        games = pacman.runGames(**args)
        # Take the average of the game scores. Note that there should be only
        # one game in games, unless `-n` is used in pacman.py
        scores = [game.state.getScore() for game in games]
        game_score = sum(scores) / len(scores)

        total_scores += game_score * score_weight
        total_weight += score_weight

    final_score = total_scores / total_weight
    print("Final score: ", final_score)
    def execute(self, grades, moduleDict, solutionDict):
        starttime = time.time()
        try:
            timed_func = TimeoutFunction(pacman.runGames, self.maxTime)
            try:
                command = '-l %s -p %s -q' % (self.layoutName, self.agentName)
                games = timed_func(** pacman.readCommand(command.split()))
                extra_time = (time.time() - starttime)
                #if games[0].state.isWin():
                moves = games[0].moveHistory
                passed = 0
                for t in self.thresholds:
                    if len(moves) <= t: passed += 1

                if passed >= len(self.thresholds):
                    grades.addMessage('PASS: %s' % self.path)
                else:
                    grades.addMessage('FAIL: %s' % self.path)
                grades.addMessage('\tExtra credit run-time: %1.2f' % extra_time)
                grades.addMessage('\tExtra credit total moves %d' % len(moves))
                grades.addMessage('\tThresholds: %s' % self.testDict['thresholds'])
                grades.addMessage('\tPassed %s thresholds: %s points.' % (passed, passed))
                grades.addPoints(passed)
                return True
            except TimeoutFunctionException:
                grades.addMessage('FAIL: %s' % self.path)
                grades.addMessage('\tExtra credit code is too slow')
                return False
        except Exception, inst:
            grades.addMessage('FAIL: %s' % self.path)
            grades.addMessage('\tExtra credit threw an exception: %s.\n%s' % (str(inst), traceback.format_exc()))
示例#5
0
    def execute(self, grades, moduleDict, solutionDict):
        self.addMessage('Grading agent using command:  python pacman.py %s'% (self.pacmanParams,))
        pacman.TEST_MODULE = moduleDict

        startTime = time.time()
        games = pacman.runGames(** pacman.readCommand(self.pacmanParams.split(' ')))
        totalTime = time.time() - startTime
        numGames = len(games)

        stats = {'time': totalTime, 'wins': [g.state.isWin() for g in games].count(True),
                 'games': games, 'scores': [g.state.getScore() for g in games],
                 'timeouts': [g.agentTimeout for g in games].count(True), 'crashes': [g.agentCrashed for g in games].count(True)}

        averageScore = sum(stats['scores']) / float(len(stats['scores']))
        nonTimeouts = numGames - stats['timeouts']
        wins = stats['wins']

        def gradeThreshold(value, minimum, thresholds, name):
            points = 0
            passed = (minimum == None) or (value >= minimum)
            if passed:
                for t in thresholds:
                    if value >= t:
                        points += 1
            return (passed, points, value, minimum, thresholds, name)

        results = [gradeThreshold(averageScore, self.scoreMinimum, self.scoreThresholds, "average score"),
                   gradeThreshold(nonTimeouts, self.nonTimeoutMinimum, self.nonTimeoutThresholds, "games not timed out"),
                   gradeThreshold(wins, self.winsMinimum, self.winsThresholds, "wins")]

        totalPoints = 0
        for passed, points, value, minimum, thresholds, name in results:
            if minimum == None and len(thresholds)==0:
                continue

            # print passed, points, value, minimum, thresholds, name
            totalPoints += points
            if not passed:
                assert points == 0
                self.addMessage("%s %s (fail: below minimum value %s)" % (value, name, minimum))
            else:
                self.addMessage("%s %s (%s of %s points)" % (value, name, points, len(thresholds)))

            if minimum != None:
                self.addMessage("    Grading scheme:")
                self.addMessage("     < %s:  fail" % (minimum,))
                if len(thresholds)==0 or minimum != thresholds[0]:
                    self.addMessage("    >= %s:  0 points" % (minimum,))
                for idx, threshold in enumerate(thresholds):
                    self.addMessage("    >= %s:  %s points" % (threshold, idx+1))
            elif len(thresholds) > 0:
                self.addMessage("    Grading scheme:")
                self.addMessage("     < %s:  0 points" % (thresholds[0],))
                for idx, threshold in enumerate(thresholds):
                    self.addMessage("    >= %s:  %s points" % (threshold, idx+1))

        if any([not passed for passed, _, _, _, _, _ in results]):
            totalPoints = 0

        return self.testPartial(grades, totalPoints, self.maxPoints)
示例#6
0
    def __init__( self, index = 0 ):
        #start ros node
        rospy.init_node('pacman_game', anonymous=True)
        self.r = rospy.Rate(10) # 10hz

        # game attributes
        # game_attributes = ["-p", "RosWaitServiceAgent", "-l", "smallClassic", "-k", "4"]
        # game_attributes = ["-p", "RosServiceWithErrorsAgent", "-l", "smallClassic", "-k", "4"]
        game_attributes = ["-p", "RosServiceWithErrorsAgent", "-l", "originalClassic", "-k", "4"]
        #a=["-p", "RosWaitServiceAgent", "-l", "originalClassic", "-k", "4"]
        #a=["-p", "RosWaitServiceAgent", "-l", "mediumGrid", "-k", "4"]
        self.args = pacman.readCommand(game_attributes)

        self.args['send_pose_as_service'] = True
        self.args['send_pose_with_error'] = True
        self.args['ghost_distance_error'] = 0.01
        self.args['pacman_pose_error'] = 0.01

        # service and variables to start new game and end it
        self.start_game_srv = rospy.Service('/pacman/start_game', StartGame, self.start_game_service)
        self.end_game_client = rospy.ServiceProxy('/pacman/end_game', EndGame)
        self.start_game = False
        self.show_gui = False

        self.game_counter = 0
示例#7
0
def main(pacman_agent):
    total_scores = 0.
    total_weight = 0.
    for n_case, case in enumerate(evaluation_cases):
        print('running game {} / {}, {}'.format(n_case + 1,
                                                len(evaluation_cases),
                                                case[0]))
        layout, score_weight = case

        # Run the pacman game and get its score
        pacman_cmd = 'python pacman.py --pacman {} -l {} -q'
        pacman_cmd_args = pacman_cmd.format(pacman_agent, layout)
        # skip 'python pacman.py' in the command line arguments above
        args = pacman.readCommand(pacman_cmd_args.split()[2:])
        games = pacman.runGames(**args)
        # Take the average of the game scores. Note that there should be only
        # one game in games, unless `-n` is used in pacman.py
        scores = [game.state.getScore() for game in games]
        game_score = sum(scores) / len(scores)

        total_scores += game_score * score_weight
        total_weight += score_weight

    final_score = total_scores / total_weight
    print("Final score: ", final_score)

    # Generate results.json
    score_fields = {}
    score_fields['score'] = final_score
    score_fields['visibility'] = 'visible'
    score_fields['leaderboard'] = [{"name": "Score", "value": final_score}]
    score_fields['output'] = 'successfully run {} games!'.format(
        len(evaluation_cases))
示例#8
0
    def execute(self, grades, moduleDict, solutionDict):
        starttime = time.time()
        try:
            timed_func = TimeoutFunction(pacman.runGames, self.maxTime)
            try:
                command = '-l %s -p %s -q' % (self.layoutName, self.agentName)
                games = timed_func(**pacman.readCommand(command.split()))
                extra_time = (time.time() - starttime)
                #if games[0].state.isWin():
                moves = games[0].moveHistory
                passed = 0
                for t in self.thresholds:
                    if len(moves) <= t: passed += 1

                if passed >= len(self.thresholds):
                    grades.addMessage('PASS: %s' % self.path)
                else:
                    grades.addMessage('FAIL: %s' % self.path)
                grades.addMessage('\tExtra credit run-time: %1.2f' %
                                  extra_time)
                grades.addMessage('\tExtra credit total moves %d' % len(moves))
                grades.addMessage('\tThresholds: %s' %
                                  self.testDict['thresholds'])
                grades.addMessage('\tPassed %s thresholds: %s points.' %
                                  (passed, passed))
                grades.addPoints(passed)
                return True
            except TimeoutFunctionException:
                grades.addMessage('FAIL: %s' % self.path)
                grades.addMessage('\tExtra credit code is too slow')
                return False
        except Exception, inst:
            grades.addMessage('FAIL: %s' % self.path)
            grades.addMessage('\tExtra credit threw an exception: %s.\n%s' %
                              (str(inst), traceback.format_exc()))
示例#9
0
def debug():
    for idx, argvStr in enumerate(argvStrList):
        start = 0
        if idx in range(0, 8):
            print "********", idx, "*********"
            argvList = argvStr.split(" ")
            args = pacman.readCommand(argvList)
            pacman.runGames(**args)
示例#10
0
    def setUp(self):
        "setUp() - Initialize a Pacman board for testing"

        # Set up game arguments
        self.args = readCommand(self.argstr)

        # Initialize the agents
        self.studentAgent = self.args['pacman']
        self.goldAgent = GoldTimidAgent()

        #layout, pacmanAgent, ghostAgents, display, quiet, catchExceptions
        self.rules = ClassicGameRules(self.args['timeout'])

        self.dist = 3
示例#11
0
def runq4():
  """
  Runs their expectimax agent a few times and checks for victory!
  """
  random.seed(SEED)
  nGames = 20
  
  print 'Running your agent %d times to compute the average score...' % nGames
  params = '-l smallClassic -p ExpectimaxAgent -a evalFn=better -q -n %d -c' % nGames
  games = pacman.runGames(**pacman.readCommand(params.split(' ')))
  timeouts = [game.agentTimeout for game in games].count(True)
  wins = [game.state.isWin() for game in games].count(True)
  averageWinScore = 0
  if wins >= nGames / 2: 
    averageWinScore = average([game.state.getScore() if game.state.isWin() else None for game in games])
  return timeouts, wins, averageWinScore
示例#12
0
def main(pacman_agent):
    n_trials = 2
    if os.path.exists('../autograder'):
        print("POSTOJIIII ")
    else:
        print("NE POSTOJI")
    final_scores = []
    for _ in range(n_trials):
        total_scores = 0.
        total_weight = 0.
        for n_case, case in enumerate(evaluation_cases):
            print('running game {} / {}, {}'.format(n_case + 1,
                                                    len(evaluation_cases),
                                                    case[0]))
            layout, score_weight = case

            # Run the pacman game and get its score
            pacman_cmd = 'python pacman.py --pacman {} -l {} -q'
            pacman_cmd_args = pacman_cmd.format(pacman_agent, layout)
            # skip 'python pacman.py' in the command line arguments above
            args = pacman.readCommand(pacman_cmd_args.split()[2:])
            games = pacman.runGames(**args)
            # Take the average of the game scores. Note that there should be only
            # one game in games, unless `-n` is used in pacman.py
            scores = [game.state.getScore() for game in games]
            game_score = sum(scores) / len(scores)

            total_scores += game_score * score_weight
            total_weight += score_weight

        final_score_i = total_scores / total_weight
        final_scores.append(final_score_i)

    final_score = sum(final_scores) / n_trials

    # Write scores for gradescope to read
    if os.path.exists('../autograder'):
        # print("USAOUSAO USAO USAO USAO USAO  ")
        # Generate results.json
        score_fields = {}
        score_fields['score'] = final_score
        score_fields['visibility'] = 'visible'
        score_fields['leaderboard'] = [{"name": "Score", "value": final_score}]
        score_fields['output'] = 'successfully run {} games!'.format(
            len(evaluation_cases))
        write_output(score_fields)
示例#13
0
def runq4():
  """
  Runs their expectimax agent a few times and checks for victory!
  """
  random.seed(SEED)
  nGames = 20

  print 'Running your agent %d times to compute the average score...' % nGames
  print 'The timeout message (if any) is obtained by running the game once, rather than %d times' % nGames
  params = '-l smallClassic -p ExpectimaxAgent -a evalFn=better -q -n %d -c --timeout=30000' % nGames
  games = pacman.runGames(**pacman.readCommand(params.split(' ')))
  timeouts = [game.agentTimeout for game in games].count(True)
  wins = [game.state.isWin() for game in games].count(True)
  averageWinScore = 0
  if wins >= nGames / 2:
    averageWinScore = average([game.state.getScore() if game.state.isWin() else None for game in games])
  print 'Average score of winning games: %d \n' % averageWinScore
  return timeouts, wins, averageWinScore
示例#14
0
    def __init__(self, layout, numGames, numGhosts, numTraining):
        argv = []
        argv.append("-pInterfaceAgent")
        argv.append("-l{}".format(layout))
        argv.append("-n{}".format(numGames))
        argv.append("-x{}".format(numTraining))
        argv.append("-k{}".format(numGhosts))

        args = readCommand(argv)

        observation_shape = (6, args['layout'].width, args['layout'].height)
        self.action_space = ActionSpace()
        self.observation_space = ObservationSpace(observation_shape)

        thread = Thread(target=runGames, kwargs=args)
        thread.start()

        self.agent = args['pacman']
        self.getAction_CV = self.agent.getAction_CV
        self.update_CV = self.agent.update_CV
示例#15
0
文件: pso.py 项目: czgcampos/CN
    def evaluate(self):
        #
        # TO DO:
        # call pac.runGames and run the game with this particle's parameters
        #
        base = ["-p", "PacmanQAgent", "-x", "2000", "-n", "2100", "-l", "smallGrid", "-q", "-a"]
        config = "epsilon=" + str(self.position_i[0]) + ",alpha=" + str(self.position_i[1]) + ",gamma=" + str(self.position_i[2])
        base.append(config)
        print(config)

        args = pac.readCommand( base ) # Get game components based on input    
        averageScore = pac.runGames( **args )
        
        #averageScore=random.uniform(1,500)

        self.score_i=averageScore      # save the averageScore this iteration had

        # check to see if the current position is an individual best
        if self.score_i>self.score_best_i or self.score_best_i==-1:
            self.pos_best_i=list(self.position_i)
            self.score_best_i=self.score_i
示例#16
0
def interactive():
    args = readCommand(
        "--layout testMaze --pacman KeyboardAgent --createPolicy".split())
    return runGames(**args)
示例#17
0
def runPacman():
    rospy.init_node('pacman_interface', anonymous=True)

    a=["-p", "RosWaitAgent", "-l", "originalClassic", "-k", "4"]
    args = pacman.readCommand(a)
    pacman.runGames(**args)
示例#18
0
def eval_genomes_single(genomes, config):
    for id, genome in genomes:
        genome.fitness = 0
        nn_model = neat.nn.FeedForwardNetwork.create(genome, config)
        pacmanType = pacman.loadAgent("NEATAgent", True)
        cmd_line_args['pacman'] = pacmanType(nn_model=nn_model)
        cmd_line_args['display'] = textDisplay.NullGraphics()
        #cmd_line_args['display'] = graphicsDisplay.PacmanGraphics()
        games = pacman.runGames(**cmd_line_args)
        for game in games:
            genome.fitness += game.state.getScore()


if __name__ == '__main__':
    cmd_line_args = pacman.readCommand(
        sys.argv[1:])  # Get game components based on input

    # Config file
    config_file = "../config-neat"

    # Load configuration.
    config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,
                         neat.DefaultSpeciesSet, neat.DefaultStagnation,
                         config_file)

    # Create the population, which is the top-level object for a NEAT run.
    p = neat.Population(config)

    # Load from checkpoint
    #if cmd_line_args["checkpoint-neat"] != -1:
    #    p = neat.Checkpointer.restore_checkpoint('neat-checkpoint-'+str(cmd_line_args["checkpoint-neat"]))
示例#19
0
文件: MCTSAgent.py 项目: EwaHb/MAI
if __name__ == '__main__':
    if PACMAN:  # PacMan
        str_args = [
            '-l', 'mediumClassic', '-g', 'DirectionalGhost', '--frameTime',
            '0', '-n', '100'
        ]
        str_args = [
            '-l', 'TinyMaze', '-g', 'DirectionalGhost', '--frameTime', '0',
            '-n', '100'
        ]
        str_args = [
            '-l', 'TestMaze', '-g', 'DirectionalGhost', '--frameTime', '0',
            '-n', '100'
        ]
        args = readCommand(str_args)
        # args['display'] = textDisplay.NullGraphics()  # Disable rendering

        args['pacman'] = MCTSagent()
        out = runGames(**args)

        scores = [o.state.getScore() for o in out]
        print(scores)

    else:  # TicTacToe
        winner = []
        n = 200
        for i in range(n):
            winner.append(
                play_game(MCTSagent(),
                          human=TICTACTOE_VS_HUMAN,
示例#20
0
    """
    This script is used for combining the local assignment
    files with the central script files, and starting the
    pacman program.
    """

    import sys, os, re, importlib

    dir_local = os.getcwd()
    dir_central = os.path.join(dir_local, '..', 'scripts')
    sys.path.append(dir_central) # append the scripts dir to the path

    os.chdir(dir_central) # import pacman files from central scripts directory

    import pacman

    os.chdir(dir_local) # import asssignment files from local directory, overriding central files

    for file in os.listdir():
        if file.endswith('.py') and file != os.path.basename(__file__):
            importlib.import_module(file[:-3])

    os.chdir(dir_central) # change back to central directory for script execution

    if len(sys.argv) == 1:
        args = re.split(r' *', input("Enter any command line arguments?"))
        sys.argv.extend([a for a in args if a != ''])
    args = pacman.readCommand(sys.argv[1:])  # Get game components based on input
    pacman.runGames(**args)
 def test_running(self):
     try:
         args = readCommand(['-l', 'testMaze', '--pacman', 'GoWestAgent'])
         runGames(**args)
     except Exception as e:
         self.fail('The test environment was not set up correctly: \n{}'.format(e.message))
示例#22
0
            return Directions.STOP
        return self.buffer.pop()

    def socketReceive(actionStr):
        print "RECEIVE"
        parts = actionStr.split()
        if parts[0] == self.agentKey:
            self.buffer.push(actionStr)

class PlayerNetworkMasterAgent(NetworkMasterAgent):
    def __init__(self):
        NetworkMasterAgent.__init__(self, KeyboardAgent(), "PLAYER")

class PlayerNetworkSlaveAgent(NetworkSlaveAgent):
    def __init__(self):
        NetworkSlaveAgent.__init__(self, "PLAYER")

if __name__ == '__main__':
    factory = WebSocketClientFactory('ws://localhost:9000')
    factory.protocol = ClientProtocol
    connectWS(factory)
    #reactor.run()
    thread = Thread(target = reactor.run, args = (False,))
    thread.start()

    args = readCommand(sys.argv[1:])
    runner = lambda: runGames(**args)
    runner()
    #thread = Thread(target = runner)
    #thread.start()
示例#23
0
        for feat, feat_value in self.getFeatures(state, action).items():
            self.weights[feat] = self.getWeight(
                feat) + self.alpha * error * feat_value

    def computeError(self, state, action, nextState, reward):
        return (reward +
                self.discount * self.getValue(nextState)) - self.getQValue(
                    state, action)

    def final(self, state):
        "Called at the end of each game."
        # call the super-class final method
        PacmanQAgent.final(self, state)

        # did we finish training?
        if self.episodesSoFar == self.numTraining:
            # you might want to print your weights here for debugging
            "*** YOUR CODE HERE ***"
            pass


if __name__ == '__main__':
    # for debug and to use the Profiler of PyCharm
    import pacman, os
    cmd = "pacman.py -p ApproximateQAgent -a extractor=SimpleExtractor -x 25 -n 30 -l trickyClassic"
    # cmd = "pacman.py -p PacmanQAgent -x 200 -n 200 -l smallGrid"
    # os.system("pacman.py -p PacmanQAgent -x 200 -n 200 -l smallGrid")
    argv = cmd.split(' ')[1:]
    args = pacman.readCommand(argv)
    pacman.runGames(**args)
from pacman import runGames, readCommand
from time import time
layout_list = [
    "originalClassic", "testClassic", "trappedClassic", "trickyClassic",
    "smallClassic", "minimaxClassic", "openClassic", "mediumClassic",
    "contestClassic", "capsuleClassic"
]

ghost_agents = ["DirectionalGhost", "RandomGhost"]

for curr_layout in layout_list:
    print("Current layout: ", curr_layout)
    games_counter = 10
    args = readCommand([
        "-n",
        str(games_counter), "-k", "2", "-l", curr_layout, "-p",
        "CompetitionAgent", "-q", "-g", ghost_agents[1]
    ])  # Get game components based on input
    start = time()
    avg = runGames(**args)
    end = time()
    print("Current layout AVG completion time: ",
          float(end - start) / float(games_counter))
    print("\n")
示例#25
0
文件: teste.py 项目: czgcampos/CN
import pacman as pac
import sys

if __name__ == '__main__':
    """
    Used to start a game, with pacman module
    """
    base = [
        "-p", "PacmanQAgent", "-x", "2000", "-n", "2010", "-l", "smallGrid",
        "-a"
    ]
    base.append("epsilon=0.1,alpha=0.3,gamma=0.7")

    args = pac.readCommand(base)  # Get game components based on input
    averageScore = pac.runGames(**args)

    print(averageScore)

    pass

#--- EXAMPLE ------------------------------------------------------------------+
# python pso.py -p PacmanQAgent -x 2000 -n 2010 -l smallGrid -a epsilon=0.1,alpha=0.3,gamma=0.7