datamllab / rlcard / 308

pending completion

Build # 308

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/datamllab/rlcard/commit/d38f530cb">Merge pull request #17 from datamllab/rule_doudizhu

Rule of kicker for doudizhu

Former-commit-id: </a><a class="double-link" href="https://github.com/datamllab/rlcard/commit/17a43f709">17a43f709</a>

Run Details

22 of 22 new or added lines in 1 file covered. (100.0%)

3290 of 3448 relevant lines covered (95.42%)

0.95 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.81

/rlcard/games/mahjong/judger.py

# -*- coding: utf-8 -*-
''' Implement Mahjong Judger class
'''
from collections import defaultdict
from rlcard.games.mahjong.player import MahjongPlayer as Player
from rlcard.games.mahjong.card import MahjongCard as Card

class MahjongJudger(object):
    ''' Determine what cards a player can play
    '''

    def __init__(self):
        ''' Initilize the Judger class for Mahjong
        '''
        pass

    @staticmethod
    def judge_pong_gong(dealer, players, last_player):
        ''' Judge which player has pong/gong
        Args:
            dealer (object): The dealer object.
            players (list): List of all players
            last_player (int): The player id of last player

        '''
        last_card = dealer.table[-1]
        last_card_str = last_card.get_str()
        #last_card_value = last_card_str.split("-")[-1]
        #last_card_type = last_card_str.split("-")[0]
        for player in players:
            hand = [card.get_str() for card in player.hand]
            hand_dict = defaultdict(list)
            for card in hand:
                hand_dict[card.split("-")[0]].append(card.split("-")[1])
            #pile = player.pile
            # check gong
            if hand.count(last_card_str) == 3 and last_player != player.player_id:
                return 'gong', player, [last_card]*4
            # check pong
            if hand.count(last_card_str) == 2 and last_player != player.player_id:
                return 'pong', player, [last_card]*3
        return False, None, None

    def judge_chow(self, dealer, players, last_player):
        ''' Judge which player has chow
        Args:
            dealer (object): The dealer object.
            players (list): List of all players
            last_player (int): The player id of last player
        '''
        last_card = dealer.table[-1]
        last_card_str = last_card.get_str()
        last_card_value = last_card_str.split("-")[-1]
        last_card_type = last_card_str.split("-")[0]
        for player in players:
            hand = [card.get_str() for card in player.hand]
            hand_dict = defaultdict(list)
            for card in hand:
                hand_dict[card.split("-")[0]].append(card.split("-")[1])
            #pile = player.pile
            # check chow
            if last_card_type != "dragons" and last_card_type != "winds" and last_player == player.get_player_id() - 1:
                #flag = False
                type_values = hand_dict[last_card_type]
                type_values.append(last_card_value)
                test_value_list = sorted(type_values)
                if len(test_value_list) < 3:
                    continue
                test_card_index = test_value_list.index(last_card_value)
                test_cases = []
                if test_card_index == 0:
                    test_cases.append([test_value_list[test_card_index], test_value_list[test_card_index+1], test_value_list[test_card_index+2]])
                elif test_card_index < len(test_value_list):
                    test_cases.append([test_value_list[test_card_index-2], test_value_list[test_card_index-1], test_value_list[test_card_index]])
                else:
                    test_cases.append([test_value_list[test_card_index-1], test_value_list[test_card_index], test_value_list[test_card_index+1]])

                for l in test_cases:
                    if self.check_consecutive(l):
                        suit = last_card_type
                        cards_str= [suit+"-"+i for i in l]
                        cards = []
                        for card in player.hand:
                            if card.get_str() in cards_str and card.get_str() != last_card_str:
                                cards.append(card)
                                cards_str.pop(cards_str.index(card.get_str()))
                            if len(cards_str) == 1:
                                cards.append(last_card)
                                break
                        return 'chow', player, cards
        return False, None, None

    def judge_game(self, game):
        ''' Judge which player has win the game
        Args:
            dealer (object): The dealer object.
            players (list): List of all players
            last_player (int): The player id of last player
        '''
        players_val = []
        win_player = -1
        for player in game.players:
            win, val = self.judge_hu(player)
            players_val.append(val)
            if win == True:
                win_player = player.player_id
        if win_player != -1 or len(game.dealer.deck) == 0:
            return True, win_player, players_val
        else:
            #player_id = players_val.index(max(players_val))
            return False, win_player, players_val

    def judge_hu(self, player):
        ''' Judge whether the player has win the game
        Args:
            player (object): Target player

        Return:
            Result (bool): Win or not
            Maximum_score (int): Set count score of the player
        '''
        set_count = 0
        hand = [card.get_str() for card in player.hand]
        count_dict = {card: hand.count(card) for card in hand}
        set_count = len(player.pile)
        if set_count >= 4:
            return True, set_count
        used = []
        maximum = 0
        for each in count_dict:
            if each in used:
                continue
            tmp_set_count = 0
            tmp_hand = hand.copy()
            if count_dict[each] == 2:
                for _ in range(count_dict[each]):
                    tmp_hand.pop(tmp_hand.index(each))
                tmp_set_count, _set = self.cal_set(tmp_hand)
                used.extend(_set)
                if tmp_set_count + set_count > maximum:
                    maximum = tmp_set_count + set_count
                if tmp_set_count + set_count >= 4:
                    #print(player.get_player_id(), sorted([card.get_str() for card in player.hand]))
                    #print([[c.get_str() for c in s] for s in player.pile])
                    #print(len(player.hand), sum([len(s) for s in player.pile]))
                    #exit()
                    return True, maximum
        return False, maximum

    @staticmethod
    def check_consecutive(_list):
        ''' Check if list is consecutive
        Args:
            _list (list): The target list

        Return:
            Result (bool): consecutive or not
        '''
        l = list(map(int, _list))
        if sorted(l) == list(range(min(l), max(l)+1)):
            return True
        return False

    def cal_set(self, cards):
        ''' Calculate the set for given cards
        Args:
            Cards (list): List of cards.

        Return:
            Set_count (int):
            Sets (list): List of cards that has been pop from user's hand
        '''
        tmp_cards = cards.copy()
        sets = []
        set_count = 0
        _dict = {card: tmp_cards.count(card) for card in tmp_cards}
        # check pong/gang
        for each in _dict:
            if _dict[each] == 3 or _dict[each] == 4:
                set_count += 1
                for _ in range(_dict[each]):
                    tmp_cards.pop(tmp_cards.index(each))

        # get all of the traits of each type in hand (except dragons and winds)
        _dict_by_type = defaultdict(list)
        for card in tmp_cards:
            _type = card.split("-")[0]
            _trait = card.split("-")[1]
            if _type == 'dragons' or _type == 'winds':
                continue
            else:
                _dict_by_type[_type].append(_trait)
        for _type in _dict_by_type.keys():
            values = sorted(_dict_by_type[_type])
            if len(values) > 2:
                for index, _ in enumerate(values):
                    if index == 0:
                        test_case = [values[index], values[index+1], values[index+2]]
                    elif index == len(values)-1:
                        test_case = [values[index-2], values[index-1], values[index]]
                    else:
                        test_case = [values[index-1], values[index], values[index+1]]
                    if self.check_consecutive(test_case):
                        set_count += 1
                        for each in test_case:
                            values.pop(values.index(each))
                            c = _type+"-"+str(each)
                            sets.append(c)
                            if c in tmp_cards:
                                tmp_cards.pop(tmp_cards.index(c))
        return set_count, sets

if __name__ == "__main__":
    judger = MahjongJudger()
    player = Player(0)
    card_info = Card.info
    #print(card_info)
    player.pile.append([Card(card_info['type'][0], card_info['trait'][0])]*3)
    #player.hand.extend([Card(card_info['type'][0], card_info['trait'][0])]*2)
    player.hand.extend([Card(card_info['type'][1], card_info['trait'][1])]*4)
    player.hand.extend([Card(card_info['type'][2], card_info['trait'][1])]*3)
    player.hand.extend([Card(card_info['type'][0], card_info['trait'][2])]*3)
    player.hand.extend([Card(card_info['type'][3], card_info['trait'][9])]*2)
    #player.hand.extend([Card(card_info['type'][2], card_info['trait'][4])]*1)
    print([card.get_str() for card in player.hand])
    print(judger.judge_hu(player))

1	# -- coding: utf-8 --
2	''' Implement Mahjong Judger class	1✔
3	'''
4	from collections import defaultdict	1✔
5	from rlcard.games.mahjong.player import MahjongPlayer as Player	1✔
6	from rlcard.games.mahjong.card import MahjongCard as Card	1✔
7
8	class MahjongJudger(object):	1✔
9	''' Determine what cards a player can play
10	'''
11
12	def __init__(self):	1✔
13	''' Initilize the Judger class for Mahjong
14	'''
15	pass	1✔
16
17	@staticmethod	1✔
18	def judge_pong_gong(dealer, players, last_player):
19	''' Judge which player has pong/gong
20	Args:
21	dealer (object): The dealer object.
22	players (list): List of all players
23	last_player (int): The player id of last player
24
25	'''
26	last_card = dealer.table[-1]	1✔
27	last_card_str = last_card.get_str()	1✔
28	#last_card_value = last_card_str.split("-")[-1]
29	#last_card_type = last_card_str.split("-")[0]
30	for player in players:	1✔
31	hand = [card.get_str() for card in player.hand]	1✔
32	hand_dict = defaultdict(list)	1✔
33	for card in hand:	1✔
34	hand_dict[card.split("-")[0]].append(card.split("-")[1])	1✔
35	#pile = player.pile
36	# check gong
37	if hand.count(last_card_str) == 3 and last_player != player.player_id:	1✔
38	return 'gong', player, [last_card]*4	×
39	# check pong
40	if hand.count(last_card_str) == 2 and last_player != player.player_id:	1✔
41	return 'pong', player, [last_card]*3	1✔
42	return False, None, None	1✔
43
44	def judge_chow(self, dealer, players, last_player):	1✔
45	''' Judge which player has chow
46	Args:
47	dealer (object): The dealer object.
48	players (list): List of all players
49	last_player (int): The player id of last player
50	'''
51	last_card = dealer.table[-1]	1✔
52	last_card_str = last_card.get_str()	1✔
53	last_card_value = last_card_str.split("-")[-1]	1✔
54	last_card_type = last_card_str.split("-")[0]	1✔
55	for player in players:	1✔
56	hand = [card.get_str() for card in player.hand]	1✔
57	hand_dict = defaultdict(list)	1✔
58	for card in hand:	1✔
59	hand_dict[card.split("-")[0]].append(card.split("-")[1])	1✔
60	#pile = player.pile
61	# check chow
62	if last_card_type != "dragons" and last_card_type != "winds" and last_player == player.get_player_id() - 1:	1✔
63	#flag = False
64	type_values = hand_dict[last_card_type]	1✔
65	type_values.append(last_card_value)	1✔
66	test_value_list = sorted(type_values)	1✔
67	if len(test_value_list) < 3:	1✔
68	continue	×
69	test_card_index = test_value_list.index(last_card_value)	1✔
70	test_cases = []	1✔
71	if test_card_index == 0:	1✔
72	test_cases.append([test_value_list[test_card_index], test_value_list[test_card_index+1], test_value_list[test_card_index+2]])	1✔
73	elif test_card_index < len(test_value_list):	1✔
74	test_cases.append([test_value_list[test_card_index-2], test_value_list[test_card_index-1], test_value_list[test_card_index]])	1✔
75	else:
76	test_cases.append([test_value_list[test_card_index-1], test_value_list[test_card_index], test_value_list[test_card_index+1]])	×
77
78	for l in test_cases:	1✔
79	if self.check_consecutive(l):	1✔
80	suit = last_card_type	1✔
81	cards_str= [suit+"-"+i for i in l]	1✔
82	cards = []	1✔
83	for card in player.hand:	1✔
84	if card.get_str() in cards_str and card.get_str() != last_card_str:	1✔
85	cards.append(card)	1✔
86	cards_str.pop(cards_str.index(card.get_str()))	1✔
87	if len(cards_str) == 1:	1✔
88	cards.append(last_card)	1✔
89	break	1✔
90	return 'chow', player, cards	1✔
91	return False, None, None	1✔
92
93	def judge_game(self, game):	1✔
94	''' Judge which player has win the game
95	Args:
96	dealer (object): The dealer object.
97	players (list): List of all players
98	last_player (int): The player id of last player
99	'''
100	players_val = []	1✔
101	win_player = -1	1✔
102	for player in game.players:	1✔
103	win, val = self.judge_hu(player)	1✔
104	players_val.append(val)	1✔
105	if win == True:	1✔
106	win_player = player.player_id	×
107	if win_player != -1 or len(game.dealer.deck) == 0:	1✔
108	return True, win_player, players_val	1✔
109	else:
110	#player_id = players_val.index(max(players_val))
111	return False, win_player, players_val	1✔
112
113	def judge_hu(self, player):	1✔
114	''' Judge whether the player has win the game
115	Args:
116	player (object): Target player
117
118	Return:
119	Result (bool): Win or not
120	Maximum_score (int): Set count score of the player
121	'''
122	set_count = 0	1✔
123	hand = [card.get_str() for card in player.hand]	1✔
124	count_dict = {card: hand.count(card) for card in hand}	1✔
125	set_count = len(player.pile)	1✔
126	if set_count >= 4:	1✔
127	return True, set_count	×
128	used = []	1✔
129	maximum = 0	1✔
130	for each in count_dict:	1✔
131	if each in used:	1✔
132	continue	1✔
133	tmp_set_count = 0	1✔
134	tmp_hand = hand.copy()	1✔
135	if count_dict[each] == 2:	1✔
136	for _ in range(count_dict[each]):	1✔
137	tmp_hand.pop(tmp_hand.index(each))	1✔
138	tmp_set_count, _set = self.cal_set(tmp_hand)	1✔
139	used.extend(_set)	1✔
140	if tmp_set_count + set_count > maximum:	1✔
141	maximum = tmp_set_count + set_count	1✔
142	if tmp_set_count + set_count >= 4:	1✔
143	#print(player.get_player_id(), sorted([card.get_str() for card in player.hand]))
144	#print([[c.get_str() for c in s] for s in player.pile])
145	#print(len(player.hand), sum([len(s) for s in player.pile]))
146	#exit()
147	return True, maximum	×
148	return False, maximum	1✔
149
150	@staticmethod	1✔
151	def check_consecutive(_list):
152	''' Check if list is consecutive
153	Args:
154	_list (list): The target list
155
156	Return:
157	Result (bool): consecutive or not
158	'''
159	l = list(map(int, _list))	1✔
160	if sorted(l) == list(range(min(l), max(l)+1)):	1✔
161	return True	1✔
162	return False	1✔
163
164	def cal_set(self, cards):	1✔
165	''' Calculate the set for given cards
166	Args:
167	Cards (list): List of cards.
168
169	Return:
170	Set_count (int):
171	Sets (list): List of cards that has been pop from user's hand
172	'''
173	tmp_cards = cards.copy()	1✔
174	sets = []	1✔
175	set_count = 0	1✔
176	_dict = {card: tmp_cards.count(card) for card in tmp_cards}	1✔
177	# check pong/gang
178	for each in _dict:	1✔
179	if _dict[each] == 3 or _dict[each] == 4:	1✔
180	set_count += 1	1✔
181	for _ in range(_dict[each]):	1✔
182	tmp_cards.pop(tmp_cards.index(each))	1✔
183
184	# get all of the traits of each type in hand (except dragons and winds)
185	_dict_by_type = defaultdict(list)	1✔
186	for card in tmp_cards:	1✔
187	_type = card.split("-")[0]	1✔
188	_trait = card.split("-")[1]	1✔
189	if _type == 'dragons' or _type == 'winds':	1✔
190	continue	1✔
191	else:
192	_dict_by_type[_type].append(_trait)	1✔
193	for _type in _dict_by_type.keys():	1✔
194	values = sorted(_dict_by_type[_type])	1✔
195	if len(values) > 2:	1✔
196	for index, _ in enumerate(values):	1✔
197	if index == 0:	1✔
198	test_case = [values[index], values[index+1], values[index+2]]	1✔
199	elif index == len(values)-1:	1✔
200	test_case = [values[index-2], values[index-1], values[index]]	1✔
201	else:
202	test_case = [values[index-1], values[index], values[index+1]]	1✔
203	if self.check_consecutive(test_case):	1✔
204	set_count += 1	1✔
205	for each in test_case:	1✔
206	values.pop(values.index(each))	1✔
207	c = _type+"-"+str(each)	1✔
208	sets.append(c)	1✔
209	if c in tmp_cards:	1✔
210	tmp_cards.pop(tmp_cards.index(c))	1✔
211	return set_count, sets	1✔
212
213	if __name__ == "__main__":	1✔
214	judger = MahjongJudger()	×
215	player = Player(0)	×
216	card_info = Card.info	×
217	#print(card_info)
218	player.pile.append([Card(card_info['type'][0], card_info['trait'][0])]*3)	×
219	#player.hand.extend([Card(card_info['type'][0], card_info['trait'][0])]*2)
220	player.hand.extend([Card(card_info['type'][1], card_info['trait'][1])]*4)	×
221	player.hand.extend([Card(card_info['type'][2], card_info['trait'][1])]*3)	×
222	player.hand.extend([Card(card_info['type'][0], card_info['trait'][2])]*3)	×
223	player.hand.extend([Card(card_info['type'][3], card_info['trait'][9])]*2)	×
224	#player.hand.extend([Card(card_info['type'][2], card_info['trait'][4])]*1)
225	print([card.get_str() for card in player.hand])	×
226	print(judger.judge_hu(player))	×

datamllab / rlcard / 308

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous