386 lines
13 KiB
Python
386 lines
13 KiB
Python
"""
|
|
This module contains the Card class and the Deck class
|
|
Card contains the information of a playing card
|
|
Deck is used as a Card container
|
|
"""
|
|
import pygame
|
|
import view
|
|
import os
|
|
import random
|
|
from enum import Enum
|
|
|
|
# LUT for mapping int to cards symbols
|
|
CARDS_SYMBOLS = {14: "A", 2: "2", 3: "3", 4: "4", 5: "5", 6: "6", 7: "7",
|
|
8: "8", 9: "9", 10: "10", 11: "J", 12: "Q", 13: "K",
|
|
100: "Clubs", 200: "Diamonds", 300: "Hearts", 400: "Spades", 500: "No Trump",
|
|
}
|
|
|
|
INPUT_SYMBOLS = {"c": 100, "d": 200, "h": 300, "s": 400, "n":500, "a": 14,
|
|
"2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7,
|
|
"8": 8, "9": 9, "10": 10, "j": 11, "q": 12, "k": 13,
|
|
}
|
|
|
|
class DeckReveal(Enum):
|
|
SHOW_ALL = 1
|
|
HIDE_ALL = 2
|
|
ANY = 3
|
|
|
|
|
|
class DeckSort(Enum):
|
|
ASCENDING = 1
|
|
DESCENDING = 2
|
|
NOSORT = 3
|
|
|
|
|
|
class Card(pygame.sprite.Sprite):
|
|
|
|
def __init__(self, x, y, width, height, value, hidden=False, image_data=None, parent=None):
|
|
super().__init__()
|
|
self.x = x
|
|
self.y = y
|
|
|
|
self.width = width
|
|
self.height = height
|
|
|
|
self.value = value
|
|
self.hidden = hidden
|
|
self.parent = parent
|
|
|
|
if image_data:
|
|
self.image = image_data
|
|
self.image = pygame.transform.scale(self.image, (self.width, self.height))
|
|
|
|
# Display Value for Debug Purposes
|
|
#myfont = pygame.font.SysFont("None", 16)
|
|
#mytext = myfont.render(str(self.value), True, (0, 0, 0))
|
|
#mytext = mytext.convert_alpha()
|
|
#self.image.blit(mytext, (0, 0))
|
|
|
|
self._layer = 0
|
|
|
|
def get_pos(self):
|
|
return self.x, self.y
|
|
|
|
def suit(self):
|
|
return get_card_suit(self.value)
|
|
|
|
def number(self):
|
|
return get_card_number(self.value)
|
|
|
|
def value_info(self):
|
|
return self.suit(), self.number()
|
|
|
|
|
|
class Deck():
|
|
|
|
def __init__(self, x, y, length, width, spacing, deck_reveal=DeckReveal.SHOW_ALL,
|
|
sort_order=DeckSort.ASCENDING, vert_orientation=False, draw_from_last=False):
|
|
super().__init__()
|
|
self.x = x
|
|
self.y = y
|
|
|
|
self.length = length
|
|
self.width = width
|
|
self.default_spacing = spacing
|
|
|
|
self.deck_reveal = deck_reveal
|
|
self.vert_orientation = vert_orientation
|
|
self.draw_from_last = draw_from_last
|
|
self.sort_order = sort_order
|
|
|
|
self.cards = []
|
|
|
|
if self.is_horizontal():
|
|
self.background = pygame.Surface((self.length, self.width))
|
|
self.background.fill((0, 255, 0))
|
|
pygame.draw.rect(self.background, (255, 255, 255), self.background.get_rect(), 5)
|
|
|
|
self.background = self.background.convert()
|
|
self.background.set_colorkey((0, 255, 0))
|
|
self.deck_surface = self.background.copy()
|
|
else:
|
|
self.background = pygame.Surface((self.width, self.length))
|
|
self.background.fill((0, 255, 0))
|
|
pygame.draw.rect(self.background, (255, 255, 255), self.background.get_rect(), 5)
|
|
self.background = self.background.convert()
|
|
self.background.set_colorkey((0, 255, 0))
|
|
self.deck_surface = self.background.copy()
|
|
|
|
self._layer = 1
|
|
|
|
def add_card(self, card, position=0):
|
|
# TODO: Add a function to add additional cards, to optimise number of recalculations
|
|
card.parent = self
|
|
number_of_cards = len(self.cards)
|
|
|
|
if number_of_cards == 0:
|
|
self.cards.append(card)
|
|
else:
|
|
if self.sort_order == DeckSort.NOSORT:
|
|
self.cards.insert(position, card)
|
|
else:
|
|
if self.sort_order == DeckSort.DESCENDING:
|
|
self.cards.reverse()
|
|
|
|
if card.value < self.cards[0].value:
|
|
self.cards.insert(0, card)
|
|
elif card.value > self.cards[-1].value:
|
|
self.cards.append(card)
|
|
else:
|
|
lo = 0
|
|
hi = number_of_cards
|
|
|
|
while abs(lo-hi) != 1:
|
|
pos = (lo + hi) // 2
|
|
if card.value > self.cards[pos].value:
|
|
lo = pos
|
|
else:
|
|
hi = pos
|
|
|
|
self.cards.insert(hi, card)
|
|
|
|
if self.sort_order == DeckSort.DESCENDING:
|
|
self.cards.reverse()
|
|
|
|
self.set_card_positions()
|
|
|
|
def set_card_positions(self):
|
|
# TODO: Fix vertical card positioning
|
|
number_of_cards = len(self.cards)
|
|
|
|
if number_of_cards > 0:
|
|
if self.is_horizontal():
|
|
total_card_length = self.cards[0].width + self.default_spacing * (number_of_cards-1)
|
|
if total_card_length <= self.length:
|
|
start_point = (self.length - total_card_length)/2
|
|
for (i, card) in enumerate(self.cards):
|
|
card.x = start_point + self.default_spacing * i
|
|
card.y = (self.width - self.cards[0].height) / 2
|
|
else:
|
|
# TODO: make sure that deck length is always longer than card width
|
|
adjusted_spacing = (self.length - self.cards[0].width)/(number_of_cards-1)
|
|
|
|
start_point = 0
|
|
for (i, card) in enumerate(self.cards):
|
|
card.x = start_point + adjusted_spacing * i
|
|
card.y = (self.width - self.cards[0].height) / 2
|
|
else:
|
|
total_card_length = self.cards[0].height + self.default_spacing * (number_of_cards-1)
|
|
if total_card_length <= self.length:
|
|
start_point = (self.length - total_card_length)/2
|
|
for (i, card) in enumerate(self.cards):
|
|
card.y = start_point + self.default_spacing * (i-1)
|
|
card.x = (self.width - self.cards[0].width) / 2
|
|
else:
|
|
adjusted_spacing = (self.length - self.cards[0].height)/(number_of_cards-1)
|
|
|
|
start_point = 0
|
|
for (i, card) in enumerate(self.cards):
|
|
card.y = start_point + adjusted_spacing * i
|
|
card.x = (self.width - self.cards[0].width)/ 2
|
|
|
|
self.update_deck_display()
|
|
|
|
def update_deck_display(self):
|
|
self.deck_surface.fill((0, 255, 0))
|
|
self.deck_surface.blit(self.background, (0, 0))
|
|
if not self.is_empty():
|
|
if self.draw_from_last:
|
|
for card in reversed(self.cards):
|
|
self.deck_surface.blit(card.image, (card.x, card.y))
|
|
else:
|
|
for card in self.cards:
|
|
self.deck_surface.blit(card.image, (card.x, card.y))
|
|
|
|
def remove_card(self, pos=-1):
|
|
if not self.is_empty():
|
|
if pos < 0:
|
|
card = self.cards.pop()
|
|
else:
|
|
card = self.cards.pop(pos)
|
|
self.set_card_positions()
|
|
return card
|
|
return None
|
|
|
|
def is_horizontal(self):
|
|
return not self.vert_orientation
|
|
|
|
def is_empty(self):
|
|
return len(self.cards) == 0
|
|
|
|
def get_pos(self):
|
|
return self.x, self.y
|
|
|
|
def get_deck_values(self):
|
|
values = []
|
|
for card in self.cards:
|
|
values.append(card.value)
|
|
return values
|
|
|
|
def check_card_in(self, value):
|
|
card_values = self.get_deck_values()
|
|
if value in card_values:
|
|
return True, card_values.index(value)
|
|
return False, -1
|
|
|
|
|
|
class SpriteSheet(object):
|
|
def __init__(self, filename):
|
|
try:
|
|
self.sheet = pygame.image.load(filename).convert()
|
|
except pygame.error:
|
|
print('Unable to load spritesheet image:', filename)
|
|
raise Exception("Cannot load image")
|
|
|
|
# Load a specific image from a specific rectangle
|
|
def image_at(self, rectangle, colorkey=None):
|
|
"Loads image from x,y,x+offset,y+offset"
|
|
rect = pygame.Rect(rectangle)
|
|
image = pygame.Surface(rect.size).convert()
|
|
image.blit(self.sheet, (0, 0), rect)
|
|
if colorkey is not None:
|
|
if colorkey is -1:
|
|
colorkey = image.get_at((0, 0))
|
|
image.set_colorkey(colorkey, pygame.RLEACCEL)
|
|
return image
|
|
# Load a whole bunch of images and return them as a list
|
|
def images_at(self, rects, colorkey = None):
|
|
"Loads multiple images, supply a list of coordinates"
|
|
return [self.image_at(rect, colorkey) for rect in rects]
|
|
# Load a whole strip of images
|
|
def load_strip(self, rect, image_count, colorkey = None):
|
|
"Loads a strip of images and returns them as a list"
|
|
tups = [(rect[0]+rect[2]*x, rect[1], rect[2], rect[3])
|
|
for x in range(image_count)]
|
|
return self.images_at(tups, colorkey)
|
|
|
|
class PlayerDeck(Deck):
|
|
# TODO: Maybe merge with Regular Deck
|
|
def get_selected_card(self, pos):
|
|
# TODO: convert pos to card num, deselect if no card is clicked or out of range
|
|
|
|
# TODO: check if card num is selected, set selected, otherwise use it (by removing)
|
|
pass
|
|
|
|
|
|
DATA_FOLDER = "data"
|
|
|
|
|
|
def prepare_playing_cards(display_w, display_h):
|
|
"""
|
|
Create the 52 playing cards. Should be called only once.
|
|
:param int display_w: Card width
|
|
:param int display_h: Card Height
|
|
:return: The list of 52 Cards
|
|
:rtype: List of <Cards>
|
|
"""
|
|
#try: # try to load images from the harddisk
|
|
# card_img = pygame.image.load(os.path.join(DATA_FOLDER, 'diamond.jpg'))
|
|
#except:
|
|
# raise Exception("Cannot load image") # print error message and exit program
|
|
card_sprites = SpriteSheet(os.path.join(DATA_FOLDER, 'card_spritesheet_2.png'))
|
|
all_cards = []
|
|
offset = 4
|
|
spacing = 7
|
|
width = 118
|
|
height = 174
|
|
suits_position = [2, 1, 0, 3]
|
|
for i in range(4):
|
|
y = suits_position[i] * (height+spacing) + offset
|
|
for j in range(13):
|
|
x = offset + (width+spacing)*j
|
|
card_img = card_sprites.image_at((x, y, width, height))
|
|
all_cards.append(Card(0, 0, display_w, display_h, (i+1)*100 + j+2, image_data=card_img))
|
|
|
|
return all_cards
|
|
|
|
|
|
def card_check(value):
|
|
return 1 <= get_card_suit(value) <= 4 \
|
|
and 2 <= get_card_number(value) <= 14
|
|
|
|
|
|
def get_card_suit(value):
|
|
return value // 100
|
|
|
|
|
|
def get_card_number(value):
|
|
return value % 100
|
|
|
|
|
|
def get_card_string(value):
|
|
suit = get_card_suit(value) * 100
|
|
num = get_card_number(value)
|
|
return CARDS_SYMBOLS[num] + ' ' + CARDS_SYMBOLS[suit]
|
|
|
|
|
|
def get_suit_string(value):
|
|
return CARDS_SYMBOLS[value*100]
|
|
|
|
|
|
def convert_input_string(string):
|
|
try:
|
|
return INPUT_SYMBOLS[string[0:-1]] + INPUT_SYMBOLS[string[-1]]
|
|
except KeyError:
|
|
return -1
|
|
|
|
|
|
def convert_bid_string(string):
|
|
try:
|
|
return int(string[0])*10 + INPUT_SYMBOLS[string[1]]//100
|
|
except KeyError:
|
|
return -1
|
|
except ValueError:
|
|
return -1
|
|
|
|
class test_screen(view.PygView):
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
|
|
all_cards = prepare_playing_cards(50, 75)
|
|
self.test_deck = Deck(100, 100, 200, 100, 25)
|
|
self.test_deck.add_card(all_cards[0])
|
|
self.test_deck.add_card(all_cards[13])
|
|
self.test_deck.add_card(all_cards[35])
|
|
self.test_deck.add_card(all_cards[51])
|
|
|
|
def draw_function(self):
|
|
#self.screen.blit(self.test_card.image, self.test_card.get_pos())
|
|
self.screen.blit(self.test_deck.deck_surface, self.test_deck.get_pos())
|
|
|
|
def run(self):
|
|
running = True
|
|
while running:
|
|
for event in pygame.event.get():
|
|
if event.type == pygame.QUIT:
|
|
running = False
|
|
elif event.type == pygame.KEYDOWN:
|
|
if event.key == pygame.K_ESCAPE:
|
|
running = False
|
|
if event.key == pygame.K_r:
|
|
card = self.test_deck.remove_card()
|
|
del card
|
|
print('remove cards')
|
|
|
|
if event.key == pygame.K_a:
|
|
self.test_deck.add_card(Card(50, 0, 50, 75, random.randint(1, 500), image_data=self.card_img))
|
|
print('remove cards')
|
|
pass
|
|
|
|
milliseconds = self.clock.tick(self.fps)
|
|
#self.playtime += milliseconds / 1000.0
|
|
|
|
self.draw_function()
|
|
|
|
pygame.display.flip()
|
|
self.screen.blit(self.background, (0, 0))
|
|
|
|
pygame.quit()
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
test_view = test_screen(640, 400, clear_colour=(0, 0, 0))
|
|
test_view.run()
|