コード例 #1
0
ファイル: base.py プロジェクト: cameronwest/rgkit
    def simulate(self, robots, locs1, next_locs1, locs2, next_locs2):
        players = [game.Player(robots={'Robot': robot()}) for robot in robots]
        map['start1'], map['start2'] = locs1, locs2
        game.init_settings(map)
        self._game = game.Game(*players, unit_testing=True)
        self._game.run_turn()

        pprint.pprint(self._game._robots)

        return [[self._game.robot_at_loc(loc) for loc in locs]
                for locs in (next_locs1, next_locs2)]
コード例 #2
0
ファイル: runner.py プロジェクト: bsuh/rgfiddle
def make_game(code1, code2):
    rgkit_dir = path.dirname(rg.__file__)
    with open(path.join(rgkit_dir, 'maps/default.py')) as mapfile:
        game.init_settings(ast.literal_eval(mapfile.read()))

    g = MyGame(
        MyPlayer(code=code1),
        MyPlayer(code=code2),
        record_actions=True)

    return g
コード例 #3
0
    def simulate(self, robots, locs1, next_locs1, locs2, next_locs2, turns=1):
        players = [game.Player(robot=robot()) for robot in robots]
        map['start1'], map['start2'] = locs1, locs2
        game.init_settings(map)
        self._game = game.Game(*players, unit_testing=True, record_turns=True)

        for i in range(turns):
            self._game.run_turn()

        pprint.pprint(self._game._robots)

        return [[self._game.robot_at_loc(loc) for loc in locs]
                for locs in (next_locs1, next_locs2)]
コード例 #4
0
ファイル: run.py プロジェクト: cgearhart/rgkit
def main():

    map_data = ast.literal_eval(args.map.read())
    game.init_settings(map_data)

    players = [make_player(args.usercode1), make_player(args.usercode2)]
    g = game.Game(*players, record_turns=True)
    for i in range(settings.max_turns):
        print (' running turn %d ' % (g.turns + 1)).center(70, '-')
        g.run_turn()
    if not args.headless:
        render.Render(g, game.settings)
    print g.history
コード例 #5
0
ファイル: base.py プロジェクト: bsuh/rgkit
    def simulate(self, robots, locs1, next_locs1, locs2, next_locs2, turns=1):
        players = [game.Player(robot=robot()) for robot in robots]
        map['start1'], map['start2'] = locs1, locs2
        game.init_settings(map)
        self._game = game.Game(*players, unit_testing=True, record_turns=True)

        for i in range(turns):
            self._game.run_turn()

        pprint.pprint(self._game._robots)

        return [[self._game.robot_at_loc(loc) for loc in locs]
                for locs in (next_locs1, next_locs2)]
コード例 #6
0
ファイル: run.py プロジェクト: mueslo/rgkit
def main():
    args = parser.parse_args()
    if args.quiet >= 3:
        mute_all()

    game.init_settings(args.map)
    print('Game seed: {0}'.format(args.game_seed))

    runner = test_runs_sequentially
    if _is_multiprocessing_supported and args.count > 1:
        runner = test_runs_concurrently
    scores = runner(args)

    if args.count > 1:
        p1won = sum(p1 > p2 for p1, p2 in scores)
        p2won = sum(p2 > p1 for p1, p2 in scores)
        print [p1won, p2won, args.count - p1won - p2won]
コード例 #7
0
ファイル: rgcompare.py プロジェクト: mpeterv/rgcompare
def comparison_worker(identity, input, output):
    logfile = open(__file__+"."+str(identity)+".log", 'w') if log else open(os.devnull, 'w')
    print "Starting worker {0} (logging to {1})".format(identity,logfile.name)
    try:
        with RedirectStdStreams(stdout=logfile, stderr=logfile):
            for match_id,player_fnames, map_fname, turns in iter(input.get, 'STOP'):

                map_data = ast.literal_eval(open(map_fname).read())
                game.init_settings(map_data)
                players = [game.Player(open(x).read()) for x in player_fnames]
                g = game.Game(*players)

                t_start = time.clock()
                for i in range(turns):
                    print (' running turn %d '%(g.state.turn)).center(70, '-')
                    g.run_turn()
                t_end = time.clock()

                output.put([g.get_scores(),t_end-t_start])
    finally:
        print "Terminating worker {0}...".format(identity)
コード例 #8
0
ファイル: rg_test.py プロジェクト: mic159/rgkit
import ast
import pkg_resources
import unittest
from rgkit import game, rg

map_data = ast.literal_eval(
    open(pkg_resources.resource_filename('rgkit', 'maps/default.py')).read())
settings = game.init_settings(map_data)


class TestRG(unittest.TestCase):
    def test_center(self):
        self.assertEqual(rg.CENTER_POINT, (9, 9))

    def test_types_invalid(self):
        self.assertEqual(rg.loc_types((-1, 9)), set(['invalid']))

    def test_types_spawn(self):
        self.assertEqual(rg.loc_types((3, 4)), set(['normal', 'spawn']))

    def test_types_obstacle(self):
        self.assertEqual(rg.loc_types((16, 4)), set(['normal', 'obstacle']))

    def test_types_normal(self):
        self.assertEqual(rg.loc_types((7, 2)), set(['normal']))

    def test_around(self):
        filtered = set(rg.locs_around((3, 3)))
        self.assertEqual(filtered, set([(3, 2), (4, 3), (3, 4), (2, 3)]))

    def test_around_filter(self):