308 lines
8.9 KiB
Python
308 lines
8.9 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 pygame
|
|
from board import Board
|
|
import numpy as np
|
|
|
|
# --- constants --- (UPPER_CASE names)
|
|
|
|
SCREEN_WIDTH = 1050
|
|
SCREEN_HEIGHT = 400
|
|
|
|
SPACING = 83.333
|
|
|
|
|
|
#BLACK = ( 0, 0, 0)
|
|
#242 209 107
|
|
SAND = (242, 209, 107)
|
|
GREEN_FILT = (0,102,0)
|
|
WHITE = (255, 255, 255)
|
|
RED = (255, 0, 0)
|
|
SALMON = (250,128,114)
|
|
BLACK = (0,0,0)
|
|
BROWN = (160,82,45)
|
|
LIGHT_GREY = (220,220,220)
|
|
num_pieces = 15
|
|
FPS = 30
|
|
cen = SPACING/2 - 11
|
|
t = 5*SPACING - cen-22
|
|
m = 7*SPACING+50 - cen-22
|
|
STARTING_IDX_P1 = [[cen,0], [cen, 30], [cen, 60], [cen, 90], [cen,120], [SCREEN_WIDTH-cen-22, 0], [SCREEN_WIDTH-cen-22, 30], [t, 378],[t,348],[t,318],[m, 378], [m,348],[m,318],[m,288],[m,258]]
|
|
|
|
STARTING_IDX_P2 = [[cen, 378], [cen, 348], [cen, 318], [cen, 288], [cen, 258], [SCREEN_WIDTH-cen-22, 378], [SCREEN_WIDTH-cen-22, 348], [t, 0], [t, 30], [t, 60], [m, 0], [m,30],[m,60],[m,90],[m,120]]
|
|
|
|
|
|
# --- classses --- (CamelCase names)
|
|
|
|
# empty
|
|
|
|
# --- functions --- (lower_case names)
|
|
|
|
# empty
|
|
|
|
# --- main ---
|
|
|
|
# - init -
|
|
|
|
pygame.init()
|
|
|
|
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
|
|
#screen_rect = screen.get_rect()
|
|
|
|
pygame.display.set_caption("Backgammon")
|
|
|
|
# - objects -
|
|
|
|
|
|
|
|
|
|
all_rects = {-1 : [], 1 : []}
|
|
|
|
x, y = [0, 0]
|
|
for p in [-1,1]:
|
|
if p == -1:
|
|
for idx in STARTING_IDX_P1:
|
|
all_rects[p] += [pygame.rect.Rect(idx[0],idx[1], 22, 22)]
|
|
|
|
if p == 1:
|
|
for idx in STARTING_IDX_P2:
|
|
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
|
|
|
|
|
|
|
|
all_drag = {-1 : [], 1 : []}
|
|
all_drag[-1] += [False]*num_pieces
|
|
all_drag[1] += [False]*num_pieces
|
|
|
|
all_off = {-1 : [], 1 : []}
|
|
all_off[-1] += [[0,0]]*num_pieces
|
|
all_off[1] += [[0,0]]*num_pieces
|
|
|
|
is_true = False
|
|
|
|
# - mainloop -
|
|
|
|
clock = pygame.time.Clock()
|
|
|
|
buckets = [[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]]
|
|
running = True
|
|
player = 1
|
|
|
|
roll = []
|
|
def switch_player(roll):
|
|
roll = roll
|
|
player *= -1
|
|
|
|
|
|
def gen_buckets_from_board(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(buckets):
|
|
board = []
|
|
board.append([0,0])
|
|
for i in range(-1,-13,-1):
|
|
board.append(buckets[i])
|
|
for i in range(0,12):
|
|
board.append(buckets[i])
|
|
board.append([0,0])
|
|
board = [x*y for x,y in board]
|
|
|
|
return board
|
|
|
|
def move_legal(from_board, buckets, roll):
|
|
board = gen_board_from_buckets(buckets)
|
|
legal_states = Board.calculate_legal_states(from_board, 1, roll)
|
|
# print(legal_states)
|
|
if board in [list(state) for state in list(legal_states)]:
|
|
return True
|
|
return False
|
|
|
|
|
|
def find_pin(pos):
|
|
x,y = pos
|
|
x -= 50 if x > 550 else 0
|
|
if y < 175:
|
|
pin = (13 + int(x / SPACING))
|
|
idx = int(x / SPACING)
|
|
elif y > 225:
|
|
pin = (12 - int(x / SPACING))
|
|
idx = 12+ int(x / SPACING)
|
|
return pin, idx
|
|
|
|
# Find the y position based on the chosen pin
|
|
def calc_pos(buckets, chosen):
|
|
amount = buckets[chosen][0]
|
|
|
|
# My math is incredibly off
|
|
if chosen > 11:
|
|
print("Amount at pin:", amount)
|
|
y = 378 - (30 * amount)
|
|
chosen -= 11
|
|
x = (SPACING*(chosen-1))+(SPACING/2)
|
|
x += 50 if x > 500 else 0
|
|
else:
|
|
chosen += 1
|
|
y = 30 * amount
|
|
x = (SPACING*(chosen-1))+(SPACING/2)
|
|
x += 50 if x > 500 else 0
|
|
|
|
|
|
|
|
return x,y
|
|
from_board = None
|
|
from_buckets = [x for x in buckets]
|
|
from_locat = None
|
|
while running:
|
|
|
|
# - events -
|
|
for event in pygame.event.get():
|
|
if event.type == pygame.QUIT:
|
|
running = False
|
|
|
|
elif event.type == pygame.MOUSEBUTTONDOWN:
|
|
if event.button == 1:
|
|
rectangles = all_rects[player]
|
|
offsets = all_off[player]
|
|
|
|
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 :<
|
|
from_buckets = []
|
|
for x in buckets:
|
|
tmp = []
|
|
for y in x:
|
|
tmp.append(y)
|
|
from_buckets.append(tmp)
|
|
|
|
from_board = [x for x in gen_board_from_buckets(buckets)]
|
|
# print("From board in mousedown:", from_board)
|
|
pin, idx = 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
|
|
|
|
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 = find_pin(event.pos)
|
|
x, y = calc_pos(buckets,idx)
|
|
buckets[idx][0] += 1
|
|
buckets[idx][1] = player
|
|
|
|
|
|
print(from_board)
|
|
print("To :",gen_board_from_buckets(buckets))
|
|
# print(move_legal(from_board, buckets, [1,2]))
|
|
if move_legal(from_board, buckets, [1,0]):
|
|
print("From:",gen_board_from_buckets(from_buckets))
|
|
print("WOHO!"*10)
|
|
|
|
rectangles_drag = all_drag[player]
|
|
rectangles_drag[is_true] = False
|
|
rectangles[is_true].x = x
|
|
rectangles[is_true].y = y
|
|
else:
|
|
print("From:",gen_board_from_buckets(from_buckets))
|
|
buckets = [x for x in from_buckets]
|
|
rectangles_drag = all_drag[player]
|
|
rectangles_drag[is_true] = False
|
|
rectangles[is_true].x = from_locat[0]
|
|
rectangles[is_true].y = from_locat[1]
|
|
print("End :",gen_board_from_buckets(buckets))
|
|
|
|
|
|
elif event.type == pygame.MOUSEMOTION:
|
|
rectangles_drag = all_drag[player]
|
|
rectangles = all_rects[player]
|
|
offsets = all_off[player]
|
|
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]
|
|
|
|
screen.fill(GREEN_FILT)
|
|
# pygame.draw.polygon(screen, (RED), [[0, 0], [50,0],[25,100]], 2)
|
|
|
|
|
|
|
|
|
|
color = LIGHT_GREY
|
|
x = 0
|
|
y = 150
|
|
# for _ in range(2):
|
|
for i in range(12):
|
|
if x < 500 and x+SPACING > 500:
|
|
x = 550
|
|
color = SALMON if color == LIGHT_GREY else LIGHT_GREY
|
|
pygame.draw.polygon(screen, color, [[x, 0], [x+SPACING, 0], [(2*x+SPACING)/2, y]])
|
|
x += SPACING
|
|
# y += 50
|
|
|
|
x = 0
|
|
y = 250
|
|
# for _ in range(2):
|
|
color = SALMON if color == LIGHT_GREY else LIGHT_GREY
|
|
|
|
for i in range(12):
|
|
if x < 500 and x+SPACING > 500:
|
|
x = 550
|
|
color = SALMON if color == LIGHT_GREY else LIGHT_GREY
|
|
pygame.draw.polygon(screen, color, [[x, 400], [x+SPACING, 400], [(2*x+SPACING)/2, y]])
|
|
x += SPACING
|
|
|
|
|
|
# print(gen_board_from_buckets(buckets))
|
|
pygame.draw.rect(screen, BROWN, pygame.rect.Rect((500, 0, 50, 400)))
|
|
for p in [-1,1]:
|
|
for rect in all_rects[p]:
|
|
|
|
pygame.draw.rect(screen, RED if p == -1 else BLACK, rect)
|
|
|
|
pygame.display.flip()
|
|
|
|
# - constant game speed / FPS -
|
|
|
|
clock.tick(FPS)
|
|
|
|
# - end -
|
|
|
|
pygame.quit()
|