def main():
c8_dealer = Dealer()
c8_opponent = Game()
c8_opponent.add_cards(c8_dealer.deal_cards(7))
c8_player = Player()
c8_player.add_cards(c8_dealer.deal_cards(7))
print("...Setup Complete. Enjoy the game!...\n")
while (c8_player.count() > 0 and c8_opponent.count() > 0):
#clear_output(wait=True)
print("\nCard In Play Is:", in_play(c8_dealer), "\n")
stat = player_play(c8_player, c8_dealer)
if (stat == "empty"):
print("...Deck is empty. Exiting...")
break
elif (stat == "quit"):
print("...Quiting...")
break
stat = game_play(c8_opponent, c8_dealer)
if stat == "empty":
print("...Deck is empty. Exiting...")
break
if (c8_player.count() == 0):
print("Yay! You won!")
elif (c8_opponent.count() == 0):
print("Computer won. Better luck next time!")
def create(money):
for x in range(2):
dealer = Dealer()
dealer.add_player("test")
# dealer.add_player("test2")
dealer.deal_cards()
for player in dealer.players:
deck.append([dealer.inspect_players()])
deal(money, deck, turn)
class PokerGame :
def __init__(self):
self.p1 = Player(1)
self.p2 = Player(2)
self.dealer = Dealer()
self.pot = 0
self.flop_cards = []
self.bet_flag = False
self.check_flag = False
self.cur_bet = 0
self.cur_round = 0
self.cur_player = 1
self.evaluator = FiveEval()
def pre_flop(self):
hands = self.dealer.deal_cards()
self.p1.hand = hands[0]
self.p2.hand = hands[1]
self.cur_bet = 0
self.handle_move(self.p1.your_move(), 1)
def flop(self):
self.check_flag = False
self.bet_flag = False
self.see_pot()
print "-----------------------------"
print "Dealing flop"
self.flop_cards = self.dealer.deal_flop()
visible_flop = []
for card in self.flop_cards:
visible_flop.append(str(self.evaluator.number_lookup_table[self.evaluator.deckcardsFace[card]])+str(self.evaluator.suit_lookup_table[self.evaluator.deckcardsSuit[card]]))
print "Flop: " + str(visible_flop)
self.cur_bet = 0
self.handle_move(self.p1.your_move(), 1)
def see_stack_sizes(self):
print "------------------------------"
print "Stack Sizes"
print("Player 1 stack: " + str(self.p1.stack))
print("Player 2 stack: " + str(self.p2.stack))
def see_pot(self):
print "------------------------------"
print "Pot Size: $" + str(self.pot)
def handle_move(self, move, id):
if move[0] == 'F':
self.bet_flag = False
print "Player " + str(move[1]) + "folded"
self.end_round(move[1])
elif move[0] == 'B' and self.bet_flag == False:
self.cur_bet = move[1]
self.pot = self.pot + self.cur_bet
self.bet_flag = True
print "Player " + str(move[2]) + " bet $" + str(self.cur_bet)
self.change_turn(move[2])
elif move[0] == 'CA' and self.bet_flag == True:
self.pot = self.pot + self.cur_bet
self.bet_flag = False
print "Player " + str(move[2]) + " called the bet"
self.next_round()
elif move[0] == 'C' and self.bet_flag == False:
if self.check_flag == False:
print "Player " + str(move[1]) + " checked"
self.check_flag = True
self.change_turn(move[1])
else:
print "Player " + str(move[1]) + " checked"
self.check_flag = False
self.next_round()
else:
print "False Move"
self.repeat_turn()
def change_turn(self, cur_player):
print "-----------------------------"
if cur_player == 1:
self.cur_player = cur_player
self.handle_move(self.p2.your_move(),2)
else:
self.cur_player = cur_player
self.handle_move(self.p1.your_move(),1)
def next_round(self):
self.cur_round = self.cur_round + 1
if self.cur_round == 1:
self.flop()
if self.cur_round == 2:
self.evaluate()
def repeat_turn(self):
if self.cur_round == 1:
self.handle_move(self.p1.your_move(),1)
else:
self.handle_move(self.p2.your_move(),2)
def end_round(self, folded_player):
print "Player " + str(folded_player) + " folded."
def evaluate(self):
self.cur_round += 1
self.see_pot()
p1_hand = self.p1.hand + self.flop_cards
p2_hand = self.p2.hand + self.flop_cards
score_p1 = self.evaluator.getRankOfFive(p1_hand[0],p1_hand[1],p1_hand[2],p1_hand[3],p1_hand[4])
score_p2 = self.evaluator.getRankOfFive(p2_hand[0],p2_hand[1],p2_hand[2],p2_hand[3],p2_hand[4])
if score_p1 > score_p2:
print "Player 1 wins $" + str(self.pot)
self.p1.stack += self.pot
elif score_p2 > score_p1:
print "Player 2 wins $" + str(self.pot)
self.p2.stack += self.pot
else:
print "Split pot"
self.p2.stack += (0.5*self.pot)
self.p1.stack += (0.5*self.pot)
self.see_stack_sizes()
class TestDealer(unittest.TestCase):
def setUp(self):
# Traits (Trait, Food-value)
self.carnivore = TraitCard(CARNIVORE, 3)
self.burrowing = TraitCard(BURROWING, 2)
self.fattissue = TraitCard(FATTISSUE, 2)
self.foraging = TraitCard(FORAGING, 2)
self.horns = TraitCard(HORNS, 0)
self.cooperation = TraitCard(COOPERATION, 1)
self.scavenger = TraitCard(SCAVENGER, 2)
# Species (Population, Food, Body, Traits, Fat-Storage)
self.species1 = Species(1, 0, 2, [self.cooperation])
self.species2 = Species(6, 2, 1, [self.carnivore])
self.species3 = Species(3, 3, 3, [self.fattissue], 0)
self.species4 = Species(5, 5, 5, [self.burrowing])
self.species5 = Species(5, 3, 4, [self.foraging])
self.species6 = Species(2, 1, 7, [self.carnivore, self.fattissue, self.scavenger], 0)
self.species7 = Species(7, 1, 6, [self.horns])
self.player1_species = [self.species1, self.species2]
self.player2_species = [self.species3, self.species4, self.species5]
self.player3_species = [self.species6, self.species7]
# Players (Name, Bag, Hand, Species)
self.player1 = PlayerState(1, 0, [self.horns, self.foraging], self.player1_species)
self.player2 = PlayerState(2, 3, [self.carnivore, self.fattissue], self.player2_species)
self.player3 = PlayerState(3, 6, [self.burrowing], self.player3_species)
self.public_player1 = PlayerState(1, False, False, self.player1_species)
self.public_player2 = PlayerState(2, False, False, self.player2_species)
self.public_player3 = PlayerState(3, False, False, self.player3_species)
self.list_of_players = [self.player1, self.player2, self.player3]
# Dealer (List of Players, Watering Hole, Deck)
self.dealer1 = Dealer(self.list_of_players, 10, [])
# Action
self.action4_1 = Action4([FoodCardAction(1), GrowAction(POPULATION, 0, 0)])
self.action4_2 = Action4([FoodCardAction(0), ReplaceTraitAction(1, 0, 1)])
self.action4_3 = Action4([AddSpeciesAction(0, [])])
self.action4_list = [self.action4_1, self.action4_2, self.action4_3]
def test_make_deck(self):
deck = Dealer.make_deck()
self.assertEqual(len(deck), LOC_MAX)
self.assertEqual(len(deck), len(set(deck)))
def test_deal_cards(self):
self.dealer1.deck = Dealer.make_deck()
self.assertEqual([len(self.dealer1.deck), len(self.player1.hand)], [LOC_MAX, 2])
self.dealer1.deal_cards(self.player1, 10)
self.assertEqual([len(self.dealer1.deck), len(self.player1.hand)], [LOC_MAX - 10, 12])
def test_public_players(self):
public_players = self.dealer1.public_players(self.player1)
self.assertTrue(public_players[0].equal_attributes(self.public_player2))
self.assertTrue(public_players[1].equal_attributes(self.public_player3))
def test_step4(self):
old_dealer = copy.deepcopy(self.dealer1)
self.dealer1.step4(self.action4_list)
self.assertEqual(old_dealer.show_changes(self.dealer1),
'Player 1:removed cards: [horns, 0], [foraging, 2], '
'Species 0: [[population, 1->2], [food, 0->2]], '
'Species 1: [[food, 2->3]], '
'Player 2:removed cards: [carnivore, 3], [fat-tissue, 2], '
'Species 1: [[traits: [0, [burrowing, 2]->[fat-tissue, 2]]], [fat-tissue, False->5]], '
'Player 3:removed cards: [burrowing, 2], '
'Species 0: [[fat-tissue, 0->7]], '
'Species 2: New Species: [[food, 0], [body, 0], [population, 1], [traits, []]], '
'[watering_hole, 10->0]')
# TODO deal with order being rearranged
# def test_feed1(self):
# # Auto-feeding
# self.species3.fat_storage = 3
# self.dealer1.list_of_players, self.dealer1.watering_hole = ([self.player2, self.player1, self.player3], 20)
#
# self.assertEqual([self.species5.food, self.dealer1.watering_hole], [3, 20])
# self.dealer1.feed1()
# self.assertEqual([self.species5.food, self.dealer1.watering_hole], [5, 18])
#
# # NoFeeding
# self.assertTrue(self.player2.active)
# self.dealer1.feed1()
# self.assertEqual([self.species5.food, self.dealer1.watering_hole, self.player2.active], [5, 18, False])
#
# # HerbivoreFeeding
# self.species2.traits.pop()
# self.dealer1.list_of_players = [self.player1, self.player2, self.player3]
# self.assertEqual([self.species1.food, self.species2.food, self.dealer1.watering_hole, self.player1.active],
# [0, 2, 18, True])
# self.dealer1.feed1()
# self.assertEqual([self.species1.food, self.species2.food, self.dealer1.watering_hole, self.player1.active],
# [0, 3, 17, True])
#
# # FatFeeding
# self.dealer1.list_of_players = [self.player3, self.player2, self.player1]
# self.assertEqual([self.species6.fat_storage, self.dealer1.watering_hole], [0, 17])
# self.dealer1.feed1()
# self.assertEqual([self.species6.fat_storage, self.dealer1.watering_hole], [7, 10])
#
# # CarnivoreFeeding
# self.species7.traits.append(self.carnivore)
# self.assertEqual([self.species2.population, self.species7.food, self.species6.food, self.dealer1.watering_hole],
# [6, 1, 1, 10])
# self.dealer1.feed1()
# self.assertEqual([self.species2.population, self.species7.food, self.species6.food, self.dealer1.watering_hole],
# [5, 2, 2, 8])
def test_feed_species(self):
# Regular Feeding
self.assertEqual([self.species2.food, self.dealer1.watering_hole], [2, 10])
self.dealer1.feed_species(self.species2, self.player1)
self.assertEqual([self.species2.food, self.dealer1.watering_hole], [3, 9])
# Cooperation Feeding
self.assertEqual(self.species1.food, 0)
self.dealer1.feed_species(self.species1, self.player1)
self.assertEqual([self.species1.food, self.species2.food, self.dealer1.watering_hole], [1, 4, 7])
# Foraging and Cooperation
self.species1.population, self.species1.food = (3, 0)
self.species1.traits.append(self.foraging)
self.dealer1.feed_species(self.species1, self.player1)
self.assertEqual([self.species1.food, self.species2.food, self.dealer1.watering_hole], [2, 6, 3])
# Cooperation Chain / Watering Hole runs out
self.player1.species.append(self.species5)
self.species2.food, self.species2.traits, self.dealer1.watering_hole = (4, [self.cooperation, self.foraging], 4)
self.dealer1.feed_species(self.species1, self.player1)
self.assertEqual([self.species1.food, self.species2.food, self.species5.food, self.dealer1.watering_hole],
[3, 6, 4, 0])
def test_handle_attack_situation(self):
# Regular Attack
self.assertEqual([self.species3.population, self.species3.food], [3, 3])
self.dealer1.handle_attack_situation(self.species2, self.species3, self.player1, self.player2)
self.assertEqual([self.species3.population, self.species3.food], [2, 2])
# Horns
self.assertEqual([self.species2.population, self.species7.population], [6, 7])
self.dealer1.handle_attack_situation(self.species2, self.species7, self.player1, self.player3)
self.assertEqual([self.species2.population, self.species7.population], [5, 6])
# Double Extinction
self.species2.population = 1
self.species7.population = 1
self.dealer1.deck = [self.foraging, self.scavenger, self.cooperation]
self.dealer1.handle_attack_situation(self.species2, self.species7, self.player1, self.player3)
self.assertEqual([self.species2.population, self.species7.population, self.player1.hand, self.player3.hand,
self.dealer1.deck],
[0, 0, [self.horns, self.foraging, self.cooperation],
[self.burrowing, self.foraging, self.scavenger], []])
self.assertFalse(self.species2 in self.player1.species)
self.assertFalse(self.species7 in self.player3.species)
def test_handle_scavenging(self):
# Regular
self.assertEqual([self.species6.food, self.dealer1.watering_hole], [1, 10])
self.dealer1.handle_scavenging()
self.assertEqual([self.species6.food, self.dealer1.watering_hole], [2, 9])
# Foraging
self.species6.population, self.species6.traits[0] = (6, self.foraging)
self.dealer1.handle_scavenging()
self.assertEqual([self.species6.food, self.dealer1.watering_hole], [4, 7])
# Cooperation
self.species6.traits[1] = self.cooperation
self.assertEqual([self.species6.food, self.species7.food, self.dealer1.watering_hole], [4, 1, 7])
self.dealer1.handle_scavenging()
self.assertEqual([self.species6.food, self.species7.food, self.dealer1.watering_hole], [6, 3, 3])
def test_show_changes(self):
old_dealer = copy.deepcopy(self.dealer1)
self.dealer1.feed1()
self.assertEquals(old_dealer.show_changes(self.dealer1),
'Player 1:'
'Species 0: [[food, 0->1]], '
'Species 1: [[food, 2->3]], '
'[watering_hole, 10->8]')
import pygame
from menu import *
from dealer import Dealer
for x in range(10):
dealer = Dealer()
dealer.add_player("test")
dealer.add_player("test2")
dealer.deal_cards()
for player in dealer.players:
print(player.hand)
dealer.inspect_players()
print("\n")
#windowSurface = pygame.display.set_mode((500, 400), 0, 32)
#menu = MainMenu(windowSurface)
#menu.run()
def main():
"""Main routine for Crazy Eight's"""
#create player objects and data structures
c8_dealer = Dealer()
c8_opponent = Game()
c8_opponent.add_cards(c8_dealer.deal_cards(7))
c8_player = Player()
c8_player.add_cards(c8_dealer.deal_cards(7))
#setup pygame
pygame.init()
pygame.display.set_caption("Crazy Eights!")
screen = pygame.display.set_mode((1000, 700))
screen.fill((0, 200, 0)) #set green background
#display game title on screen
font = pygame.font.Font(None, 48)
text = font.render("Crazy Eight!", 1, (10, 10, 10))
textpos = text.get_rect()
textpos.centerx = screen.get_rect().centerx
screen.blit(text, textpos)
pycards = Cards()
print("...Setup Complete. Enjoy the game!...\n")
#play game
running = True
while (c8_player.count() > 0 and c8_opponent.count() > 0 and running):
#check for quit event
for event in pygame.event.get():
if event.type == pygame.QUIT:
running == False
cardinplay = in_play(c8_dealer)
dispcard = cardinplay[1] + "of" + cardinplay[0]
#print("\nCard In Play Is:", dispcard, "\n")
pycards.carddisplay(screen, dispcard,
(470, 250)) #card in center of screen
#display user's cards
x, y = 230, 550
card_plot = dict()
for card in c8_player.hand:
dispcard = card[1] + "of" + card[0]
card_rect = pycards.carddisplay(screen, dispcard, (x, y))
x += 75
card_plot[card] = card_rect
#print(card_plot.keys())
pygame.display.flip()
#wait for user to select card on screen to play
cardselect = True
while cardselect:
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN:
x, y = event.pos
for card in card_plot:
if card_plot[card].collidepoint(x, y):
#print("you clicked", card)
cardselected = card
cardselect = False
#print("Calling player_play with",cardselected)
stat = player_play(cardselected, c8_player, c8_dealer)
if (stat == "empty"):
print("...Deck is empty. Exiting...")
#break
running = False
else:
stat = game_play(c8_opponent, c8_dealer)
if stat == "empty":
print("...Deck is empty. Exiting...")
#break
running = False
screen.fill((0, 200, 0)) #refresh background
screen.blit(text, textpos) #label
if (c8_player.count() == 0):
print("Yay! You won!")
elif (c8_opponent.count() == 0):
print("Computer won. Better luck next time!")
pygame.quit()
class TestDealer(unittest.TestCase):
def setUp(self):
# Traits (Trait, Food-value)
self.carnivore = TraitCard(CARNIVORE, 3)
self.burrowing = TraitCard(BURROWING, 2)
self.fattissue = TraitCard(FATTISSUE, 2)
self.foraging = TraitCard(FORAGING, 2)
self.horns = TraitCard(HORNS, 0)
self.cooperation = TraitCard(COOPERATION, 1)
self.scavenger = TraitCard(SCAVENGER, 2)
# Species (Population, Food, Body, Traits, Fat-Storage)
self.species1 = Species(1, 0, 2, [self.cooperation])
self.species2 = Species(6, 2, 1, [self.carnivore])
self.species3 = Species(3, 3, 3, [self.fattissue], 0)
self.species4 = Species(5, 5, 5, [self.burrowing])
self.species5 = Species(5, 3, 4, [self.foraging])
self.species6 = Species(
2, 1, 7, [self.carnivore, self.fattissue, self.scavenger], 0)
self.species7 = Species(7, 1, 6, [self.horns])
self.player1_species = [self.species1, self.species2]
self.player2_species = [self.species3, self.species4, self.species5]
self.player3_species = [self.species6, self.species7]
# Players (Name, Bag, Hand, Species)
self.player1 = PlayerState(1,
0, [self.horns, self.foraging],
self.player1_species,
ext_player=Player())
self.player2 = PlayerState(2,
3, [self.carnivore, self.fattissue],
self.player2_species,
ext_player=Player())
self.player3 = PlayerState(3,
6, [self.burrowing],
self.player3_species,
ext_player=Player())
self.public_player1 = PlayerState(1, False, False,
self.player1_species)
self.public_player2 = PlayerState(2, False, False,
self.player2_species)
self.public_player3 = PlayerState(3, False, False,
self.player3_species)
self.list_of_players = [self.player1, self.player2, self.player3]
# Dealer (List of Players, Watering Hole, Deck)
self.dealer1 = Dealer(self.list_of_players, 10, [])
# Action
self.action4_1 = Action4(FoodCardAction(1),
[GrowAction(POPULATION, 0, 0)], [], [], [])
self.action4_2 = Action4(FoodCardAction(0), [], [], [],
[ReplaceTraitAction(1, 0, 1)])
self.action4_3 = Action4(FoodCardAction(0), [], [], [], [])
self.action4_list = [self.action4_1, self.action4_2, self.action4_3]
def test_make_deck(self):
deck = Dealer.make_deck()
self.assertEqual(len(deck), LOC_MAX)
self.assertEqual(len(deck), len(set(deck)))
def test_deal_cards(self):
self.dealer1.deck = Dealer.make_deck()
self.assertEqual([len(self.dealer1.deck),
len(self.player1.hand)], [LOC_MAX, 2])
self.dealer1.deal_cards(self.player1, 10)
self.assertEqual([len(self.dealer1.deck),
len(self.player1.hand)], [LOC_MAX - 10, 12])
def test_public_players(self):
public_players = self.dealer1.public_players(self.player1)
self.assertTrue(public_players[0].equal_attributes(
self.public_player2))
self.assertTrue(public_players[1].equal_attributes(
self.public_player3))
def test_cheater(self):
dealer = Dealer.create_initial(
[Player(), Player(),
Player(), Cheater(),
Player()])
#result = dealer.run_game()
#print result
def test_step4(self):
old_dealer = copy.deepcopy(self.dealer1)
self.dealer1.step4(self.action4_list)
self.assertEqual(
old_dealer.show_changes(self.dealer1),
'Player 1: removed cards: [horns, 0], [foraging, 2], '
'Species 0: [[population, 1->2], [food, 0->2]], '
'Species 1: [[food, 2->4]], '
'Player 2: removed cards: [carnivore, 3], [fat-tissue, 2], '
'Species 0: [[fat-tissue, 0->1]], '
'Species 1: [[traits: [0, [burrowing, 2]->[fat-tissue, 2]]], [fat-tissue, False->5]], '
'Player 3: removed cards: [burrowing, 2], '
'Species 0: [[fat-tissue, 0->7]], '
'[watering_hole, 10->0]')
def test_auto_feed1(self):
# Herbivore
self.species2.food = 6
old_dealer = copy.deepcopy(self.dealer1)
self.dealer1.feed1()
self.assertEqual(
old_dealer.show_changes(self.dealer1),
'Player 1: Species 0: [[food, 0->1]], [watering_hole, 10->9]')
# Fat-tissue
self.species5.food = 5
old_dealer = copy.deepcopy(self.dealer1)
self.dealer1.feed1()
self.assertEqual(
old_dealer.show_changes(self.dealer1),
'Player 2: Species 0: [[fat-tissue, 0->3]], [watering_hole, 9->6]')
# Carnivore
self.species7.food, self.species6.fat_storage = (7, 7)
old_dealer = copy.deepcopy(self.dealer1)
self.dealer1.feed1()
self.assertEqual(
old_dealer.show_changes(self.dealer1),
'Player 3: Species 0: [[food, 1->2]], '
'Player 1: Species 1: [[population, 6->5], [food, 6->5]], '
'[watering_hole, 6->5]')
# NoFeeding
old_dealer = copy.deepcopy(self.dealer1)
self.dealer1.feed1()
self.assertEqual(old_dealer.show_changes(self.dealer1),
'Player 1: [active, True->False]')
def test_feed_species(self):
# Regular Feeding
herbivore_feeding = HerbivoreFeeding(1)
self.species2.traits = []
old_dealer = copy.deepcopy(self.dealer1)
herbivore_feeding.handle_feeding(self.dealer1, self.player1)
self.assertEqual(
old_dealer.show_changes(self.dealer1),
'Player 1: Species 1: [[food, 2->3]], '
'[watering_hole, 10->9]')
# Cooperation Feeding
old_dealer = copy.deepcopy(self.dealer1)
herbivore_feeding = HerbivoreFeeding(0)
herbivore_feeding.handle_feeding(self.dealer1, self.player1)
self.assertEqual(
old_dealer.show_changes(self.dealer1),
'Player 1: Species 0: [[food, 0->1]], Species 1: [[food, 3->4]], '
'[watering_hole, 9->7]')
# Foraging and Cooperation
self.species1.population, self.species1.food = (3, 0)
self.species1.traits.append(self.foraging)
old_dealer = copy.deepcopy(self.dealer1)
herbivore_feeding.handle_feeding(self.dealer1, self.player1)
self.assertEqual(
old_dealer.show_changes(self.dealer1),
'Player 1: Species 0: [[food, 0->2]], Species 1: [[food, 4->6]], '
'[watering_hole, 7->3]')
# Cooperation Chain / Watering Hole runs out
self.player1.species.append(self.species5)
self.player2.species.remove(self.species5)
self.species2.food, self.species2.traits, self.dealer1.watering_hole = (
4, [self.cooperation, self.foraging], 4)
old_dealer = copy.deepcopy(self.dealer1)
herbivore_feeding.handle_feeding(self.dealer1, self.player1)
self.assertEqual(
old_dealer.show_changes(self.dealer1),
'Player 1: Species 0: [[food, 2->3]], Species 1: [[food, 4->6]], Species 2: [[food, 3->4]], '
'[watering_hole, 4->0]')
def test_handle_attack_situation(self):
# Regular Attack
old_dealer = copy.deepcopy(self.dealer1)
attack_choice = CarnivoreFeeding(0, 0, 0)
attack_choice.handle_attack_situation(self.species2, self.species3,
self.player1, self.player2,
self.dealer1)
self.assertEquals(
old_dealer.show_changes(self.dealer1),
'Player 2: Species 0: [[population, 3->2], [food, 3->2]]')
# Horns
old_dealer = copy.deepcopy(self.dealer1)
attack_choice.handle_attack_situation(self.species2, self.species7,
self.player1, self.player3,
self.dealer1)
self.assertEquals(
old_dealer.show_changes(self.dealer1),
'Player 1: Species 1: [[population, 6->5]], Player 3: Species 1: [[population, 7->6]]'
)
# Double Extinction
self.species2.population = 1
self.species7.population = 1
self.dealer1.deck = [self.foraging, self.scavenger, self.cooperation]
old_dealer = copy.deepcopy(self.dealer1)
attack_choice.handle_attack_situation(self.species2, self.species7,
self.player1, self.player3,
self.dealer1)
self.assertEquals(
old_dealer.show_changes(self.dealer1),
'Player 1: new cards: [cooperation, 1], '
'Species 1: Species removed, '
'Player 3: new cards: [foraging, 2], [scavenger, 2], '
'Species 1: Species removed, '
'deck: removed cards: [foraging, 2], [scavenger, 2], [cooperation, 1]'
)
def test_handle_scavenging(self):
# Regular
old_dealer = copy.deepcopy(self.dealer1)
self.dealer1.feed_trait(SCAVENGER)
self.assertEquals(
old_dealer.show_changes(self.dealer1),
'Player 3: Species 0: [[food, 1->2]], '
'[watering_hole, 10->9]')
# Foraging
self.species6.population, self.species6.traits[0] = (6, self.foraging)
old_dealer = copy.deepcopy(self.dealer1)
self.dealer1.feed_trait(SCAVENGER)
self.assertEquals(
old_dealer.show_changes(self.dealer1),
'Player 3: Species 0: [[food, 2->4]], '
'[watering_hole, 9->7]')
# Cooperation
self.species6.traits[1] = self.cooperation
old_dealer = copy.deepcopy(self.dealer1)
self.dealer1.feed_trait(SCAVENGER)
self.assertEquals(
old_dealer.show_changes(self.dealer1),
'Player 3: Species 0: [[food, 4->6]], Species 1: [[food, 1->3]], '
'[watering_hole, 7->3]')
def test_show_changes(self):
old_dealer = copy.deepcopy(self.dealer1)
self.dealer1.feed1()
self.assertEquals(
old_dealer.show_changes(self.dealer1),
'Player 1: Species 0: [[food, 0->1]], Species 1: [[food, 2->3]], '
'[watering_hole, 10->8]')
class TestDealer(unittest.TestCase):
def setUp(self):
# Traits (Trait, Food-value)
self.carnivore = TraitCard(CARNIVORE, 3)
self.burrowing = TraitCard(BURROWING, 2)
self.fattissue = TraitCard(FATTISSUE, 4)
self.foraging = TraitCard(FORAGING, 2)
self.horns = TraitCard(HORNS, 6)
self.cooperation = TraitCard(COOPERATION, 1)
self.scavenger = TraitCard(SCAVENGER, 2)
# Species (Population, Food, Body, Traits, Fat-Storage)
self.species1 = Species(1, 0, 2, [self.cooperation])
self.species2 = Species(6, 2, 1, [self.carnivore])
self.species3 = Species(3, 3, 3, [self.fattissue], 0)
self.species4 = Species(5, 5, 5, [self.burrowing])
self.species5 = Species(5, 3, 4, [self.foraging])
self.species6 = Species(
2, 1, 7, [self.carnivore, self.fattissue, self.scavenger], 0)
self.species7 = Species(7, 1, 6, [self.horns])
self.player1_species = [self.species1, self.species2]
self.player2_species = [self.species3, self.species4, self.species5]
self.player3_species = [self.species6, self.species7]
# Players (Name, Bag, Hand, Species)
self.player1 = PlayerState(1, 0, [], self.player1_species)
self.player2 = PlayerState(2, 3, [self.carnivore, self.fattissue],
self.player2_species)
self.player3 = PlayerState(3, 6, [self.burrowing],
self.player3_species)
self.public_player1 = PlayerState(1, False, False,
self.player1_species)
self.public_player2 = PlayerState(2, False, False,
self.player2_species)
self.public_player3 = PlayerState(3, False, False,
self.player3_species)
self.list_of_players = [self.player1, self.player2, self.player3]
# Dealer (List of Players, Watering Hole, Deck)
self.dealer1 = Dealer(self.list_of_players, 10, [])
def test_make_deck(self):
deck = Dealer.make_deck()
self.assertEqual(len(deck), LOC_MAX)
self.assertEqual(len(deck), len(set(deck)))
def test_deal_cards(self):
self.dealer1.deck = Dealer.make_deck()
self.assertEqual([len(self.dealer1.deck),
len(self.player1.hand)], [LOC_MAX, 0])
self.dealer1.deal_cards(self.player1, 10)
self.assertEqual([len(self.dealer1.deck),
len(self.player1.hand)], [LOC_MAX - 10, 10])
def test_public_players(self):
public_players = self.dealer1.public_players(self.player1)
self.assertTrue(public_players[0].equal_attributes(
self.public_player2))
self.assertTrue(public_players[1].equal_attributes(
self.public_player3))
def test_feed1(self):
# Auto-feeding
self.species3.fat_storage = 3
self.dealer1.list_of_players, self.dealer1.watering_hole = ([
self.player2, self.player1, self.player3
], 20)
self.assertEqual([self.species5.food, self.dealer1.watering_hole],
[3, 20])
self.dealer1.feed1()
self.assertEqual([self.species5.food, self.dealer1.watering_hole],
[5, 18])
# NoFeeding
self.assertTrue(self.player2.active)
self.dealer1.feed1()
self.assertEqual([
self.species5.food, self.dealer1.watering_hole, self.player2.active
], [5, 18, False])
# HerbivoreFeeding
self.species2.traits.pop()
self.dealer1.list_of_players = [
self.player1, self.player2, self.player3
]
self.assertEqual([
self.species1.food, self.species2.food, self.dealer1.watering_hole,
self.player1.active
], [0, 2, 18, True])
self.dealer1.feed1()
self.assertEqual([
self.species1.food, self.species2.food, self.dealer1.watering_hole,
self.player1.active
], [0, 3, 17, True])
# FatFeeding
self.dealer1.list_of_players = [
self.player3, self.player2, self.player1
]
self.assertEqual(
[self.species6.fat_storage, self.dealer1.watering_hole], [0, 17])
self.dealer1.feed1()
self.assertEqual(
[self.species6.fat_storage, self.dealer1.watering_hole], [7, 10])
# CarnivoreFeeding
self.species7.traits.append(self.carnivore)
self.assertEqual([
self.species2.population, self.species7.food, self.species6.food,
self.dealer1.watering_hole
], [6, 1, 1, 10])
self.dealer1.feed1()
self.assertEqual([
self.species2.population, self.species7.food, self.species6.food,
self.dealer1.watering_hole
], [5, 2, 2, 8])
def test_feed_species(self):
# Regular Feeding
self.assertEqual([self.species2.food, self.dealer1.watering_hole],
[2, 10])
self.dealer1.feed_species(self.species2, self.player1)
self.assertEqual([self.species2.food, self.dealer1.watering_hole],
[3, 9])
# Cooperation Feeding
self.assertEqual(self.species1.food, 0)
self.dealer1.feed_species(self.species1, self.player1)
self.assertEqual([
self.species1.food, self.species2.food, self.dealer1.watering_hole
], [1, 4, 7])
# Foraging and Cooperation
self.species1.population, self.species1.food = (3, 0)
self.species1.traits.append(self.foraging)
self.dealer1.feed_species(self.species1, self.player1)
self.assertEqual([
self.species1.food, self.species2.food, self.dealer1.watering_hole
], [2, 6, 3])
# Cooperation Chain / Watering Hole runs out
self.player1.species.append(self.species5)
self.species2.food, self.species2.traits, self.dealer1.watering_hole = (
4, [self.cooperation, self.foraging], 4)
self.dealer1.feed_species(self.species1, self.player1)
self.assertEqual([
self.species1.food, self.species2.food, self.species5.food,
self.dealer1.watering_hole
], [3, 6, 4, 0])
def test_handle_attack_situation(self):
# Regular Attack
self.assertEqual([self.species3.population, self.species3.food],
[3, 3])
self.dealer1.handle_attack_situation(self.species2, self.species3,
self.player1, self.player2)
self.assertEqual([self.species3.population, self.species3.food],
[2, 2])
# Horns
self.assertEqual([self.species2.population, self.species7.population],
[6, 7])
self.dealer1.handle_attack_situation(self.species2, self.species7,
self.player1, self.player3)
self.assertEqual([self.species2.population, self.species7.population],
[5, 6])
# Double Extinction
self.species2.population = 1
self.species7.population = 1
self.dealer1.deck = [self.foraging, self.scavenger, self.cooperation]
self.dealer1.handle_attack_situation(self.species2, self.species7,
self.player1, self.player3)
self.assertEqual([
self.species2.population, self.species7.population,
self.player1.hand, self.player3.hand, self.dealer1.deck
], [
0, 0, [self.cooperation],
[self.burrowing, self.foraging, self.scavenger], []
])
self.assertFalse(self.species2 in self.player1.species)
self.assertFalse(self.species7 in self.player3.species)
def test_handle_scavenging(self):
# Regular
self.assertEqual([self.species6.food, self.dealer1.watering_hole],
[1, 10])
self.dealer1.handle_scavenging()
self.assertEqual([self.species6.food, self.dealer1.watering_hole],
[2, 9])
# Foraging
self.species6.population, self.species6.traits[0] = (6, self.foraging)
self.dealer1.handle_scavenging()
self.assertEqual([self.species6.food, self.dealer1.watering_hole],
[4, 7])
# Cooperation
self.species6.traits[1] = self.cooperation
self.assertEqual([
self.species6.food, self.species7.food, self.dealer1.watering_hole
], [4, 1, 7])
self.dealer1.handle_scavenging()
self.assertEqual([
self.species6.food, self.species7.food, self.dealer1.watering_hole
], [6, 3, 3])
