def mid_card(self, allowed_cards, first, min):
#print('mid card')
card_obj = cards()
if first:
min = 3
#print(min)
card = allowed_cards[0]
mid_rank = card_obj.get_rank(card[1])
found_good_rank = min < mid_rank
for i in range(1, len(allowed_cards)):
#print('mid: ',mid_rank,' min: ',min,' rank: ',card_obj.get_rank(allowed_cards[i][1]))
if not found_good_rank:
#print('did not find')
if card_obj.get_rank(allowed_cards[i][1]) > mid_rank:
#print('if', allowed_cards[i])
card = allowed_cards[i]
mid_rank = card_obj.get_rank(allowed_cards[i][1])
found_good_rank = min < mid_rank
elif card_obj.get_rank(
allowed_cards[i][1]) < mid_rank and card_obj.get_rank(
allowed_cards[i][1]) > min:
#print('elif',allowed_cards[i])
card = allowed_cards[i]
mid_rank = card_obj.get_rank(allowed_cards[i][1])
return card
def highest_card_played(self,cards_played):
new_cards = cards()
suit, rank = cards_played[0][1][0], new_cards.get_rank(cards_played[0][1][1])
for i in range(1, len(cards_played)):
if cards_played[i][1][0] == suit and new_cards.get_rank(cards_played[i][1][1]) > rank:
rank = new_cards.get_rank(cards_played[i][1][1])
return rank
def analyse_trick(self, previous_trick, trick_winner):
new_cards = cards()
#suit, rank = previous_trick[0][1][0], new_cards.get_rank(previous_trick[0][1][1])
suit = previous_trick[0][1][0]
#print('winnnnnnner: ',trick_winner)
for i in range(len(previous_trick)):
rank = self.highest_card_played(previous_trick[:i + 1])
if not previous_trick[i][0] == 'Motaz':
#print('analyse trick')
#print('player: ',previous_trick[i][0], ' ',previous_trick[i][1])
player_rank = new_cards.get_rank(previous_trick[i][1][1])
if previous_trick[i][1][0] == suit:
if player_rank < rank:
expected, index = self.remove_player_cards(
previous_trick[i][0], rank, player_rank, suit,
True, suit, previous_trick)
self.players_cards_expected[index] = expected
else:
player_suit = previous_trick[i][1][0]
expected, index = self.remove_player_cards(
previous_trick[i][0], rank, player_rank, player_suit,
False, suit, previous_trick)
self.players_cards_expected[index] = copy.deepcopy(
expected)
if i == len(previous_trick) - 1 and previous_trick[i][
0] == trick_winner and trick_winner != 'Motaz':
#print('winner: ',trick_winner,' player: ',previous_trick[i][0])
expected, index = self.remove_higher_cards(
previous_trick[i][0], rank, suit)
self.players_cards_expected[index] = expected
def check_block(self, card):
card_obj = cards()
#print('hand to check block: ', self.hand)
#print((card[0], card_obj.get_rank_name(card_obj.get_rank(card[1]) - 1)))
#print((card[0], card_obj.get_rank_name(card_obj.get_rank(card[1]) - 1)) in self.hand)
return (card[0],
card_obj.get_rank_name(card_obj.get_rank(card[1]) -
1)) in self.hand
def block_to_the_end(self, card):
card_obj = cards()
if card_obj.get_rank(card[1]) == 1:
return True
if self.check_block(card):
return self.block_to_the_end(
(card[0],
card_obj.get_rank_name(card_obj.get_rank(card[1]) - 1)))
return False
def max_card(self, allowed_cards):
card_obj = cards()
card = allowed_cards[0]
max_rank = card_obj.get_rank(card[1])
for i in range(1, len(allowed_cards)):
if card_obj.get_rank(allowed_cards[i][1]) > max_rank:
card = allowed_cards[i]
max_rank = card_obj.get_rank(allowed_cards[i][1])
return card
def evaluate_suit(self, my_cards):
#print('####### evalutae ##########')
suit = my_cards[0][0]
number_of_my_cards = len(my_cards)
temp = []
limit = 0
for i in self.players_cards_expected:
player_suit = self.extract_suits(i).get(suit)
#print('type of suit: ',player_suit)
if type(player_suit) == list:
temp.append(len(player_suit))
if temp[-1] > 0:
limit += 1
number_of_players_cards = min(temp)
temp = [number_of_my_cards, number_of_players_cards]
number_of_cards_to_check = min(temp)
#print('temp: ',temp)
#print('number: ',number_of_cards_to_check)
#print('players cards expected: ',number_of_players_cards)
#print('my cards: ', my_cards)
card_obj = cards()
strong = True
cards_left = self.suits_left(suit)
#self.extract_suits(my_cards).get(suit)
#print('cards to check: ',my_cards)
#print('cards to compare: ',cards_left)
#print('cards checke: ',number_of_cards_to_check)
#print('limit: ',limit)
found = False
counter = 0
# print('cards to check: ',number_of_cards_to_check)
for i in range(number_of_cards_to_check):
my_rank = card_obj.get_rank(my_cards[i][1])
# print('rank: ',my_rank)
for j in range(limit):
if i * limit + j < len(cards_left):
rank_to_compare = card_obj.get_rank(cards_left[i * limit +
j][1])
# print('rank to compare: ', rank_to_compare)
if rank_to_compare > my_rank and counter == 1:
found = True
# print('rank to compare: ',rank_to_compare)
counter += 1
break
else:
found = True
break
# print()
if not found:
strong = found
break
#print('strong: ',strong)
return (my_cards[0][0], strong)
def majority_less(self,highest,allowed_cards):
#print('majority less: ',highest)
#print('allowed cards: ',allowed_cards)
card_obj = cards()
for i in range(len(allowed_cards)):
if card_obj.get_rank(allowed_cards[i][1])> highest:
return len(allowed_cards)-i<i
if i == 3:
return True
return True
def trick_winner(cards_played):
new_cards = cards()
print(cards_played)
suit, rank = cards_played[0][1][0], new_cards.get_rank(cards_played[0][1][1])
winner = 0
for i in range(1, len(cards_played)):
if cards_played[i][1][0] == suit and new_cards.get_rank(cards_played[i][1][1]) > rank:
rank = new_cards.get_rank(cards_played[i][1][1])
winner = i
print('winner is : ', cards_played[winner])
return winner
def valid_actions(self, allowed_cards, highest_card):
#print('*************** valid actions *************')
#print('allowed_cards: ',allowed_cards)
#print('highest: ',highest_card)
card_obj = cards()
if len(allowed_cards) == 1:
return [2], False
if highest_card > card_obj.get_rank(allowed_cards[-1][1]):
return [2], False
if highest_card < card_obj.get_rank(allowed_cards[0][1]):
return [1, 2], True
return [0, 1, 2], True
def remove_higher_cards(self, player, rank, suit):
new_cards = cards()
index_player = 0
#print(player)
for i in range(len(self.players)):
if self.players[i] == player:
index_player = i - 1
break
card = copy.deepcopy(self.players_cards_expected[index_player])
#print(len(card),'cards before process: ', card)
for i in range(13 - rank):
if (suit, new_cards.get_rank_name(rank + i + 1)) in card:
card.remove((suit, new_cards.get_rank_name(rank + i + 1)))
#print(len(card),'cards after process: ', card)
return copy.deepcopy(card), index_player
def allowed_cards(self, jack, hand):
playing = True
# print('hand: ',hand)
# print('jack: ',jack)
card_obj = cards()
allowed_up = []
allowed_down = []
for i in range(len(jack[1])):
# print('type down : ', type(jack[1][i]))
if type(jack[1][i]) != tuple:
rank_allowed = 10
else:
rank_allowed = card_obj.get_rank(jack[1][i][1]) - 1
# print('rank allowed: ',rank_allowed,' card: ',(jack[1][i][0],card_obj.get_rank_name(rank_allowed)))
if rank_allowed != 0 and (
self.suits[i],
card_obj.get_rank_name(rank_allowed)) in hand:
allowed_down.append(
(self.suits[i], card_obj.get_rank_name(rank_allowed)))
# print('base rank: ',rank_allowed)
# print('type up : ', type(jack[0][i]))
if type(jack[0][i]) != tuple:
if rank_allowed == 10:
rank_allowed = -1
else:
rank_allowed = 11
else:
rank_allowed = card_obj.get_rank(jack[0][i][1]) + 1
if rank_allowed != 14 and rank_allowed != -1 and (
self.suits[i],
card_obj.get_rank_name(rank_allowed)) in hand:
# print('check me:',card_obj.get_rank_name(rank_allowed))
# print('allowed rank: ',rank_allowed)
allowed_up.append(
(self.suits[i], card_obj.get_rank_name(rank_allowed)))
if len(allowed_down) == 0 and len(allowed_up) == 0:
playing = False
#print('allowed up: ', allowed_up)
#print('allowed down: ', allowed_down)
#print('playing: ', playing)
return allowed_up, allowed_down, playing
def remove_player_cards(self, player, highest_rank, player_rank, suit,
match, base_suit, trick):
#print('remove player cards')
new_cards = cards()
index_player = 0
for i in range(len(self.players)):
if self.players[i] == player:
index_player = i - 1
break
card = copy.deepcopy(self.players_cards_expected[index_player])
for i in trick:
if i[1] in card:
#print('to be removed: ',i[1])
#print('cards to remove from: ',card)
card.remove(i[1])
#print('cards after remove: ', card)
#print(player,' ',highest_rank,' ',player_rank,' ',suit)
#print(len(self.hand),len(card),card)
if match:
for i in range(highest_rank - player_rank - 1):
if (suit,
new_cards.get_rank_name(player_rank + i + 1)) in card:
card.remove(
(suit, new_cards.get_rank_name(player_rank + i + 1)))
else:
for i in range(14 - player_rank):
if (suit, new_cards.get_rank_name(player_rank + i)) in card:
card.remove(
(suit, new_cards.get_rank_name(player_rank + i)))
#print(len(card), card)
counter = 0
for i in range(len(card)):
#print('len: ', len(card), ' suit: ', base_suit, ' i: ', i)
#print(card)
if card[i - counter][0] == base_suit:
card.pop(i - counter)
counter += 1
#print(len(self.hand),len(card),card)
return copy.deepcopy(card), index_player
class Plyer():
card = """
______
| |
|{: ^6}|
| of |
|{: ^6}|
|______|
"""
cardls = []
c = cards()
def __init__(self, type):
self.type = type
def __init__(self):
del self
def profile(self, res=0):
ls = Plyer.c.choose()
#Plyer.cardls = [Plyer.card.format(ls[0],ls[1]),Plyer.card.format(ls2[0],ls2[1])]
Plyer.cardls.append(Plyer.card.format(ls[0], ls[1]))
player = [x for x in range(len(Plyer.cardls))]
lines = [Plyer.cardls[i].splitlines() for i in player]
for l in zip(*lines):
print(*l, sep='')
return [ls[0], ls[2]]
def details(self):
print(Plyer.c.details())
def rerun(self):
Plyer.cardls = []
class Plyer():
card = """
______
| |
|{: ^6}|
| of |
|{: ^6}|
|______|
"""
cardls = []
c = cards()
def __init__(self):
del self
def profile(self, res=0):
ls = Plyer.c.choose()
#Plyer.cardls = [Plyer.card.format(ls[0],ls[1]),Plyer.card.format(ls2[0],ls2[1])]
Plyer.cardls.append(Plyer.card.format(ls[0], ls[1]))
#player = [x for x in range(len(Plyer.cardls))]
#lines = [Plyer.cardls[i].splitlines() for i in player]
return [ls[0], ls[2], Plyer.cardls]
def details(self):
print(Plyer.c.details())
def rerun(self):
Plyer.cardls = []
def count(self):
return Plyer.c.count()
def reload(self):
Plyer.c.reload()
def min_card(self, allowed_cards,first,max):
card_obj = cards()
if first:
max = 5
#print(max)
card = allowed_cards[0]
min_rank = card_obj.get_rank(card[1])
found_lower_than_max = min_rank<max
for i in range(1,len(allowed_cards)):
if not found_lower_than_max:
if card_obj.get_rank(allowed_cards[i][1]) < min_rank:
card = allowed_cards[i]
min_rank = card_obj.get_rank(allowed_cards[i][1])
found_lower_than_max = min_rank<max
elif card_obj.get_rank(allowed_cards[i][1]) > min_rank and card_obj.get_rank(allowed_cards[i][1])<max:
card = allowed_cards[i]
min_rank = card_obj.get_rank(allowed_cards[i][1])
return card
def sorted_lowest(self, suits_names):
card_obj = cards()
#print()
#print('my hand: ', self.hand)
suits = self.extract_suits(self.hand)
lowest_cards = []
for i in suits_names:
if suits.get(i) != None and card_obj.get_rank(
suits.get(i)[0][1]) < 11:
lowest_cards.append(suits.get(i)[0])
lowest_cards = sorted(lowest_cards, key=self.getKey)
#print('lowest cards : ', lowest_cards)
self.lowest_cards = lowest_cards
self.lowest_suits = self.lowest_cards.copy()
for i in range(len(self.lowest_cards)):
self.lowest_suits[i] = self.lowest_cards[i][0]
#print('lowest suits : ', self.lowest_suits)
#print()
self.update_options()
def update_jack(player, card, cards_left):
card_obj = cards()
print('up: ', up_cards)
print('down: ', down_cards)
print(player, ' played: ', card)
print('card: ', card)
if type(card) != str:
index = suits.index(card[0])
if card_obj.get_rank(card[1]) > 10:
up_cards[index] = card
else:
down_cards[index] = card
cards_left -= 1
print('cards played so far: ')
print(up_cards)
print(down_cards)
jack[0] = up_cards
jack[1] = down_cards
return cards_left
from cards import cards
from trained_player_diamonds import trained_player_diamonds
import random
#rename to trianing tricks
print('welcom to diamonds')
deck = cards()
# def __init__(self, name, score, hand, game,human):
player = trained_player_diamonds('Motaz', True)
ai1 = trained_player_diamonds('ai1', False)
ai2 = trained_player_diamonds('ai2', False)
ai3 = trained_player_diamonds('ai3', False)
players = [player, ai1, ai2, ai3]
temp_players = [player, ai1, ai2, ai3]
players_order = players
order_of_play = ['Motaz', 'ai1', 'ai2', 'ai3']
end_game = False
first_game = True
new_subgame = True
new_subgame = True
your_kingdom = True
sub_game_finished = False
games_left = 1
sub_games_left = 1
scores = [0, 0, 0, 0]
subscores = [0, 0, 0, 0]
def test_duas_cartas_diferentes(self):
cartas = [1, 2]
self.assertEqual(2, cards(cartas))
def test_10(self):
cartas = [1] * 30
self.assertEqual(len(cartas) / 2, cards(cartas))
def test_duas_cartas_iguais(self):
cartas = [1, 1]
self.assertEqual(1, cards(cartas))
def test_quatro_cartas_iguais_2(self):
cartas = [2, 2, 2, 2]
self.assertEqual(4, cards(cartas))
def test_10(self):
cartas = [1]*30
self.assertEqual(len(cartas)/2, cards(cartas))
import cards
import sys
import time
from getch import getch, pause
import os
#########
# card manager
##########
deckpath = sys.argv[1]
reviewpath = sys.argv[2]
MANAGER = cards.cards(deckpath, reviewpath)
# manager hjas getaq answer(int) and getq()
##############
# MAINLOOP
#############
stop = False
while not stop:
print(MANAGER.getq())
pause()
print(MANAGER.getaq())
ch = getch()
if ch == 'q':
break
MANAGER.answer(int(ch))
def test_quatro_cartas_diferentes1234(self):
cartas = [1, 2, 3, 4]
self.assertEqual(6, cards(cartas))
def test_quatro_cartas_diferentes1234(self):
cartas = [1, 2, 3, 4]
self.assertEqual(6, cards(cartas))
import start_game
import player_table
import property
import turn
import cards
import options
import os
#### INITIALIZE GAME #####
# Create blank player_table, which holds all info about players
pl = player_table.player_table()
# Initialize property database
prop = property.property_table()
# Initialize cards database
cards = cards.cards()
# Initialize whose turn it is - if a game is loaded, this may change
whose_turn = 0
print '\n' * 50
print '======================================================\n'
print "Welcome to Monopoly: The game of unadulterated capitalism.\n\n"
start_game.new_or_load(pl,prop,cards,whose_turn)
print '\n======================================================'
raw_input("\nWe're all set to play! Press enter to continue.\n")
print '\n' * 50
print '======================================================'
while pl.player_count > 1:
doubles = True
def test_quatro_cartas_diferentes_onde_o_melhor_eh_ser_esperto2(self):
cartas = [7, -3, 50, 47]
self.assertEqual(57, cards(cartas))
import start_game
import player_table
import property
import turn
import cards
import options
import os
#### INITIALIZE GAME #####
# Create blank player_table, which holds all info about players
pl = player_table.player_table()
# Initialize property database
prop = property.property_table()
# Initialize cards database
cards = cards.cards()
# Initialize whose turn it is - if a game is loaded, this may change
whose_turn = 0
print '\n' * 50
print '======================================================\n'
print "Welcome to Monopoly: The game of unadulterated capitalism.\n\n"
start_game.new_or_load(pl, prop, cards, whose_turn)
print '\n======================================================'
raw_input("\nWe're all set to play! Press enter to continue.\n")
print '\n' * 50
print '======================================================'
while pl.player_count > 1:
doubles = True
def __init__(self):
super().__init__(4)
self._player_cards: Dict[str, cards.MultiPlayingCardCollection] = {}
self._bank_stats: int = 0
self._card_deck: cards.MultiPlayingCardCollection = cards.mdeck(
cards.cards())
def test_duas_cartas_diferentes(self):
cartas = [1, 2]
self.assertEqual(2, cards(cartas))
def getKey(self, item):
card_obj = cards()
return card_obj.get_rank(item[1])
def test_duas_cartas_diferentes_2_1(self):
cartas = [2, 1]
self.assertEqual(2, cards(cartas))
def test_quatro_cartas_diferentes(self):
cartas = [1, 2, 2, 1]
self.assertEqual(3, cards(cartas))
def test_seis_cartas_diferentes(self):
cartas = [811605199,89864465,877809956,930012974,283791902,907039700]
self.assertEqual(2068641558, cards(cartas))
def test_quatro_cartas_diferentes_onde_o_melhor_eh_ser_esperto2(self):
cartas = [7, -3, 50, 47]
self.assertEqual(57, cards(cartas))
def test_duas_cartas_iguais(self):
cartas = [1, 1]
self.assertEqual(1, cards(cartas))
def test_quatro_cartas_iguais(self):
cartas = [1, 1, 1, 1]
self.assertEqual(2, cards(cartas))
def test_quatro_cartas_diferentes_onde_o_melhor_eh_ser_meio_burro(self):
cartas = [7, -3, 47, 50]
self.assertEqual(57, cards(cartas))
def test_seis_cartas_diferentes(self):
cartas = [
811605199, 89864465, 877809956, 930012974, 283791902, 907039700
]
self.assertEqual(2068641558, cards(cartas))
def test_quatro_cartas_diferentes_onde_o_melhor_eh_ser_meio_burro(self):
cartas = [7, -3, 47, 50]
self.assertEqual(57, cards(cartas))
