Esempio n. 1
0
class Game:
    INITIAL_BALANCE = 300

    def __init__(self, players, properties):
        self.players = players
        self.board = Board(self.players, properties)

    @property
    def leader(self):
        return sorted(self.players, key=lambda p: p.balance, reverse=True)[0]

    @staticmethod
    def dice():
        return random.randint(1, 6)

    def run(self, counter=0):
        turn_count = counter
        for p in cycle(self.players):
            if p not in self.board.players:
                continue

            self.board.turn(p, self.dice())
            turn_count += 1

            if len(self.board.players) == 1:
                break

            if turn_count >= 1000:
                break

        return self.leader
def calculate(chromosome, opponent):
    score = 0
    for _ in range(1000):
        b = Board([GaHousePlayer(chromosome), GaHousePlayer(opponent)])
        if b.start_game(250):
            if b.players[1].is_bankrupt:
                score += 1

    return score, chromosome
def calculate(chromosome, opponent):
    score = 0
    for _ in range(1000):
        b = Board([GaHousePlayer(chromosome), GaHousePlayer(opponent)])
        if b.start_game(250):
            if b.players[1].is_bankrupt:
                score += 1

    return score, chromosome
def calculate(chromosome, opponents):
    results = []

    for opponent in opponents:
        if chromosome != opponent:
            scores = [0, 0]
            while True:
                b = Board([GaHousePlayer(chromosome), GaHousePlayer(opponent)])
                if b.start_game(250):
                    if b.players[0].is_bankrupt:
                        scores[1] += 1
                        if scores[1] > 4:
                            break
                    else:
                        scores[0] += 1
                        if scores[0] > 4:
                            break

            if scores[0] > scores[1]:
                results.append((chromosome, opponent))
            else:
                results.append((opponent, chromosome))

    return results
def calculate(chromosome, opponents):
    results = []

    for opponent in opponents:
        if chromosome != opponent:
            scores = [0, 0]
            while True:
                b = Board([GaHousePlayer(chromosome), GaHousePlayer(opponent)])
                if b.start_game(250):
                    if b.players[0].is_bankrupt:
                        scores[1] += 1
                        if scores[1] > 4:
                            break
                    else:
                        scores[0] += 1
                        if scores[0] > 4:
                            break

            if scores[0] > scores[1]:
                results.append((chromosome, opponent))
            else:
                results.append((opponent, chromosome))

    return results
 def setUp(self):
     self.p = Player()
     self.board = Board([self.p])
class TestBoard(TestCase):

    def setUp(self):
        self.p = Player()
        self.board = Board([self.p])

    def test_position_update(self):
        self.assertEqual(self.board.get_position(self.p), 0)

        d1, d2 = dice_roll()
        self.board.update_position(self.p, d1, d2)

        self.assertEqual(self.board.get_position(self.p), d1 + d2)

    def test_pass_start(self):
        self.board.update_position(self.p, 10, 15)
        self.board.update_position(self.p, 10, 15)
        self.assertEqual(self.board.get_cash_left(self.p), 1500 + 200)

    def test_buy_position(self):
        self.board.buy_deed(self.p, self.board.deeds[1])

        self.assertEqual(self.board.get_cash_left(self.p), 1500 - 60)
        self.assertEqual(self.board.get_deeds(self.p), [self.board.deeds[1], ])
        self.assertEqual(self.board.get_mortgagable_deeds(self.p), [self.board.deeds[1], ])
        self.assertEqual(self.board.get_streets_owned(self.p), [])

    def test_mortgage(self):
        self.board.buy_deed(self.p, self.board.deeds[1])
        self.board.add_mortgage(self.p, self.board.deeds[1])

        self.assertEqual(self.board.get_morgages_owned(self.p), [self.board.deeds[1], ])
        self.assertEqual(self.board.get_cash_left(self.p), 1500 - 60 + 30)
        self.assertEqual(self.board.get_mortgagable_deeds(self.p), [])

    def test_streets(self):
        self.board.buy_deed(self.p, self.board.deeds[1])
        self.board.buy_deed(self.p, self.board.deeds[3])
        self.assertEqual(self.board.get_streets_owned(self.p), ["purple"])

    def test_houses(self):
        self.board.buy_deed(self.p, self.board.deeds[1])
        self.board.buy_deed(self.p, self.board.deeds[3])

        cash_left = 1500 - 60 - 60
        self.assertEqual(self.board.get_cash_left(self.p), cash_left)

        self.board.add_house(self.p, self.board.deeds[1])
        self.board.add_house(self.p, self.board.deeds[1])

        cash_left -= 50

        self.assertEqual(self.board.get_houses(self.p), [(self.board.deeds[1], 1)])
        self.assertEqual(self.board.get_cash_left(self.p), cash_left)

        self.board.sell_house(self.p, self.board.deeds[1])

        cash_left += 25

        self.assertEqual(self.board.get_cash_left(self.p), cash_left)
        self.assertTrue(self.board.add_house(self.p, self.board.deeds[1]))

    def test_morgage_house(self):
        self.board.buy_deed(self.p, self.board.deeds[1])
        self.board.buy_deed(self.p, self.board.deeds[3])

        self.board.add_house(self.p, self.board.deeds[1])
        self.board.add_house(self.p, self.board.deeds[3])
        self.assertEqual(self.board.get_houses(self.p), [(self.board.deeds[1], 1), (self.board.deeds[3], 1)])

        self.assertFalse(self.board.add_mortgage(self.p, self.board.deeds[1]))
        self.board.sell_house(self.p, self.board.deeds[1])
        self.assertTrue(self.board.add_mortgage(self.p, self.board.deeds[1]))
class TestBoard(TestCase):

    def setUp(self):
        self.p = Player()
        self.board = Board([self.p])

    def test_raise_amount_mortgage(self):
        self.board.buy_deed(self.p, self.board.deeds[1])
        self.board.buy_deed(self.p, self.board.deeds[3])

        self.p.raise_amount(30)
        self.assertEqual(self.board.get_mortgagable_deeds(self.p), [self.board.deeds[3], ])

        self.p.raise_amount(30)
        self.assertEqual(self.board.get_mortgagable_deeds(self.p), [])

    def test_raise_amount_houses(self):
        self.board.buy_deed(self.p, self.board.deeds[1])
        self.board.buy_deed(self.p, self.board.deeds[3])

        self.board.add_house(self.p, self.board.deeds[1])
        self.board.add_house(self.p, self.board.deeds[3])

        self.assertEqual(self.board.get_mortgagable_deeds(self.p), [])

        self.p.raise_amount(25)
        self.assertEqual(self.board.get_houses(self.p), [(self.board.deeds[3], 1)])
        self.assertEqual(self.board.get_mortgagable_deeds(self.p), [self.board.deeds[1], ])
Esempio n. 9
0
 def __init__(self, players, properties):
     self.players = players
     self.board = Board(self.players, properties)
Esempio n. 10
0
 def setUp(self):
     self.p = Player()
     self.board = Board([self.p])
Esempio n. 11
0
class TestBoard(TestCase):
    def setUp(self):
        self.p = Player()
        self.board = Board([self.p])

    def test_raise_amount_mortgage(self):
        self.board.buy_deed(self.p, self.board.deeds[1])
        self.board.buy_deed(self.p, self.board.deeds[3])

        self.p.raise_amount(30)
        self.assertEqual(self.board.get_mortgagable_deeds(self.p), [
            self.board.deeds[3],
        ])

        self.p.raise_amount(30)
        self.assertEqual(self.board.get_mortgagable_deeds(self.p), [])

    def test_raise_amount_houses(self):
        self.board.buy_deed(self.p, self.board.deeds[1])
        self.board.buy_deed(self.p, self.board.deeds[3])

        self.board.add_house(self.p, self.board.deeds[1])
        self.board.add_house(self.p, self.board.deeds[3])

        self.assertEqual(self.board.get_mortgagable_deeds(self.p), [])

        self.p.raise_amount(25)
        self.assertEqual(self.board.get_houses(self.p),
                         [(self.board.deeds[3], 1)])
        self.assertEqual(self.board.get_mortgagable_deeds(self.p), [
            self.board.deeds[1],
        ])