def __init__(self, screen):
self.screen = screen
self.mouse_pos = [0, 0]
self.background = pygame.image.load("Map_Old.bmp").convert()
headline_font = pygame.font.SysFont('Arial', 100)
self.headline = headline_font.render("Conquest Of The New World",
False, (0, 0, 0))
self.menu_box = pygame.Surface((1000, 500))
self.menu_box.set_alpha(128)
self.menu_box.fill((255, 255, 255))
self.btn_solitaire_game = classes.Button(300, 600, True,
"New Solitair Game",
"Button_Disabled.bmp",
"Button_Enabled.bmp",
"Button_Clicked.bmp")
self.btn_load_game = classes.Button(300, 640, True,
"Load Solitair Game",
"Button_Disabled.bmp",
"Button_Enabled.bmp",
"Button_Clicked.bmp")
self.btn_quit = classes.Button(300, 680, True, "Quit Game",
"Button_Disabled.bmp",
"Button_Enabled.bmp",
"Button_Clicked.bmp")
self.btn_options = classes.Button(300, 720, True, "Options",
"Button_Disabled.bmp",
"Button_Enabled.bmp",
"Button_Clicked.bmp")
def fillBoard():
marginY = 0
margemX = 0
a = []
margemX = math.ceil(fullSize / 2)
for x in range(math.floor(width / (fullSize))):
a.append([])
marginY = math.ceil(fullSize / 2)
if (x % 3 == 0 and x != 0):
margemX += 3
for y in range(math.floor(height / (fullSize))):
tamanhox = x * (fullSize)
tamanhoy = y * (fullSize)
if (y % 3 == 0 and y != 0):
marginY += 3
rect = pygame.Rect(tamanhox + margemX, tamanhoy + marginY,
blockSize, blockSize)
but = classes.Button((tamanhox + margemX, tamanhoy + marginY),
rect, fullSize)
a[x].append(but)
#print(str(but.vetpos) + "", end = "")
screen.blit(but.image, but.pos)
return a
def __init__(
self, screen
): # zum initialisieren des Levels werden einige Elemente initialisiert
self.screen = screen # der Screen enthält die Bildelemente
self.top_menu = pygame.Surface((1200, 35))
#self.top_menu.set_alpha()
self.top_menu.fill((120, 120, 120))
self.zoom = 1
self.mouse_pos = [0, 0] # initialisiere die Maus
self.btn_end_round = classes.Button(10, 5, True, "End Round",
"Button_Disabled.bmp",
"Button_Enabled.bmp",
"Button_Clicked.bmp")
self.btn_quit = classes.Button(270, 5, True, "Quit Game",
"Button_Disabled.bmp",
"Button_Enabled.bmp",
"Button_Clicked.bmp")
self.btn_zoom_in = classes.Button(540, 5, True, "Zoom In",
"Button_Disabled.bmp",
"Button_Enabled.bmp",
"Button_Clicked.bmp")
self.btn_zoom_out = classes.Button(810, 5, True, "Zoom Out",
"Button_Disabled.bmp",
"Button_Enabled.bmp",
"Button_Clicked.bmp")
self.cam = classes.Camera(100, 100, 10000)
self.t_wdeep = pygame.image.load("waterdeep_iso.png").convert_alpha()
self.t_wdeep_shall = pygame.image.load(
"water_deep_shallow_iso.png").convert_alpha()
self.t_wshallow = pygame.image.load(
"watershallow_iso.png").convert_alpha()
def setUpLayers():
# MAKE SOME SPACE
# Add the background
cfg.LAYERS['background'] = [classes.Background(cfg.IMAGESDICT['space'])]
# Add some planets
cfg.LAYERS['middleground'] = makeSystem()
# Add one ship
ship = classes.Ship()
ship.destinations = [] # No destinations yet
ship.currentDestination = 0
# Add the ship to the foreground
cfg.LAYERS['foreground'] = [ship]
# Add a button
button = classes.Button((40, 40), (400, 400))
cfg.LAYERS['buttons'] = [button]
def game(width, height, fullscreen, lvl_name):
FPS = 120
WIDTH = width
HEIGHT = height
running = True
drawing = False
newturnanimation = False
screen_3 = pygame.display.set_mode((width, height), fullscreen)
clock = pygame.time.Clock()
board = classes.board
board.clear()
board.set_level(lvl_name)
board.resize(WIDTH, HEIGHT)
DELTA = board.get_delta()
hud = classes.hud
bu = False
players = [player_1, player_2, player_3, player_4] = board.get_players()
turns = {
player_1: player_2,
player_2: player_3,
player_3: player_4,
player_4: player_1
}
turned = players[board.get_first_turned()]
next_turned = turns[turned]
while not next_turned.active:
next_turned = turns[next_turned]
turned.update()
button_town = classes.Button((WIDTH - 275, 30), 'Build Town')
button_gun = classes.Button((WIDTH - 275, 90), 'Set Gun')
button_block = classes.Button((WIDTH - 275, 150), 'Set Block')
button_destroy = classes.Button((WIDTH - 275, 210), 'Destroy')
button_end_turn = classes.Button((WIDTH - 275, HEIGHT - 80), 'End Turn')
buttons = [
button_town, button_gun, button_block, button_destroy, button_end_turn
]
players = [player_1, player_2, player_3, player_4]
pygame.mouse.set_visible(0)
DELTA = board.resize(WIDTH, HEIGHT)
classes.resize(DELTA, button_town, button_gun, button_block,
button_destroy, button_end_turn)
hud.resize()
hud.set_turned_text(str(board.get_first_turned() + 1), turned)
x, y, a, b = 0, 0, 0, 0
turned_gun = None
ch = 0
choosen = '.'
while running:
ch += 1
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit(0)
if event.type == pygame.MOUSEBUTTONDOWN:
sprites.click.play()
x, y = event.pos
if 0 <= x < DELTA[0] * len(
board.board[0]) and 0 <= y < DELTA[1] * len(
board.board) and turned.action != 0:
x1, y1 = board.get_click(event.pos)
if board.board[y1][x1] is not None:
if board.board[y1][x1].player == turned:
if board.board[y1][
x1].built or choosen == 'Destroy':
if choosen == 'Destroy':
board.destroy_object(y1, x1)
turned.use_action()
hud.update_actions()
for button in buttons:
button.unpress()
choosen = '.'
else:
if board.board[y1][
x1].__class__ == classes.Gun:
turned_gun = board.board[y1][x1]
else:
board.board[y1][x1].build()
turned.use_action()
hud.update_actions()
elif board.board[y1][x1].__class__ == classes.Gun:
if turned_gun is not None and turned_gun.can_destroy(
y1, x1):
board.attack(y1, x1, turned)
turned_gun = None
turned.use_action()
hud.update_actions()
elif board.board[y1][x1].__class__ == classes.Block:
if turned_gun is not None and turned_gun.can_destroy(
y1, x1):
board.attack(y1, x1, turned)
turned_gun = None
turned.use_action()
hud.update_actions()
elif board.board[y1][x1].__class__ == classes.Town:
if turned_gun is not None and turned_gun.can_destroy(
y1, x1):
board.attack(y1, x1, turned)
turned_gun = None
turned.use_action()
hud.update_actions()
else:
if choosen in 'GunTownBlock' and board.possible(
y1, x1, turned):
board.board[y1][x1] = classes.get_class(
choosen, (y1, x1), turned)
turned.add_own(board.board[y1][x1])
turned.update_max_actions()
turned.use_action()
hud.update_actions()
board.board[y1][x1].build()
choosen = '.'
else:
find = False
for button in buttons:
button.unpress()
if button.crossing((x, y)):
choosen = button.press()
if choosen != 'Destroy' and choosen != 'End Turn':
choosen = choosen.split()[1]
find = True
if not find:
choosen = '.'
if choosen == 'End Turn':
newturnanimation = True
sprites.newturn.play()
choosen = '.'
button_end_turn.unpress()
turned.update(turn=False)
turned = next_turned
next_turned = turns[next_turned]
while not next_turned.active:
next_turned = turns[next_turned]
turned.update()
hud.set_turned_text(str(players.index(turned) + 1),
turned)
if event.type == pygame.MOUSEMOTION:
x, y = event.pos
for button in buttons:
button.crossing(event.pos)
if 0 <= x < DELTA[0] * len(
board.board[0]) and 0 <= y < DELTA[1] * len(
board.board):
b, a = board.get_click(event.pos)
else:
a, b = -1, -1
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
if not esc.menu(screen_3, board):
running = False
if newturnanimation:
count += 1
if count == 60:
newturnanimation = False
if not newturnanimation:
count = 0
if not running:
break
screen_3.fill((0, 0, 0))
hud.update_hud(screen_3)
if (ch // 80) % 2 == 0:
board.update(screen_3, True)
else:
board.update(screen_3)
for button in buttons:
button.render(screen_3)
hud.draw_info((a, b), screen_3, board.board[a][b])
if newturnanimation:
screen_3.blit(sprites.newturnanim[count // 6], (0, 0))
if pygame.mouse.get_focused():
screen_3.blit(sprites.mouse.image, (x, y))
k = 0
for c in players:
if c.active:
k += 1
if k == 1:
for c in players:
if c.active:
fun.win(c, screen_3, WIDTH, HEIGHT)
bu = True
if bu:
break
pygame.display.flip()
clock.tick(FPS)
var.SCREEN_TYPE) # on trouve le définition de l'écran avec son format
while var.globalLoop: ##################### boucle globale, qui fait le lien entre le menu, les options et le jeu
if var.menuLoop: ######## début de la boucle du menu, on réinitialise les listes,et on fait apparaitre les boutons
var.refreshList = []
var.playerList = []
var.buttonList = []
if var.SCREEN_TYPE == 169:
menu = cl.Fond(var.img_menu169
) #on met le l'image de menu approprié au format
else:
menu = cl.Fond(var.img_menu43)
#on fait apparaitre les boutons(avec l'image qu'il doivent prendre, les x,y et le code à exec si ils sont pressés)
butGame = cl.Button(
var.img_highlbutt,
(var.SCREEN_LENGHT / 2, var.SCREEN_HEIGHT / 2 - 100),
'var.menuLoop=False\nvar.gameLoop=True\n')
butOptions = cl.Button(
var.img_highlbutt,
(var.SCREEN_LENGHT / 2, var.SCREEN_HEIGHT / 2 + 60),
'var.menuLoop=False\nvar.optionsLoop = True')
butExit = cl.Button(
var.img_highlbutt,
(var.SCREEN_LENGHT / 2, var.SCREEN_HEIGHT / 2 + 215),
'var.menuLoop=False\nvar.globalLoop=False')
#on initie la playlist si elle ne se joue pas déja
if var.MUSIC and not (var.playlist == "menu_music"):
cl.pygame.mixer.music.set_volume(var.volume / 100)
var.playlist = "menu_music"
cl.pygame.mixer.init()
cl.pygame.mixer.music.load(var.music_top_gun)
def add_button(self, module_name, **kwargs):
button_obj = classes.Button(**kwargs)
engine.add_button(module_name, button_obj)
return button_obj
def new_game_choose(width, height, fullscreen):
running = True
x, y, a, b = 0, 0, 0, 0
FPS = 60
choosen = '.'
clock = pygame.time.Clock()
pygame.mouse.set_visible(0)
screen_2 = pygame.display.set_mode((width, height), fullscreen)
button_choose_map = classes.Button(
(int(width * 3 / 4) - classes.Button.size[1], int(height * 3 / 4)),
'Choose Map')
button_back = classes.Button((width // 4, int(height * 3 / 4)), 'Back')
buttons = [button_choose_map, button_back]
levels = sprites.levels
choose_text = 'Choose Level'
font = classes.FONT
i = 0
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit(0)
if event.type == pygame.MOUSEMOTION:
a, b = event.pos
for button in buttons:
button.crossing(event.pos)
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
running = False
if event.type == pygame.MOUSEBUTTONDOWN:
x, y = event.pos
for button in buttons:
if button.crossing((x, y)):
choosen = button.press()
if choosen == 'Choose Map':
return levels[i].text
if choosen == 'Back':
running = False
if fun.crossing((width // 4, height // 2), (x, y)):
if i != 0:
i -= 1
if fun.crossing((int((width * 3) / 4) - 25, height // 2),
(x, y)):
if i != len(sprites.levels) - 1:
i += 1
if event.type == pygame.MOUSEBUTTONUP:
for button in buttons:
button.unpress()
# screen.blit(image, (0, 0))
screen_2.fill((40, 40, 40))
screen_2.fill((100, 100, 100),
(width // 4, height // 4, width // 2, height // 2))
screen_2.blit(font.render(choose_text, True, pygame.Color('white')),
(width // 2 - 50, height // 4 + 17))
screen_2.blit(levels[i].image, (width // 4 + 25, height // 4 + 50))
if i != 0:
screen_2.blit(sprites.left.image, (width // 4, height // 2))
if i != len(sprites.levels) - 1:
screen_2.blit(sprites.right.image, (int(
(width * 3) / 4) - 25, height // 2))
for button in buttons:
button.render(screen_2)
if pygame.mouse.get_focused():
screen_2.blit(sprites.mouse.image, (a, b))
pygame.display.flip()
clock.tick(FPS)
def image_to_json(imgc,models):
#remove noise
imgc = cv2.fastNlMeansDenoisingColored(imgc)
#get gray image
gray=cv2.cvtColor(imgc,6)
#remove noise
gray = cv2.fastNlMeansDenoising(gray,None,10,7,21)
h,w=gray.shape
#get binary image
img= cv2.adaptiveThreshold(gray,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,\
cv2.THRESH_BINARY,11,2)
#initializing array for all the components of the form
fields=[]
#detect text
tboxes=models["textDetector"].boxes(Image.fromarray(imgc))
#recognize text
for tbox in tboxes:
x,y,w,h=map(int,tbox)
new=img[y:y+h,x:x+w]
res=models["textrec"].recognize(new)
if res is not None:
fields.append(classes.Label(res[0],tbox,float(res[1])))
#calculate average text height, used as reference
avg_t_h=mean([b[3] for b in tboxes])
fields=textUtils.groupLabels(fields,avg_t_h)
#erasing text
utils.erase(tboxes,img)
#detect all components remaining on the form
contours, hierarchy = cv2.findContours(255-img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
boxes=sorted([cv2.boundingRect(c) for c in contours], key =lambda x:x[2],reverse=True )
#cleaning
if (0,0,w,h) in boxes:
boxes.remove((0,0,w,h))
temp=[]
for b in boxes:
if b[2]<=8 or b[2]*b[3]<150 :
temp.append(b)
boxes=[b for b in boxes if b not in temp]
for b in boxes:
l=[x for x in boxes if utils.is_inside(x,b,5)]
boxes=[x for x in boxes if x not in l]
#recognize components
lines=[]
for i in range(len(boxes)):
x,y,w,h=boxes[i]
res=models["widgetClassifier"].classify(img[y:y+h,x:x+w],avg_t_h)
if res is None:
continue
Ftype=res[1]
if Ftype in ["textBox","dropDown","date"]:
ls=[f for f in fields if f.fieldType == "Label" and utils.is_inside(f.getBbox(),boxes[i],avg_t_h/3)]
if ls:
fields=[f for f in fields if f not in ls]
fields.append(classes.Button(boxes[i],textUtils.mergeLabels(ls)))
else:
if Ftype == "textBox":
fields.append(classes.TextField(boxes[i]))
elif Ftype == "dropDown":
fields.append(classes.DropDown(boxes[i]))
else:
fields.append(classes.Date(boxes[i]))
elif Ftype == "line":
ls=[f for f in fields if f.fieldType == "Label" and widgets.is_underline(f.getBbox(),boxes[i],avg_t_h//2,avg_t_h//2)]
if len(ls) != 0:
fields=[f for f in fields if f not in ls]
ls=textUtils.mergeLabels(ls).toTitle()
ls.headerLine=classes.Line(boxes[i])
fields.append(ls)
else:
lines.append(classes.Line(boxes[i]))
elif Ftype == "checkBox":
fields.append(classes.CheckBox(boxes[i]))
elif Ftype == "radio":
fields.append(classes.Radio(boxes[i]))
elif Ftype == "table":
fields.append(classes.Table(boxes[i]))
# processing the widgets
#collecting all the lines
for l in lines:
# To recognize lines as fill-in-the blank text-box
# comparing the line with adjacent text,
# which is made one fourth it's height so as to match the line height
textFieldLine=False
for t in tboxes :
bbox1=(t[0]+(t[2]*3)//4,t[1],t[2]//4,t[3]);
bbox2=l.getBbox();
if utils.is_left(bbox1,bbox2) or utils.is_right(bbox1,bbox2):
textFieldLine=True
break
if textFieldLine:
lines.remove(l)
ls=list(l.getBbox())
ls[3]=avg_t_h
fields.append(TextField(ls))
lines.sort(key=lambda x:x.BoundingBox['Top'])
# grouping lines into multiline textArea
groups=[]
while lines:
ls=[lines.pop(0)]
while True:
temp=[line for line in lines if utils.is_above(ls[-1].getBbox(),line.getBbox(),avg_t_h)]
if temp:
ls.append(min(temp,key=lambda x:x.BoundingBox['Top'] - ls[-1].BoundingBox['Top']))
lines.remove(ls[-1])
else:
break
groups.append(ls)
#form text area out of lines
for group in groups:
if len(group)==1:
fields.append(group[0])
else:
fields.append(classes.TextArea(utils.getBbox(group),len(group)))
for f in [f for f in fields if f.fieldType=="Table"]:
x,y,w,h=f.getBbox()
f.rows=len(widgets.getRows(img[y:y+h,x:x+w]))
f.cols=len(widgets.getColums(img[y:y+h,x:x+w]))
if f.rows == 0 or f.cols == 0:
fields.remove(f)
for f in [f for f in fields if f.fieldType=="Date"]:
x,y,w,h=f.getBbox()
f.blocks=len(widgets.getColums(img[y:y+h,x:x+w]))
if f.blocks == 0:
fields.remove(f)
#collecting the row and column count in the table
#rectifying the heights and sorting
fields=utils.makeHeights(fields,avg_t_h/2)
#association of related components
components=utils.getComponents(fields,avg_t_h)
#breaking of the form into sections
sections=utils.getSections(components)
new=classes.form(img.shape)
new.sections=sections
cv2.imwrite("result.jpg",new.printForm())
return new.getJSON()
def settings(screen):
running = True
FPS = 120
choosen = '.'
clock = pygame.time.Clock()
x, y, a, b = 0, 0, 0, 0
volume_slider = classes.Slider((20, 80))
button_exit = classes.Button((5, classes.HEIGHT), 'Back')
button_save_settings = classes.Button((classes.WIDTH, classes.HEIGHT), 'Save Setting')
buttons = [button_exit, button_save_settings]
sliders = [volume_slider]
FONT = classes.FONT
while running:
choosen = '.'
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
if event.type == pygame.MOUSEMOTION:
a, b = event.pos
for slider in sliders:
if slider.pressed:
if a - 15 > 0 and a - 15 < 400:
slider.xp = a - 15
slider.crossing(event.pos)
for button in buttons:
button.crossing(event.pos)
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
running = False
if event.type == pygame.MOUSEBUTTONDOWN:
x, y = event.pos
for button in buttons:
if button.crossing((x, y)):
choosen = button.press()
for slider in sliders:
if slider.crossing((x, y)):
slider.press()
if choosen == 'Back':
running = False
if event.type == pygame.MOUSEBUTTONUP:
for button in buttons:
button.unpress()
for slider in sliders:
if slider.pressed:
classes.volume_value = slider.get_pos()
classes.volume_update()
slider.unpress()
screen.fill((50, 50, 50))
screen.blit(FONT.render('Settings', True, (255, 255, 255)), (20, 20))
screen.blit(FONT.render('Music', True, (255, 255, 255)), (20, 60))
for button in buttons:
button.render(screen)
for slider in sliders:
slider.render(screen)
if pygame.mouse.get_focused():
screen.blit(sprites.mouse.image, (a, b))
pygame.display.flip()
clock.tick(FPS)
#create game clock
clock = pygame.time.Clock()
title = classes.Text(screen, screenX / 2, 50, inits.arial60, 'Dogfight',
inits.black)
gameOver = classes.Text(screen, screenX / 2, 50, inits.arial60, 'Game Over',
inits.black)
gameScore = classes.Text(screen, screenX / 2, 0, inits.arial30,
'Score: ' + str(score), inits.red)
endScore = classes.Text(screen, screenX / 2, 400, inits.arial40,
'Score: ' + str(score), inits.red)
bestScoretxt = classes.Text(screen, screenX / 2, 450, inits.arial40,
'Best Score: ' + str(bestScore), inits.black)
startButton = classes.Button(screen, screenX / 2, 135, 100, 50, inits.black,
inits.arial30, 'Start', inits.red)
helpButton = classes.Button(screen, screenX / 2, 200, 100, 50, inits.black,
inits.arial30, 'Help', inits.red)
retryButton = classes.Button(screen, screenX / 2, 135, 100, 50, inits.black,
inits.arial30, 'Retry', inits.red)
quitButton = classes.Button(screen, screenX / 2, 265, 100, 50, inits.black,
inits.arial30, 'Quit', inits.red)
nextButton = classes.Button(screen, screenX - screenX / 4, 500, 100, 50,
inits.black, inits.arial30, 'Next', inits.red)
backButton = classes.Button(screen, screenX / 4, 500, 100, 50, inits.black,
inits.arial30, 'Back', inits.red)
exitButton = classes.Button(screen, 50, 10, 100, 50, inits.red, inits.arial30,
'Exit', inits.black)
helpScreenLine1 = classes.Text(screen, screenX / 2, 100, inits.arial30,
'helpScreenLine1', inits.black)
def menu(screen, board):
running = True
x, y, a, b = 0, 0, 0, 0
FPS = 120
choosen = '.'
clock = pygame.time.Clock()
button_continue = classes.Button((5, classes.HEIGHT - 205), 'Continue')
button_save = classes.Button((5, classes.HEIGHT - 155), 'Save Game')
button_settings = classes.Button((5, classes.HEIGHT - 105), 'Settings')
button_exit = classes.Button((5, classes.HEIGHT - 55), 'Exit')
buttons = [button_continue, button_save, button_settings, button_exit]
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit(0)
if event.type == pygame.MOUSEMOTION:
a, b = event.pos
for button in buttons:
button.crossing(event.pos)
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
return True
if event.type == pygame.MOUSEBUTTONDOWN:
x, y = event.pos
for button in buttons:
if button.crossing((x, y)):
choosen = button.press()
if choosen == 'Continue':
return True
if choosen == 'Save Game':
x, y = len(classes.board.board[0]), len(
classes.board.board)
data = ''
data_1 = '{} {}\n'.format(x, y)
data_2 = [['.'] * x for i in range(y)]
data_3 = str(classes.board.get_num())
for i in range(y):
for j in range(x):
if classes.board.board[i][j] != None:
if classes.board.board[i][
j].__class__ == classes.Town:
if classes.board.board[i][j].main_town:
data_2[i][j] = '@' + str(
classes.COLORS.index(classes.board.board[i][j].player.color) + 1) + '*'\
+ str(classes.board.board[i][j].build_actions) + '*'\
+ str(classes.board.board[i][j].life)
else:
data_2[i][j] = 'T' + str(
classes.COLORS.index(classes.board.board[i][j].player.color) + 1) + '*' \
+ str(classes.board.board[i][j].build_actions) + '*' \
+ str(classes.board.board[i][j].life)
if classes.board.board[i][
j].__class__ == classes.Gun:
data_2[i][j] = 'G' + str(
classes.COLORS.index(classes.board.board[i][j].player.color) + 1) + '*'\
+ str(classes.board.board[i][j].build_actions) + '*'\
+ str(classes.board.board[i][j].life)
if classes.board.board[i][
j].__class__ == classes.Block:
data_2[i][j] = 'B' + str(
classes.COLORS.index(classes.board.board[i][j].player.color) + 1) + '*'\
+ str(classes.board.board[i][j].build_actions) + '*'\
+ str(classes.board.board[i][j].life)
for j in range(1, x):
data_2[i][0] += ';' + data_2[i][j]
data += data_1
for i in range(len(data_2)):
data += data_2[i][0] + '\n'
data += data_3
fun.save_game(data)
if choosen == 'Settings':
settings.settings(screen)
if choosen == 'Exit':
return False
if event.type == pygame.MOUSEBUTTONUP:
for button in buttons:
button.unpress()
screen.fill((50, 50, 50))
board.update(screen)
for button in buttons:
button.render(screen)
if pygame.mouse.get_focused():
screen.blit(sprites.mouse.image, (a, b))
pygame.display.flip()
clock.tick(FPS)
width, height = size
running = True
x, y, a, b = 0, 0, 0, 0
choosen = '.'
clock = pygame.time.Clock()
screen = pygame.display.set_mode((width, height), fullscreen)
pygame.mouse.set_visible(0)
pygame.display.set_caption('BlockWars')
pygame.mixer.music.load('data/sound/track/BlockWarsSoundTrack.wav')
pygame.mixer.music.play(5)
pygame.mixer.music.set_volume(volume)
button_newgame = classes.Button((width // 2 - 125, height // 2 - 50),
'New Game')
button_loadgame = classes.Button((width // 2 - 125, height // 2 + 70 - 50),
'Load Game')
button_settings = classes.Button((width // 2 - 125, height // 2 + 140 - 50),
'Settings')
button_exit = classes.Button((width // 2 - 125, height // 2 + 210 - 50),
'Exit')
buttons = [button_newgame, button_loadgame, button_settings, button_exit]
image = pygame.transform.scale(sprites.BW.image, (width // 2, height // 4))
for lvl_preview in sprites.levels:
lvl_preview.image = pygame.transform.scale(
lvl_preview.image, (width // 2 - 50, height // 2 - 50))
while running:
def load_game_choose(width, height, fullscreen):
running = True
x, y, a, b = 0, 0, 0, 0
FPS = 60
choosen = '.'
clock = pygame.time.Clock()
pygame.mouse.set_visible(0)
screen_2 = pygame.display.set_mode((width, height), fullscreen)
button_start_game = classes.Button((int(width * 3 / 4) - classes.Button.size[1], int(height * 3 / 4)), 'Start Game')
button_back = classes.Button((width // 4, int(height * 3 / 4)), 'Back')
buttons = [button_start_game, button_back]
choose_text = 'Choose Level'
choosed_level = ''
levels = fun.find_levels()
font = classes.FONT
view_levels = classes.LevelView(levels, width // 2 - 10, height // 2 - 75, (width // 4 + 5, height // 4 + 75))
i, j = 0, 0
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit(0)
if event.type == pygame.MOUSEMOTION:
a, b = event.pos
for button in buttons:
button.crossing(event.pos)
view_levels.crossing(event.pos)
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
running = False
if event.type == pygame.MOUSEBUTTONDOWN:
x, y = event.pos
for button in buttons:
if button.crossing((x, y)):
choosen = button.press()
if choosen == 'Start Game':
if choosed_level != '':
fullname = os.path.join('data/saves/' + choosed_level)
game.game(width, height, fullscreen, fullname)
running = False
if choosen == 'Back':
running = False
if fun.crossing((width // 2, height // 4 + 40), (x, y)):
if j != 0:
view_levels.view_levels_up()
j -= 1
if i != 0:
i -= 1
if fun.crossing((width // 2, int((height * 3) / 4) - 25), (x, y)):
if j + view_levels.kol < len(view_levels.levels):
view_levels.view_levels_down()
j += 1
if i != view_levels.kol - 1:
i += 1
x = view_levels.crossing(event.pos)
if x is not None:
view_levels.press(x)
choosed_level = view_levels.view_levels[x]
for i in range(len(view_levels.levels)):
if view_levels.view_levels[i] != view_levels.view_levels[x]:
view_levels.view_levels_pressed[i] = False
else:
choosed_level = ''
if event.type == pygame.MOUSEBUTTONUP:
for button in buttons:
button.unpress()
screen_2.fill((40, 40, 40))
screen_2.fill((100, 100, 100), (width // 4, height // 4, width // 2, height // 2))
screen_2.blit(font.render(choose_text, True, pygame.Color('white')), (width // 2 - 50, height // 4 + 17))
if j != 0:
screen_2.blit(sprites.up.image, (width // 2, height // 4 + 40))
if j + view_levels.kol < len(view_levels.levels) and len(view_levels.levels) > view_levels.kol:
screen_2.blit(sprites.down.image, (width // 2, int((height * 3) / 4) - 25))
for button in buttons:
button.render(screen_2)
view_levels.view_levels_update(screen_2)
if pygame.mouse.get_focused():
screen_2.blit(sprites.mouse.image, (a, b))
pygame.display.flip()
clock.tick(FPS)
