451 lines
16 KiB
Python
451 lines
16 KiB
Python
# TODO: The bar is just for show at the moment. Home doesn't work either.
|
|
# TODO: An issue with the bouncing back things. It appears to do the move and then
|
|
# it doesn't properly restore the buckets to where they should be.
|
|
|
|
import random
|
|
import pygame
|
|
import threading
|
|
from board import Board
|
|
import numpy as np
|
|
import time
|
|
|
|
# --- constants --- (UPPER_CASE names)
|
|
|
|
|
|
|
|
class Board_painter:
|
|
|
|
def __init__(self):
|
|
self.SCREEN_WIDTH = 1050
|
|
self.SCREEN_HEIGHT = 400
|
|
|
|
self.SPACING = 83.333
|
|
|
|
|
|
#BLACK = ( 0, 0, 0)
|
|
#242 209 107
|
|
self.SAND = (242, 209, 107)
|
|
self.GREEN_FILT = (0,102,0)
|
|
self.WHITE = (255, 255, 255)
|
|
self.RED = (255, 0, 0)
|
|
self.SALMON = (250,128,114)
|
|
self.BLACK = (0,0,0)
|
|
self.BROWN = (160,82,45)
|
|
self.LIGHT_GREY = (220,220,220)
|
|
self.num_pieces = 15
|
|
self.FPS = 999
|
|
cen = self.SPACING/2 - 11
|
|
t = 5*self.SPACING - cen-22
|
|
m = 7*self.SPACING+50 - cen-22
|
|
self.STARTING_IDX_P1 = [[cen,0], [cen, 30], [cen, 60], [cen, 90], [cen,120], [self.SCREEN_WIDTH-cen-22, 0], [self.SCREEN_WIDTH-cen-22, 30], [t, 378],[t,348],[t,318],[m, 378], [m,348],[m,318],[m,288],[m,258]]
|
|
|
|
self.STARTING_IDX_P2 = [[cen, 378], [cen, 348], [cen, 318], [cen, 288], [cen, 258], [self.SCREEN_WIDTH-cen-22, 378], [self.SCREEN_WIDTH-cen-22, 348], [t, 0], [t, 30], [t, 60], [m, 0], [m,30],[m,60],[m,90],[m,120]]
|
|
|
|
pygame.init()
|
|
|
|
self.screen = pygame.display.set_mode((self.SCREEN_WIDTH, self.SCREEN_HEIGHT))
|
|
#screen_rect = screen.get_rect()
|
|
|
|
pygame.display.set_caption("Backgammon")
|
|
|
|
|
|
|
|
self.all_rects = {-1 : [], 1 : []}
|
|
|
|
for p in [-1,1]:
|
|
if p == -1:
|
|
for idx in self.STARTING_IDX_P1:
|
|
self.all_rects[p] += [pygame.rect.Rect(idx[0],idx[1], 22, 22)]
|
|
|
|
if p == 1:
|
|
for idx in self.STARTING_IDX_P2:
|
|
self.all_rects[p] += [pygame.rect.Rect(idx[0],idx[1], 22, 22)]
|
|
# for i in range(num_pieces):
|
|
# x = x+20
|
|
# all_rects[p] += [pygame.rect.Rect(x,y, 22, 22)]
|
|
# x = 100
|
|
# y += 100
|
|
|
|
|
|
|
|
self.all_drag = {-1 : [], 1 : []}
|
|
self.all_drag[-1] += [False]*self.num_pieces
|
|
self.all_drag[1] += [False]*self.num_pieces
|
|
|
|
self.all_off = {-1 : [], 1 : []}
|
|
self.all_off[-1] += [[0,0]]*self.num_pieces
|
|
self.all_off[1] += [[0,0]]*self.num_pieces
|
|
|
|
self.is_true = False
|
|
|
|
|
|
|
|
self.clock = pygame.time.Clock()
|
|
|
|
self.buckets = [[0,0],[5,-1],[0,0],[0,0],[0,0],[3,1],[0,0],[5,1],[0,0],[0,0],[0,0],[0,0],[2,-1],[5,1],[0,0],[0,0],[0,0],[3,-1],[0,0],[5,-1],[0,0],[0,0],[0,0],[0,0],[2,1],[0,0]]
|
|
self.running = True
|
|
self.player = -1
|
|
|
|
self.roll = [random.randrange(1, 7), random.randrange(1, 7)]
|
|
print("initial_roll:", self.roll)
|
|
|
|
self.from_board = None
|
|
self.from_buckets = [x for x in self.buckets]
|
|
self.from_locat = None
|
|
self.total_moves = 0
|
|
|
|
def switch_player(self):
|
|
self.player *= -1
|
|
print("CHANGED PLAYER!")
|
|
|
|
|
|
def gen_buckets_from_board(self, board):
|
|
meh = []
|
|
for i in range(13,25):
|
|
pin = board[i]
|
|
# print(pin)
|
|
meh.append([abs(pin), np.sign(pin)])
|
|
for i in range(1,13):
|
|
pin = board[i]
|
|
meh.append([abs(pin), np.sign(pin)])
|
|
|
|
return meh
|
|
|
|
|
|
def gen_board_from_buckets(self, buckets):
|
|
board = []
|
|
board.append(buckets[0])
|
|
for i in range(-2,-14,-1):
|
|
board.append(buckets[i])
|
|
for i in range(1,13):
|
|
board.append(buckets[i])
|
|
board.append(buckets[25])
|
|
board = [x*y for x,y in board]
|
|
|
|
return board
|
|
|
|
def move_legal(self, from_board, buckets, roll):
|
|
board = self.gen_board_from_buckets(buckets)
|
|
legal_states = Board.calculate_legal_states(from_board, self.player, roll)
|
|
# print(legal_states)
|
|
if board in [list(state) for state in list(legal_states)]:
|
|
return True
|
|
return False
|
|
|
|
def find_pin(self, pos):
|
|
SPACING = self.SPACING
|
|
x,y = pos
|
|
x -= 50 if x > 550 else 0
|
|
if y < 175:
|
|
pin = (13 + int(x / SPACING))
|
|
idx = 1+int(x / SPACING)
|
|
elif y > 225:
|
|
pin = (12 - int(x / SPACING))
|
|
idx = 13+ int(x / SPACING)
|
|
return pin, idx
|
|
|
|
# Find the y position based on the chosen pin
|
|
def calc_pos(self, buckets, chosen):
|
|
amount = buckets[chosen][0]
|
|
print(chosen)
|
|
SPACING = self.SPACING
|
|
|
|
if chosen == 0:
|
|
x = 525
|
|
y = 350
|
|
elif chosen == 26:
|
|
x = 525
|
|
y = 50
|
|
else:
|
|
if chosen > 12:
|
|
# print("Amount at pin:", amount)
|
|
y = 378 - (30 * amount)
|
|
chosen -= 12
|
|
x = (SPACING*(chosen-1))+(SPACING/2)
|
|
x += 50 if x > 500 else 0
|
|
else:
|
|
|
|
y = 30 * amount
|
|
x = (SPACING*(chosen-1))+(SPACING/2)
|
|
x += 50 if x > 500 else 0
|
|
return x,y
|
|
|
|
def calc_move_sets(self, from_board, roll, player):
|
|
# board = self.gen_board_from_buckets(buckets)
|
|
board = from_board
|
|
sets = []
|
|
total = 0
|
|
print("board!:",board)
|
|
for r in roll:
|
|
# print("Value of r:",r)
|
|
sets.append([Board.calculate_legal_states(board, player, [r,0]), r])
|
|
total += r
|
|
sets.append([Board.calculate_legal_states(board, player, [total,0]), total])
|
|
return sets
|
|
|
|
def calc_turn(self):
|
|
player = self.player
|
|
if self.total_moves == 0:
|
|
return player * -1
|
|
return player
|
|
|
|
def handle_move(self, from_board, buckets, roll, player):
|
|
board = self.gen_board_from_buckets(buckets)
|
|
# print("Cur board:",board)
|
|
sets = self.calc_move_sets(from_board, roll, player)
|
|
for idx, board_set in enumerate(sets):
|
|
board_set[0] = list(board_set[0])
|
|
# print("My board_set:",board_set)
|
|
if board in [list(c) for c in board_set[0]]:
|
|
self.total_moves -= board_set[1]
|
|
if idx < 2:
|
|
# print("Roll object:",self.roll)
|
|
self.roll[idx] = 0
|
|
else:
|
|
self.roll = [0,0]
|
|
break
|
|
print("Total moves left:",self.total_moves)
|
|
|
|
|
|
# while running:
|
|
|
|
def paint_board(self):
|
|
# - events -
|
|
if self.player != self.calc_turn():
|
|
self.switch_player()
|
|
self.roll = [random.randrange(1, 7), random.randrange(1, 7)]
|
|
self.total_moves = self.roll[0] + self.roll[1]
|
|
print("Player:",self.player,"rolled:",self.roll)
|
|
|
|
player = self.player
|
|
rectangles_drag = self.all_drag[player]
|
|
rectangles = self.all_rects[player]
|
|
offsets = self.all_off[player]
|
|
buckets = self.buckets
|
|
|
|
for event in pygame.event.get():
|
|
if event.type == pygame.QUIT:
|
|
running = False
|
|
|
|
elif event.type == pygame.MOUSEBUTTONDOWN:
|
|
if event.button == 1:
|
|
meh = [rect.collidepoint(event.pos) for rect in rectangles]
|
|
if any(meh):
|
|
is_true = np.where(meh)[0][0]
|
|
if any(meh):
|
|
# print("GETTING CALLED")
|
|
rectangles_drag[is_true] = True
|
|
mouse_x, mouse_y = event.pos
|
|
|
|
# Need this to be a deepcopy :<
|
|
self.from_buckets = []
|
|
for x in buckets:
|
|
tmp = []
|
|
for y in x:
|
|
tmp.append(y)
|
|
self.from_buckets.append(tmp)
|
|
|
|
self.from_board = [x for x in self.gen_board_from_buckets(buckets)]
|
|
# print("From board in mousedown:", from_board)
|
|
pin, idx = self.find_pin(event.pos)
|
|
from_pin = pin
|
|
buckets[idx][0] -= 1
|
|
|
|
if buckets[idx][0] == 0:
|
|
buckets[idx][1] = 0
|
|
|
|
offsets[is_true][0] = rectangles[is_true].x - mouse_x
|
|
offsets[is_true][1] = rectangles[is_true].y - mouse_y
|
|
|
|
self.from_locat = [rectangles[is_true].x, rectangles[is_true].y]
|
|
|
|
elif event.type == pygame.MOUSEBUTTONUP:
|
|
if event.button == 1:
|
|
meh = [rect.collidepoint(event.pos) for rect in rectangles]
|
|
if any(meh):
|
|
is_true = np.where(meh)[0][0]
|
|
|
|
pin, idx = self.find_pin(event.pos)
|
|
x, y = self.calc_pos(buckets,idx)
|
|
|
|
# Need to take care of bar stuff :<
|
|
if (buckets[idx][1] == player*-1) and buckets[idx][0] == 1:
|
|
to_idx = 0 if buckets[idx][1] == 1 else 25
|
|
enemy_rects = self.all_rects[player*-1]
|
|
|
|
|
|
# Have some check if we're looking for either rects in the bottom or top,
|
|
# instead of having both here
|
|
neg_tester = [rect.collidepoint(x,y-30) for rect in enemy_rects]
|
|
pos_tester = [rect.collidepoint(x,y+40) for rect in enemy_rects]
|
|
print("Neg tester:",neg_tester)
|
|
print("Pos tester:",pos_tester)
|
|
if any(neg_tester):
|
|
enemy = np.where(neg_tester)[0][0]
|
|
elif any(pos_tester):
|
|
enemy = np.where(pos_tester)[0][0]
|
|
|
|
buckets[to_idx][0] += 1
|
|
buckets[to_idx][1] = buckets[idx][1]
|
|
|
|
bar_x, bar_y = self.calc_pos(buckets, to_idx)
|
|
enemy_rects[enemy].x = bar_x
|
|
enemy_rects[enemy].y = bar_y
|
|
|
|
|
|
buckets[idx][0] = 0
|
|
print("In here"*20)
|
|
|
|
|
|
|
|
pin, idx = self.find_pin(event.pos)
|
|
x, y = self.calc_pos(buckets,idx)
|
|
buckets[idx][0] += 1
|
|
buckets[idx][1] = player
|
|
|
|
|
|
# print(self.from_board)
|
|
# print("To :",self.gen_board_from_buckets(buckets))
|
|
# print(move_legal(from_board, buckets, [1,2]))
|
|
|
|
|
|
print("from board:",self.from_board)
|
|
# if self.move_legal(self.from_board, buckets, self.roll):
|
|
pot_board = self.gen_board_from_buckets(buckets)
|
|
sets = self.calc_move_sets(self.from_board, self.roll, player)
|
|
|
|
print("potential board:",pot_board)
|
|
# print("board:",pot_board)
|
|
truth_values = []
|
|
for t in sets:
|
|
b = [list(c) for c in list(t)[0]]
|
|
if pot_board in list(b):
|
|
truth_values.append(pot_board in list(b))
|
|
|
|
print("Truth values:",truth_values)
|
|
if any(truth_values):
|
|
self.handle_move(self.from_board, buckets, self.roll, player)
|
|
# print("From:",self.gen_board_from_buckets(self.from_buckets))
|
|
# print("WOHO!"*10)
|
|
|
|
rectangles_drag[is_true] = False
|
|
rectangles[is_true].x = x
|
|
rectangles[is_true].y = y
|
|
else:
|
|
# print("From:",self.gen_board_from_buckets(self.from_buckets))
|
|
|
|
self.buckets = []
|
|
for x in self.from_buckets:
|
|
tmp = []
|
|
for y in x:
|
|
tmp.append(y)
|
|
self.buckets.append(tmp)
|
|
|
|
rectangles_drag[is_true] = False
|
|
rectangles[is_true].x = self.from_locat[0]
|
|
rectangles[is_true].y = self.from_locat[1]
|
|
|
|
# print("End :",self.gen_board_from_buckets(buckets))
|
|
|
|
|
|
elif event.type == pygame.MOUSEMOTION:
|
|
|
|
if any(rectangles_drag):
|
|
is_true = np.where(rectangles_drag)[0][0]
|
|
|
|
mouse_x, mouse_y = event.pos
|
|
rectangles[is_true].x = mouse_x + offsets[is_true][0]
|
|
rectangles[is_true].y = mouse_y + offsets[is_true][1]
|
|
|
|
self.screen.fill(self.GREEN_FILT)
|
|
# pygame.draw.polygon(screen, (RED), [[0, 0], [50,0],[25,100]], 2)
|
|
|
|
|
|
|
|
|
|
color = self.LIGHT_GREY
|
|
x = 0
|
|
y = 150
|
|
# for _ in range(2):
|
|
for i in range(12):
|
|
if x < 500 and x+self.SPACING > 500:
|
|
x = 550
|
|
color = self.SALMON if color == self.LIGHT_GREY else self.LIGHT_GREY
|
|
pygame.draw.polygon(self.screen, color, [[x, 0], [x+self.SPACING, 0], [(2*x+self.SPACING)/2, y]])
|
|
x += self.SPACING
|
|
# y += 50
|
|
|
|
x = 0
|
|
y = 250
|
|
# for _ in range(2):
|
|
color = self.SALMON if color == self.LIGHT_GREY else self.LIGHT_GREY
|
|
|
|
for i in range(12):
|
|
if x < 500 and x+self.SPACING > 500:
|
|
x = 550
|
|
color = self.SALMON if color == self.LIGHT_GREY else self.LIGHT_GREY
|
|
pygame.draw.polygon(self.screen, color, [[x, 400], [x+self.SPACING, 400], [(2*x+self.SPACING)/2, y]])
|
|
x += self.SPACING
|
|
|
|
|
|
# print(gen_board_from_buckets(buckets))
|
|
pygame.draw.rect(self.screen, self.BROWN, pygame.rect.Rect((500, 0, 50, 400)))
|
|
for p in [-1,1]:
|
|
for rect in self.all_rects[p]:
|
|
|
|
pygame.draw.rect(self.screen, self.RED if p == -1 else self.BLACK, rect)
|
|
|
|
pygame.display.flip()
|
|
|
|
# - constant game speed / FPS -
|
|
|
|
self.clock.tick(self.FPS)
|
|
|
|
def test(self):
|
|
while True:
|
|
self.paint_board()
|
|
|
|
|
|
|
|
b = Board_painter()
|
|
b.test()
|
|
# class myThread (threading.Thread):
|
|
# def __init__(self, threadID, name, counter):
|
|
# threading.Thread.__init__(self)
|
|
# self.threadID = threadID
|
|
# self.name = name
|
|
# self.counter = counter
|
|
# def run(self, function):
|
|
# print ("Starting " + self.name)
|
|
# function()
|
|
# print ("Exiting " + self.name)
|
|
|
|
|
|
# def change_player():
|
|
# while True:
|
|
# time.sleep(5)
|
|
# b.switch_player([1,2])
|
|
|
|
# def keep_painting():
|
|
# while True:
|
|
# b.paint_board()
|
|
|
|
|
|
|
|
# # Create new threads
|
|
# thread2 = myThread( keep_painting() )
|
|
# thread1 = myThread( change_player() )
|
|
|
|
|
|
# # Start new Threads
|
|
# thread1.start()
|
|
# thread2.start()
|
|
# thread1.join()
|
|
# thread2.join()
|
|
# print ("Exiting Main Thread")
|
|
# # - end -
|
|
|
|
# pygame.quit()
|
|
|
|
|