def make_AI_basic(deck, AI_name, mem_depth=0):
"""
Simple AI creation function that allows for the creation of a simple
"flash frame decision" low memory style AI.
Returns: AI_player_gen: a simple generated AI
"""
AI_player_gen = game_classes.Player(AI_name)
AI_player_gen.grab_cards(deck, 7)
AI_player_gen.AI = True
AI_player_gen.Main_Decision_Tree = Main_Decision_Tree.Main_Decision_Tree(AI_name)
AI_player_gen.Card_Guess_Tree = Card_Guess_Tree.Card_Guess_Tree(AI_name, mem_depth)
AI_player_gen.Card_Choose_Tree = Card_Choose_Tree.Card_Choose_Tree(AI_name)
return AI_player_gen
def test_Main_Decision_Tree_2():
"""
Test function that tests the basic capabilites of a Main_Decision_Tree
going over feature such as creating a Main_Decision_Tree, and deciding a
player decision based on board state.
"""
test_tree = Main_Decision_Tree("test")
test_board = game_classes.Board("board_test")
deck1 = gen_rand_deck("deck_test", 0)
player1 = game_classes.Player("player_1")
player1.grab_cards(deck1, 8)
player2AI = game_classes.Player("player_2AI")
player2AI.grab_cards(deck1, 1)
player3AI = game_classes.Player("player_3AI")
player3AI.grab_cards(deck1, 7)
player4AI = game_classes.Player("player_4AI")
player4AI.grab_cards(deck1, 7)
player5AI = game_classes.Player("player_5AI")
player5AI.grab_cards(deck1, 7)
player6AI = game_classes.Player("player_6AI")
player6AI.grab_cards(deck1, 7)
player7AI = game_classes.Player("player_7AI")
player7AI.grab_cards(deck1, 7)
player1.Main_Decision_Tree = test_tree
player1.Card_Choose_Tree = Card_Choose_Tree.Card_Choose_Tree("test")
for i in range(len(player1.hand)):
print(player1.hand[i].name)
player1.hand[i].old_val = i
test_player = player1
test_players = [
player1, player2AI, player3AI, player4AI, player5AI, player6AI,
player7AI
]
travel_Main_Decision_Tree(test_board, deck1, test_player, test_players,
test_tree.Dec_Tree)
print(test_board.card_stack[-1].name)
def test_Card_Choose_Tree():
"""
Test function that tests the basic capabilites of a Card_Choose_Tree
going over feature such as creating a Card_Choose_Tree, and deciding a
card decision based on board state (thus traveling the tree itself).
"""
test_tree = Card_Choose_Tree("test")
test_board = game_classes.Board("board_test")
deck1 = gen_rand_deck("deck_test", 0)
player1 = game_classes.Player("player_1")
player1.grab_cards(deck1, 7)
player2AI = game_classes.Player("player_2AI")
player2AI.grab_cards(deck1, 7)
player3AI = game_classes.Player("player_3AI")
player3AI.grab_cards(deck1, 7)
player4AI = game_classes.Player("player_4AI")
player4AI.grab_cards(deck1, 7)
player5AI = game_classes.Player("player_5AI")
player5AI.grab_cards(deck1, 7)
player6AI = game_classes.Player("player_6AI")
player6AI.grab_cards(deck1, 7)
player7AI = game_classes.Player("player_7AI")
player7AI.grab_cards(deck1, 7)
test_player = player1
test_players = [
player1, player2AI, player3AI, player4AI, player5AI, player6AI,
player7AI
]
travel_Card_Choose_Tree(test_board, test_player, test_players,
test_tree.Choose_Tree)
def new_player():
data = request.json
response = dict()
response['status'] = 'invalid'
if data is not None:
aid = data.get('aid', None)
username = data.get('username', None)
if aid is not None and username is not None:
new_corp = game_classes.Corporation()
if config.developing:
new_corp.gain_ore(5000)
else:
new_corp.gain_ore(205)
corporations[new_corp.corp_id] = new_corp
player = game_classes.Player()
player.assign_corp(new_corp)
player.assign_aid(aid)
player.assign_username(username)
players[player.uid] = player
spawn_player(player.uid)
response['id'] = player.uid
response['status'] = 'valid'
return home_cor(jsonify(**response))
"You brandish your kitchen knife with skill and attack your opponent", 7)
axe = game_classes.Weapon(
'axe', 18, "You brandish your axe with skill and attack your opponent", 10)
scalpel = game_classes.Weapon(
'scalpel', 20,
"You brandish your scalpel with skill and attack your opponent", 12)
rifle = game_classes.Weapon(
'blaster rifle', 30,
"You let loose with your blaster rifle, firing off several devestatng rounds that are sure to ruin someones day",
20)
suit = game_classes.Weapon(
'Exo-Suit', 50,
"Your Exo-Suit whirs to life and supplies power to your devestating blows",
200)
hero = game_classes.Player(health=100, armed=fists, base_weapon=fists)
kevin = game_classes.Beetle('Red Specks', 30, 8, 101, None)
dave = game_classes.Beetle('Blue Bars', 20, 9, 101, None)
shawn = game_classes.Beetle('No-Wings', 35, 5, 101, None)
gus = game_classes.Beetle('3-Arms', 15, 4, 51, None)
lassie = game_classes.Beetle('Sneak', 30, 8, 101, None)
jim = game_classes.Beetle('White Eyes', 25, 10, 201, None)
paul = game_classes.Beetle('Red Stripes', 30, 8, 101, None)
john = game_classes.Beetle('Green Marks', 30, 8, 101, None)
george = game_classes.Beetle('Black Stripes', 30, 8, 101, None)
ringo = game_classes.Beetle('The Small One', 40, 10, 101, None)
ben = game_classes.Beetle('Hairy', 30, 8, 101, None)
chris = game_classes.Beetle('Blue Specks', 30, 8, 101, None)
BBEG = game_classes.Beetle('The Warlord', 100, 15, 51, None)
import display_funct
import game_AI
import game_classes
import game_logic
# loop for allowing multiple games to be restarted
while True:
# initilizing the board to be used within the game
board1 = game_classes.Board("board1")
# initilizing a deck to be used within the game (3 copies are added to
# each other)
deck1 = gen_rand_deck("deck1", 0)
# defining a 7 player uno game
player1 = game_classes.Player("player_1")
player1.grab_cards(deck1, 7)
player2AI = game_AI.make_AI_basic(deck1, "player_2AI", 7)
player3AI = game_AI.make_AI_basic(deck1, "player_3AI", 7)
player4AI = game_AI.make_AI_basic(deck1, "player_4AI", 7)
player5AI = game_AI.make_AI_basic(deck1, "player_5AI", 7)
player6AI = game_AI.make_AI_basic(deck1, "player_6AI", 7)
player7AI = game_AI.make_AI_basic(deck1, "player_7AI", 7)
display_funct.redraw_hand_visble(player1, None)
# enters into playing the game
game_logic.game_loop(board1, deck1, [player1, player2AI, player3AI, player4AI,
player5AI, player6AI, player7AI])
def GameMode():
# Reset screen
screen.fill(pygame.Color("forestgreen"))
pygame.display.flip()
# Buttons for menu
menu_space = pygame.draw.rect(screen, pygame.Color("grey"),
[0, 480, 960, 60])
canasta_button = game_classes.Button_Hover("Canasta", (80, 510), screen,
"center")
draw_button = game_classes.Button_Hover("Draw 2", (240, 510), screen,
"center")
pile_button = game_classes.Button_Hover("Take pile", (400, 510), screen,
"center")
discard_button = game_classes.Button_Hover("Discard", (560, 510), screen,
"center")
rules_button = game_classes.Button_Hover("Rules", (720, 510), screen,
"center")
quit_button = game_classes.Button_Hover("QUIT", (880, 510), screen,
"center")
# Buttons to see other players
pygame.draw.circle(screen, pygame.Color("grey"), [100, 0], 100)
pygame.draw.circle(screen, pygame.Color("grey"), [480, 0], 100)
pygame.draw.circle(screen, pygame.Color("grey"), [860, 0], 100)
player2_button = game_classes.Button_Hover("Player 1", (100, 0), screen,
"midtop")
player3_button = game_classes.Button_Hover("Player 2", (480, 0), screen,
"midtop")
player4_button = game_classes.Button_Hover("Player 3", (860, 0), screen,
"midtop")
font = pygame.font.Font(None, 40)
player1_display = font.render("H", True, pygame.Color("black"))
screen.blit(player1_display, player1_display.get_rect(center=(100, 60)))
player2_display = font.render("H", True, pygame.Color("black"))
screen.blit(player2_display, player2_display.get_rect(center=(480, 60)))
player3_display = font.render("H", True, pygame.Color("black"))
screen.blit(player3_display, player3_display.get_rect(center=(860, 60)))
# GameMode Loop
done = False
canasta_on_screen = False
i = 0
deck = game_classes.Deck()
deck.shuffle()
# Creating players
player1 = game_classes.Player(deck)
player2 = game_classes.Player(deck)
player3 = game_classes.Player(deck)
player4 = game_classes.Player(deck)
# Starting positions for the players cards
hf_x_start, hf_y_start, x_overlap_dist = 80, 370, 30
card_height, card_width = 90, 60
display_hand(player1)
# Starting positions for thr canastas cards
c_x_start, c_y_start, y_shift = 25, 150, 15
# Drawing the starting deck card back
card = pygame.image.load("res/img/cards/red_back.png").convert()
card = pygame.transform.scale(card, (card_width, card_height))
screen.blit(card, [640, 25])
# Where the pile will be drawn when it is created
screen.blit(card, [260, 25])
prev_time = time.time()
while not done:
click = pygame.mouse.get_pressed()
pygame.time.wait(5)
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
pygame.quit()
sys.exit()
if event.type == pygame.MOUSEBUTTONUP:
pos = pygame.mouse.get_pos()
# Checks for clicking on cards in the hand and if it detects it, will toggle the selected attribute of the card and re-draw the hand
if (pos[1] <
(hf_y_start + card_height)) and (pos[1] > hf_y_start):
if (pos[0] > hf_x_start) and (
pos[0] <
(x_overlap_dist * len(player1.get_hand())) +
hf_x_start + x_overlap_dist):
card_pos = pos[0] - hf_x_start
card_pos = int(card_pos / x_overlap_dist)
if card_pos > len(player1.get_hand()) - 1:
card_pos -= 1
player1.get_hand()[card_pos].toggle_selected()
display_hand(player1)
# Checks for clicking on canasta's, and if it detects it, will attempt to add any selected cards to that canasta
if (pos[0] > c_x_start and pos[0] <
card_width * len(player1.get_canastas()) + c_x_start
and pos[1] > c_y_start):
index = int((pos[0] - c_x_start) / card_width)
# Statement checks whether the stack has been squished or not
if (len(player1.get_canastas()) * y_shift + 60 > 200):
y_shift = (200 - 60) / (len(player1.get_canastas()))
# Checks that the mouse button up was detected on a y position that has cards on it, and if so, attempts to add cards
if (pos[1] <
(len(player1.get_canastas()[index]) - 1) * y_shift +
c_y_start + card_height):
player1.add_to_canasta(index)
display_canasta(player1)
display_hand(player1)
y_shift = 15
# Check for hover for menu
canasta_button.check_hover(screen)
draw_button.check_hover(screen)
pile_button.check_hover(screen)
discard_button.check_hover(screen)
rules_button.check_hover(screen)
quit_button.check_hover(screen)
player2_button.check_hover(screen)
# Check hover for players
if player2_button.hovered == True and i == 0:
# print ("hover 1")
# player1_hand = False
# pygame.draw.circle(screen, pygame.Color("grey"), [100, 0], 100)
overlay = pygame.Rect(10, 10,
(card_width * len(player2.hand) / 2) +
x_overlap_dist + 40, card_height + 40)
overlay.center = (screen.get_width() / 2,
(screen.get_height() / 2) - 50)
pygame.draw.rect(screen, pygame.Color("grey"), overlay)
display_on_hover(player2, overlay)
pygame.display.flip()
reset_overlay = pygame.Rect(10, 10,
(card_width * len(player2.hand) / 2) +
x_overlap_dist + 40, card_height + 40)
reset_overlay.center = (screen.get_width() / 2,
(screen.get_height() / 2) - 50)
player2_button = game_classes.Button_Hover("Player 1", (100, 0),
screen, "midtop")
player2_button.check_hover(screen)
i += 1
elif player2_button.hovered == False and canasta_on_screen and i > 0:
i = 0
pygame.draw.rect(screen, pygame.Color("gold"), (20, 140, 920, 200))
display_canasta(player1)
elif player2_button.hovered == False and not canasta_on_screen:
i = 0
reset_overlay = pygame.Rect(10, 10,
(card_width * len(player2.hand) / 2) +
x_overlap_dist + 40, card_height + 40)
reset_overlay.center = (screen.get_width() / 2,
(screen.get_height() / 2) - 50)
pygame.draw.rect(screen, pygame.Color("forestgreen"),
reset_overlay)
player3_button.check_hover(screen)
if player3_button.hovered == True:
# print ("hover 2")
pass
player4_button.check_hover(screen)
if player4_button.hovered == True:
# print ("hover 3")
pass
# See if button was clicked in the menu
# call make_canasta(cards) with the cards being an array of selected cards
if canasta_button.rect.collidepoint(
pygame.mouse.get_pos()) and click[0]:
selected_cards = player1.get_selected_cards()
if player1.make_canasta(selected_cards):
canasta_on_screen = True
for pos in range(len(selected_cards)):
player1.remove_card(selected_cards[pos])
print(player1.get_canastas())
display_canasta(player1)
display_hand(player1)
canasta_on_screen = True
if draw_button.rect.collidepoint(pygame.mouse.get_pos()) and click[0]:
print("draw 2")
player1.add_card(deck.get_card())
player1.add_card(deck.get_card())
display_hand(player1)
if pile_button.rect.collidepoint(pygame.mouse.get_pos()) and click[0]:
# print("pile")
pass
if discard_button.rect.collidepoint(
pygame.mouse.get_pos()) and click[0]:
print("discard")
temp_discard_deck = player1.get_selected_cards()
if (len(temp_discard_deck) != 1): # Unclear discard
print(temp_discard_deck)
print("Incorrect number of cards")
else: # Clear Discard
print(temp_discard_deck)
print("Correct number of cards")
player1.remove_card(temp_discard_deck[0])
player2.take_turn()
display_hand(player1)
if rules_button.rect.collidepoint(pygame.mouse.get_pos()) and click[0]:
# print("rules")
pass
if quit_button.rect.collidepoint(pygame.mouse.get_pos()) and click[0]:
done = True
# Check if players are in hand or foot
if not player1.on_hand():
player1_display = font.render("F", True, pygame.Color("black"))
screen.blit(player1_display,
player1_display.get_rect(center=(100, 60)))
if not player2.on_hand():
player2_display = font.render("F", True, pygame.Color("black"))
screen.blit(player2_display,
player2_display.get_rect(center=(100, 60)))
if not player3.on_hand():
player3_display = font.render("F", True, pygame.Color("black"))
screen.blit(player3_display,
player3_display.get_rect(center=(100, 60)))
pygame.display.flip()
pygame.display.update()
curr_time = time.time() # so now we have time after processing
diff = curr_time - prev_time # frame took this much time to process and render
delay = max(
1.0 / target_fps - diff, 0
) # if we finished early, wait the remaining time to desired fps, else wait 0 ms!
time.sleep(delay)
fps = 1.0 / (
delay + diff
) # fps is based on total time ("processing" diff time + "wasted" delay time)
prev_time = curr_time
pygame.display.set_caption("{0}: {1:.2f}".format(title, fps))