extends Node @export var pion_alb_scene : PackedScene @export var pion_negru_scene : PackedScene @export var cadran_negru_scene : PackedScene @export var cadran_alb_scene : PackedScene @export var tura_neagra_scene: PackedScene @export var cal_negru_scene: PackedScene @export var nebun_negru_scene: PackedScene @export var regina_neagra_scene: PackedScene @export var rege_negru_scene: PackedScene @export var tura_alba_scene: PackedScene @export var cal_alb_scene: PackedScene @export var nebun_alb_scene: PackedScene @export var regina_alba_scene: PackedScene @export var rege_alb_scene: PackedScene var player : int var pasi : int var piesa : int var board_size : int var cell_size : int var grid_pos : Vector2i var grid_data : Array # matrice 8 pe 8 var start_pos : Vector2i # retine primul click dat / piesa pe care se doreste a muta var start_piesa : int var temp_marker var enemy : Vector2i # ajuta la retinerea valorilor pieselor inamice var ally : Vector2i var piesa_mutare : int var transformare_pion = false var piese_albe = [] var piese_negre = [] var pos_rege_alb : Vector2i var pos_rege_negru : Vector2i var pos_rege_actual : Vector2i #cand simulez o mutare pentru a verifica daca pune regele in sah #in grid_data la pozitia de start pun ca si gol #pozitia unde se doreste deplasarea preia valoarea piesei de mutat #la pozitia unde se deoreste deplasarea se poate afla o piesa inamica, aceea trebuie salvata #de aici vine "piesa_capturata" var piesa_capturata : int var numar_mutari_incercate : int var player_care_a_incercat_o_miscare_precedent : int # Called when the node enters the scene tree for the first time. func _ready(): board_size = 788 + 4 # imparte board_size la 8 pentru a obtine dimensiunea fiecarei celule cell_size = board_size / 8 new_game() piesa_mutare = 100 # valoare aberanta #modul in care am gandit sfarsitul jocului #imi e imposibil sa stiu cand se da un sah mat # prin cod, regele nu se poate muta intr=o pozitie care il pune in sah # o piesa nu se poate deplasa daca isi lasa descoperit in sah regele aliat # daca regele se afla in sah, player-ul este obligat sa mute o piesa astfel incat sa iasa din sah altfel nu poate executa mutarea #MODUL DE SFARSIRE JOC (pentru piese albe, e mai usor de explicat) #jucatorul alb are la dispozitei 4 incercari de a deplasa o piesa, daca nu reuseste, se considera sah mat # _input(event) este functia principala unde se intampla magia func _input(event): if numar_mutari_incercate == 5: get_tree().paused=true $MeniuGameOver.show() if player == 1: $MeniuGameOver/LabelCastigator.text="Piesele negre au câștigat!" else: $MeniuGameOver/LabelCastigator.text="Piesele albe au câștigat!" if event is InputEventMouseButton : if event.button_index == MOUSE_BUTTON_LEFT and event.pressed : #verifica daca mouse-ul e pe tabla de joc if event.position.x < board_size: #convertire pozitie mouse in locatie grid grid_pos = Vector2i(event.position / cell_size) # grid_pos memoreza [coloana, linie] transformare_pion = false var auxiliar : Vector2i if player == 1: pos_rege_actual = pos_rege_alb else: pos_rege_actual = pos_rege_negru if player_care_a_incercat_o_miscare_precedent == player and pasi ==2: print("SAU EXECUTAT ", numar_mutari_incercate, " INCERCARI" ) if numar_mutari_incercate == 5 and se_afla_in_sah(pos_rege_actual) == true: print("") print("GAME OVER< PLAYERUL: ",player," A PIERDUT!!!!!!!!!!!!!!!!!!!!") numar_mutari_incercate +=1 elif player_care_a_incercat_o_miscare_precedent != player: player_care_a_incercat_o_miscare_precedent = player numar_mutari_incercate = 1 #miscari pentru pion alb if grid_data[grid_pos.y][grid_pos.x][0] == 6 and pasi == 1 and player == 1: selectare_piesa() piesa_mutare = grid_data[grid_pos.y][grid_pos.x][0] #deplasare pion alb elif grid_pos != start_pos and grid_data[grid_pos.y][grid_pos.x][0] <= 0 and piesa_mutare == 6 and pasi ==2: # in grid_data sterg pozitia initiala a pionului, si o marchez pe cea finala grid_data[start_pos.y][start_pos.x][0] = 0 piesa_capturata = grid_data[grid_pos.y][grid_pos.x][0] grid_data[grid_pos.y][grid_pos.x][0] = piesa_mutare #verific daca teoretica mutare pune in pericol regele print("pozitia regelui alb este " , pos_rege_alb) if se_afla_in_sah(pos_rege_alb) == true: # se anuleaza mutarea print("mutarea pionului pune in pericol regele alb ") # restitui grid_data asa cum a fost grid_data[start_pos.y][start_pos.x][0] = piesa_mutare grid_data[grid_pos.y][grid_pos.x][0] = piesa_capturata else: #restitui grid_data asa cum a fost grid_data[start_pos.y][start_pos.x][0] = piesa_mutare grid_data[grid_pos.y][grid_pos.x][0] = piesa_capturata #execut mutarea deplasare_pion_alb() #miscari pt pion negru if grid_data[grid_pos.y][grid_pos.x][0] == -6 and pasi == 1 and player == -1 : selectare_piesa() piesa_mutare = grid_data[grid_pos.y][grid_pos.x][0] #deplasare pion negru elif grid_pos != start_pos and grid_data[grid_pos.y][grid_pos.x][0] >= 0 and piesa_mutare == -6 and pasi == 2: # in grid_data sterg pozitia initiala a pionului, si o marchez pe cea finala grid_data[start_pos.y][start_pos.x][0] = 0 piesa_capturata = grid_data[grid_pos.y][grid_pos.x][0] # retin ce se afla pe pozitia unde se doreste mutarea grid_data[grid_pos.y][grid_pos.x][0] = piesa_mutare #verific daca teoretica mutare pune in pericol regele print("pozitia regelui negru este " , pos_rege_negru) if se_afla_in_sah(pos_rege_negru) == true: # se anuleaza mutarea print("mutarea pionului pune in pericol regele negru ") # restitui grid_data asa cum a fost grid_data[start_pos.y][start_pos.x][0] = piesa_mutare grid_data[grid_pos.y][grid_pos.x][0] = piesa_capturata else: #restitui grid_data asa cum a fost grid_data[start_pos.y][start_pos.x][0] = piesa_mutare grid_data[grid_pos.y][grid_pos.x][0] = piesa_capturata #execut mutarea deplasare_pion_negru() for i in range (1,6): if grid_data[grid_pos.y][grid_pos.x][0] == i*player and pasi == 1 : selectare_piesa() piesa_mutare = grid_data[grid_pos.y][grid_pos.x][0] break elif grid_pos != start_pos and grid_data[grid_pos.y][grid_pos.x][0] >= enemy.x and grid_data[grid_pos.y][grid_pos.x][0] <= enemy.y and piesa_mutare == i*player or\ grid_pos != start_pos and grid_data[grid_pos.y][grid_pos.x][0] == 0 and piesa_mutare == i*player: if pasi == 2: if piesa_mutare == 2 or piesa_mutare == -2: # in grid_data sterg pozitia initiala a pionului, si o marchez pe cea finala grid_data[start_pos.y][start_pos.x][0] = 0 piesa_capturata = grid_data[grid_pos.y][grid_pos.x][0] # retin ce se afla pe pozitia unde se doreste mutarea grid_data[grid_pos.y][grid_pos.x][0] = piesa_mutare #verific daca teoretica mutare pune in pericol regele if se_afla_in_sah(grid_pos) == true: # regele nu se poate muta intr-o pozitie daca se pune in sah print("Mutarea pune in pericol regele ") # restitui grid_data asa cum a fost grid_data[start_pos.y][start_pos.x][0] = piesa_mutare grid_data[grid_pos.y][grid_pos.x][0] = piesa_capturata else: #restitui grid_data asa cum a fost grid_data[start_pos.y][start_pos.x][0] = piesa_mutare grid_data[grid_pos.y][grid_pos.x][0] = piesa_capturata #execut mutarea var verificare = deplasare_rege() if verificare == true: if player == -1: pos_rege_alb = grid_pos print("regele alb se deplaseaza la pozitia", grid_pos) elif player == 1: pos_rege_negru = grid_pos print("regele negru se deplaseaza la pozitia", grid_pos) else: # in grid_data sterg pozitia initiala a pionului, si o marchez pe cea finala grid_data[start_pos.y][start_pos.x][0] = 0 piesa_capturata = grid_data[grid_pos.y][grid_pos.x][0] # retin ce se afla pe pozitia unde se doreste mutarea grid_data[grid_pos.y][grid_pos.x][0] = piesa_mutare #verific daca teoretica mutare pune in pericol regele print("pozitia regelui este " , pos_rege_actual) if se_afla_in_sah(pos_rege_actual) == true: # se anuleaza mutarea print("mutarea pune in pericol regele jucatorului ",player ) # restitui grid_data asa cum a fost grid_data[start_pos.y][start_pos.x][0] = piesa_mutare grid_data[grid_pos.y][grid_pos.x][0] = piesa_capturata else: #restitui grid_data asa cum a fost grid_data[start_pos.y][start_pos.x][0] = piesa_mutare grid_data[grid_pos.y][grid_pos.x][0] = piesa_capturata #execut mutarea if piesa_mutare == 1 or piesa_mutare == -1: deplasare_regina() elif piesa_mutare == 3 or piesa_mutare == -3: luare_piesa_diagonala() elif piesa_mutare == 4 or piesa_mutare == -4: deplasare_cal() elif piesa_mutare == 5 or piesa_mutare == -5: luare_piesa_linie_coloana() if event.button_index == MOUSE_BUTTON_RIGHT and event.pressed : piesa_mutare = 99 pasi = 1 print("ATENTIE CLICK DREAPTA DE LA MOUSE ANULEAZA PIESA SELECTATA") func new_game(): enemy = Vector2i(-6,-1) ally = Vector2i(1,6) pos_rege_alb = Vector2i(0,3) pos_rege_negru = Vector2i(7,3) $MeniuGameOver.hide() get_tree().paused=false player = 1 player_care_a_incercat_o_miscare_precedent = 1 numar_mutari_incercate = 1 #trebuie sterse toate piesele de la jocul anterior var i = 0 while piese_albe.size() > 0 : piese_albe[i].queue_free() piese_albe.remove_at(i) while piese_negre.size() > 0 : piese_negre[i].queue_free() piese_negre.remove_at(i) piese_albe.clear() piese_negre.clear() # [5,1] a doua valoare marcheaza culoarea chenarului tablei de joc, 7 = negru, 8 = alb grid_data = [ [[5,7], [6,8], [0,7], [0,8], [0,7], [0,8], [-6,7], [-5,8]], [[4,8], [6,7], [0,8], [0,7], [0,8], [0,7], [-6,8], [-4,7]], [[3,7], [6,8], [0,7], [0,8], [0,7], [0,8], [-6,7], [-3,8]], [[2,8], [6,7], [0,8], [0,7], [0,8], [0,7], [-6,8], [-2,7]], [[1,7], [6,8], [0,7], [0,8], [0,7], [0,8], [-6,7], [-1,8]], [[3,8], [6,7], [0,8], [0,7], [0,8], [0,7], [-6,8], [-3,7]], [[4,7], [6,8], [0,7], [0,8], [0,7], [0,8], [-6,7], [-4,8]], [[5,8], [6,7], [0,8], [0,7], [0,8], [0,7], [-6,8], [-5,7]] ] pasi = 1 # punerea pionilor albi pe tabla create_marker(6, Vector2i(1,0) * cell_size + Vector2i(cell_size /2, cell_size /2 )) create_marker(6, Vector2i(1,1) * cell_size + Vector2i(cell_size /2, cell_size /2 )) create_marker(6, Vector2i(1,2) * cell_size + Vector2i(cell_size /2, cell_size /2 )) create_marker(6, Vector2i(1,3) * cell_size + Vector2i(cell_size /2, cell_size /2 )) create_marker(6, Vector2i(1,4) * cell_size + Vector2i(cell_size /2, cell_size /2 )) create_marker(6, Vector2i(1,5) * cell_size + Vector2i(cell_size /2, cell_size /2 )) create_marker(6, Vector2i(1,6) * cell_size + Vector2i(cell_size /2, cell_size /2 )) create_marker(6, Vector2i(1,7) * cell_size + Vector2i(cell_size /2, cell_size /2 )) #punerea pionilor negri pe tabla create_marker(-6, Vector2i(6,0) * cell_size + Vector2i(cell_size /2, cell_size /2 )) create_marker(-6, Vector2i(6,1) * cell_size + Vector2i(cell_size /2, cell_size /2 )) create_marker(-6, Vector2i(6,2) * cell_size + Vector2i(cell_size /2, cell_size /2 )) create_marker(-6, Vector2i(6,3) * cell_size + Vector2i(cell_size /2, cell_size /2 )) create_marker(-6, Vector2i(6,4) * cell_size + Vector2i(cell_size /2, cell_size /2 )) create_marker(-6, Vector2i(6,5) * cell_size + Vector2i(cell_size /2, cell_size /2 )) create_marker(-6, Vector2i(6,6) * cell_size + Vector2i(cell_size /2, cell_size /2 )) create_marker(-6, Vector2i(6,7) * cell_size + Vector2i(cell_size /2, cell_size /2 )) #punerea turelor negre create_marker(-5, Vector2i(7,0) * cell_size + Vector2i(cell_size /2, cell_size /2)) create_marker(-5, Vector2i(7,7) * cell_size + Vector2i(cell_size /2, cell_size /2)) #punerea cailor negri create_marker(-4, Vector2i(7,1) * cell_size + Vector2i(cell_size /2, cell_size /2)) create_marker(-4, Vector2i(7,6) * cell_size + Vector2i(cell_size /2, cell_size /2)) #punerea nebunilor negri create_marker(-3, Vector2i(7,2) * cell_size + Vector2i(cell_size /2, cell_size /2)) create_marker(-3, Vector2i(7,5) * cell_size + Vector2i(cell_size /2, cell_size /2)) #punerea reginei si a regelui negru create_marker(-1, Vector2i(7,4) * cell_size + Vector2i(cell_size /2, cell_size /2)) create_marker(-2, Vector2i(7,3) * cell_size + Vector2i(cell_size /2, cell_size /2)) #punerea turelor albe create_marker(5, Vector2i(0,0) * cell_size + Vector2i(cell_size /2, cell_size /2)) create_marker(5, Vector2i(0,7) * cell_size + Vector2i(cell_size /2, cell_size /2)) #punerea cailor albi create_marker(4, Vector2i(0,1) * cell_size + Vector2i(cell_size /2, cell_size /2)) create_marker(4, Vector2i(0,6) * cell_size + Vector2i(cell_size /2, cell_size /2)) #punerea nebunilor albi create_marker(3, Vector2i(0,2) * cell_size + Vector2i(cell_size /2, cell_size /2)) create_marker(3, Vector2i(0,5) * cell_size + Vector2i(cell_size /2, cell_size /2)) #punerea reginei si a regelui alb create_marker(1, Vector2i(0,4) * cell_size + Vector2i(cell_size /2, cell_size /2)) create_marker(2, Vector2i(0,3) * cell_size + Vector2i(cell_size /2, cell_size /2)) #create_marker realizeaza creerea unui nod child al piesei specificate la pozitia specificata si il salveaza intr_o lista # piese_albe sau piese_negre in functie de culoarea acesteia func create_marker(piesa, position) : #creaza un marcker node si il adauga ca un child if piesa==-1: var regina_neagra = regina_neagra_scene.instantiate() regina_neagra.position=position add_child(regina_neagra) piese_negre.append(regina_neagra) if piesa==-2: var rege_negru = rege_negru_scene.instantiate() rege_negru.position=position add_child(rege_negru) piese_negre.append(rege_negru) if piesa==-3: var nebun_negru = nebun_negru_scene.instantiate() nebun_negru.position=position add_child(nebun_negru) piese_negre.append(nebun_negru) if piesa ==-4: var cal_negru = cal_negru_scene.instantiate() cal_negru.position=position add_child(cal_negru) piese_negre.append(cal_negru) if piesa == -5: var tura_neagra = tura_neagra_scene.instantiate() tura_neagra.position = position add_child(tura_neagra) piese_negre.append(tura_neagra) if piesa == -6 : var pion_negru = pion_negru_scene.instantiate() pion_negru.position = position add_child(pion_negru) piese_negre.append(pion_negru) if piesa==1: var regina_alba=regina_alba_scene.instantiate() regina_alba.position=position add_child(regina_alba) piese_albe.append(regina_alba) if piesa==2: var rege_alb=rege_alb_scene.instantiate() rege_alb.position=position add_child(rege_alb) piese_albe.append(rege_alb) if piesa==3: var nebun_alb=nebun_alb_scene.instantiate() nebun_alb.position=position add_child(nebun_alb) piese_albe.append(nebun_alb) if piesa==4: var cal_alb=cal_alb_scene.instantiate() cal_alb.position=position add_child(cal_alb) piese_albe.append(cal_alb) if piesa == 5: var tura_alba = tura_alba_scene.instantiate() tura_alba.position=position add_child(tura_alba) piese_albe.append(tura_alba) if piesa == 6 : var pion_alb = pion_alb_scene.instantiate() pion_alb.position = position add_child(pion_alb) piese_albe.append(pion_alb) if piesa == 7 : var cadran_negru = cadran_negru_scene.instantiate() cadran_negru.position = position add_child((cadran_negru)) if piesa == 8 : var cadran_alb = cadran_alb_scene.instantiate() cadran_alb.position = position add_child((cadran_alb)) func selectare_piesa(): start_piesa = grid_data[grid_pos.y][grid_pos.x][0] start_pos = grid_pos print(" ") print("player", player, "a apasat pe chenarul ", grid_pos ) print("a fost selectata piesa ", start_piesa) pasi = 2 func deplasare_piesa(): var index var index2 = 100 piesa_capturata = 0 if player == 1: #aflu care este piesa alba din memorie for i in range(piese_albe.size()): if Vector2i(piese_albe[i].position.x, piese_albe[i].position.y ) == start_pos * cell_size + Vector2i(cell_size /2, cell_size /2 ): print("este vorba de pionul", i) index = i break #caut daca pe pozitia finala exista o piesa neagra for i in range(piese_negre.size()): if Vector2i(piese_negre[i].position.x, piese_negre[i].position.y ) == grid_pos * cell_size + Vector2i(cell_size /2, cell_size /2 ): index2 = i break #stergere din matrice pozitia veche a piesei albe grid_data[start_pos.y][start_pos.x][0] = 0 if index2 != 100: # a fost gasita o piesa neagra, aceasta trebuei stearsa piese_negre[index2].queue_free() piese_negre.remove_at(index2) piesa_capturata = grid_data[grid_pos.y][grid_pos.x][0] #marcare noua pozitie a piesei albe in memoria matricei grid_data[grid_pos.y][grid_pos.x][0] = start_piesa #demarcare vechea pozitie a piesei prin deplasarea acesteia piese_albe[index].position = grid_pos * cell_size + Vector2i(cell_size /2, cell_size /2 ) elif player == -1: for i in range(piese_negre.size()): if Vector2i(piese_negre[i].position.x, piese_negre[i].position.y ) == start_pos * cell_size + Vector2i(cell_size /2, cell_size /2 ): print("este vorba de pionul", i) index = i break #caut daca pe pozitia finala exista o piesa alba for i in range(piese_albe.size()): if Vector2i(piese_albe[i].position.x, piese_albe[i].position.y ) == grid_pos * cell_size + Vector2i(cell_size /2, cell_size /2 ): index2 = i break #stergere din matrice pozitia veche a piesei negre grid_data[start_pos.y][start_pos.x][0] = 0 if index2 != 100: # a fost gasita o piesa alba, aceasta trebuei stearsa piese_albe[index2].queue_free() piese_albe.remove_at(index2) piesa_capturata = grid_data[grid_pos.y][grid_pos.x][0] #marcare noua pozitie a piesei negre in memoria matricei grid_data[grid_pos.y][grid_pos.x][0] = start_piesa #demarcare vechea pozitie a piesei prin deplasarea acesteia piese_negre[index].position = grid_pos * cell_size + Vector2i(cell_size /2, cell_size /2 ) print(grid_pos) print(grid_data) pasi = 1 player *= -1 set_ally_and_enemy() func set_ally_and_enemy(): if player == 1: enemy = Vector2i(-6,-1) ally = Vector2i(1,6) else : enemy = Vector2i(1,6) ally = Vector2i(-6,-1) #functiile deplasare_inainte_pion_alb() si deplasare_diagonala_pion_alb() sunt unite in functia deplasare_pion_alb() func deplasare_inainte_pion_alb(): if grid_pos.x == start_pos.x + 1 and grid_pos.y == start_pos.y : if pasi == 2: deplasare_piesa() if grid_pos.x == 7: #trebuie sters pionul de pe tabla var index = 100 for i in range(piese_albe.size()): if Vector2i(piese_albe[i].position.x, piese_albe[i].position.y ) == grid_pos * cell_size + Vector2i(cell_size /2, cell_size /2 ): index = i break if index != 100: # a fost gasita o piesa alba, aceasta trebuei stearsa piese_albe[index].queue_free() piese_albe.remove_at(index) create_marker(1, grid_pos * cell_size + Vector2i(cell_size /2, cell_size /2) ) grid_data[grid_pos.y][grid_pos.x][0] = 1 transformare_pion = true elif grid_pos.x == start_pos.x + 2 and grid_pos.y == start_pos.y and start_pos.x == 1 and grid_data[start_pos.y][start_pos.x + 1][0] == 0 : if pasi == 2 : deplasare_piesa() func capturare_diagonala_pion_alb(): if grid_pos.x == start_pos.x + 1 and grid_pos.y == start_pos.y + 1 or grid_pos.x == start_pos.x + 1 and grid_pos.y == start_pos.y - 1 : if pasi == 2: deplasare_piesa() if grid_pos.x == 7: #trebuie sters pionul de pe tabla var index = 100 for i in range(piese_albe.size()): if Vector2i(piese_albe[i].position.x, piese_albe[i].position.y ) == grid_pos * cell_size + Vector2i(cell_size /2, cell_size /2 ): index = i break if index != 100: # a fost gasita o piesa alba, aceasta trebuei stearsa piese_albe[index].queue_free() piese_albe.remove_at(index) create_marker(1, grid_pos * cell_size + Vector2i(cell_size /2, cell_size /2) ) grid_data[grid_pos.y][grid_pos.x][0] = 1 transformare_pion = true func deplasare_pion_alb(): if grid_pos != start_pos and grid_data[grid_pos.y][grid_pos.x][0] == 0: deplasare_inainte_pion_alb() elif grid_pos != start_pos and grid_data[grid_pos.y][grid_pos.x][0] <0: capturare_diagonala_pion_alb() #functiile deplasare_inainte_pion_negru() si deplasare_diagonala_pion_negru() sunt unite in functia deplasare_pion_negru() func deplasare_inainte_pion_negru(): if grid_pos.x == start_pos.x - 1 and grid_pos.y == start_pos.y : if pasi == 2: deplasare_piesa() if grid_pos.x == 0: #trebuie sters pionul de pe tabla var index = 100 for i in range(piese_negre.size()): if Vector2i(piese_negre[i].position.x, piese_negre[i].position.y ) == grid_pos * cell_size + Vector2i(cell_size /2, cell_size /2 ): index = i break if index != 100: # a fost gasita o piesa alba, aceasta trebuei stearsa piese_negre[index].queue_free() piese_negre.remove_at(index) create_marker(-1, grid_pos * cell_size + Vector2i(cell_size /2, cell_size /2) ) grid_data[grid_pos.y][grid_pos.x][0] = -1 transformare_pion = true elif grid_pos.x == start_pos.x - 2 and grid_pos.y == start_pos.y and start_pos.x == 6 and grid_data[start_pos.y][start_pos.x - 1][0] == 0 : if pasi == 2 : deplasare_piesa() func capturare_diagonala_pion_negru(): if grid_pos.x == start_pos.x - 1 and grid_pos.y == start_pos.y + 1 or grid_pos.x == start_pos.x - 1 and grid_pos.y == start_pos.y - 1 : if pasi == 2: deplasare_piesa() if grid_pos.x == 0: #trebuie sters pionul de pe tabla var index = 100 for i in range(piese_negre.size()): if Vector2i(piese_negre[i].position.x, piese_negre[i].position.y ) == grid_pos * cell_size + Vector2i(cell_size /2, cell_size /2 ): index = i break if index != 100: # a fost gasita o piesa alba, aceasta trebuei stearsa piese_negre[index].queue_free() piese_negre.remove_at(index) create_marker(-1, grid_pos * cell_size + Vector2i(cell_size /2, cell_size /2) ) grid_data[grid_pos.y][grid_pos.x][0] = -1 transformare_pion = true func deplasare_pion_negru(): if grid_pos != start_pos and grid_data[grid_pos.y][grid_pos.x][0] == 0: deplasare_inainte_pion_negru() elif grid_pos != start_pos and grid_data[grid_pos.y][grid_pos.x][0] >0: capturare_diagonala_pion_negru() #functiile luare_piesa_linie() si luare_piesa_coloana() sunt unite in functia luare_piesa_linie_coloana() # functia luare_piesa_linie_coloana se refera la deplasarea turei si la capturarea pieselor de catrea aceasta func luare_piesa_linie(): # capturare piesa adversa pe linie var sens = 0 if grid_pos.y == start_pos.y: print("esti in fucntia luare_piesa_linie") if grid_pos.x >= start_pos.x: sens = 1 print("Sensul este ", sens) print("aliati player-ului ",player, " sunt ", ally ) for i in range(start_pos.x + 1,grid_pos.x + 1, sens): print(i) print("esti in for loop") # detecteaza inamici pe if grid_data[grid_pos.y][i][0] >= enemy.x and grid_data[grid_pos.y][i][0] <= enemy.y : grid_pos.x = i print("Tura a intalnit un inamic in drum") print("tura ramane pe pozitia cu grid_pos.x = ", i, " si grid_pos.y = ", grid_pos.y) break if grid_data[grid_pos.y][i][0] >= ally.x and grid_data[grid_pos.y][i][0] <= ally.y : grid_pos.x = i - 1 print("Tura a intalnic un aliat in drum") print("tura ramane pe pozitia cu grid_pos.x = ", i, " si grid_pos.y = ", grid_pos.y) break else: sens = -1 print("Sensul este ", sens) print("aliati player-ului ",player, " sunt ", ally ) for i in range(start_pos.x - 1 ,grid_pos.x - 1, sens): print(i) print("Esti in for loop") # detecteaza inamici pe if grid_data[grid_pos.y][i][0] >= enemy.x and grid_data[grid_pos.y][i][0] <= enemy.y : grid_pos.x = i print("Tura a intalnit un inamic in drum") print("tura ramane pe pozitia cu grid_pos.x = ", i, " si grid_pos.y = ", grid_pos.y) break if grid_data[grid_pos.y][i][0] >= ally.x and grid_data[grid_pos.y][i][0] <= ally.y : grid_pos.x = i + 1 print("Tura a intalnic un aliat in drum") print("tura ramane pe pozitia cu grid_pos.x = ", i, " si grid_pos.y = ", grid_pos.y) break if grid_pos != start_pos: deplasare_piesa() else: pasi = 2 # se permite iar mutarea deoarece prima nu a produs nici-o miscare print("parasire functie luare_piesa_linie") func luare_piesa_coloana(): #capturare piesa pe coloanna var sens = 0 if grid_pos.x == start_pos.x: print("esti in functia luare_piesa_coloana") if grid_pos.y >= start_pos.y: sens = 1 print("Sensul este ", sens) print("aliati player-ului ",player, " sunt ", ally ) for i in range(start_pos.y + 1,grid_pos.y + 1, sens): print(i) print("esti in for loop") if grid_data[i][grid_pos.x][0] >= enemy.x and grid_data[i][grid_pos.x][0] <= enemy.y : grid_pos.y = i print("Tura a intalnit un inamic in drum") print("tura ramane pe pozitia cu grid_pos.x = ", grid_pos.x, " si grid_pos.y = ", i) break if grid_data[i][grid_pos.x][0] >= ally.x and grid_data[i][grid_pos.x][0] <= ally.y : grid_pos.x = i - 1 print("Tura a intalnic un aliat in drum") print("tura ramane pe pozitia cu grid_pos.x = ", grid_pos.x, " si grid_pos.y= ", i) break else: sens = -1 print("Sensul este ", sens) print("aliati player-ului ",player, " sunt ", ally ) for i in range(start_pos.y - 1,grid_pos.y -1,sens): print(i) print("Esti in for loop") if grid_data[i][grid_pos.x][0] >= enemy.x and grid_data[i][grid_pos.x][0] <= enemy.y : grid_pos.y = i print("Tura a intalnit un inamic in drum") print("tura ramane pe pozitia cu grid_pos.x = ", grid_pos.x, " si grid_pos.y = ", i) break if grid_data[i][grid_pos.x][0] >= ally.x and grid_data[i][grid_pos.x][0] <= ally.y : grid_pos.y = i + 1 print("tura ramane pe pozitia cu grid_pos.x = ", grid_pos.x, " si grid_pos.y = ", i) print("Tura a intalnic un aliat in drum") break if grid_pos != start_pos: deplasare_piesa() else: pasi = 2 # se permite iar mutarea deoarece prima nu a produs nici-o miscare print("parasirea functie luare_piesa_coloana") func luare_piesa_linie_coloana(): luare_piesa_linie() luare_piesa_coloana() print("parasier functie luare_piesa_linie_coloana") #functia deplasare_cal() verifica daca pozitia indicata de player este aceasi cu una dintre cele 8 mutari posibile ale calului #daca pe acea pozitie se afla o piesa adversara sau este o pozitie goala, se executa mutarea func deplasare_cal(): var sens = 1 # deplasare la dreapta de poz initiala cal print(" ") print("intrare infunctia deplasare_cal") #verificare mutare ca fiind pe tabla if grid_pos.x >= 0 and grid_pos.x <=7 and grid_pos.y >= 0 and grid_pos.y <=7 : print("Mutarea apare pe tabla: (linie,coloana) ", grid_pos.y, " ", grid_pos.x ) #verificare mutari partea dreapta fata de poz initiala cal #verificare mutare (linie , coloana) (-2, +1) if grid_pos.x == start_pos.x + (1*sens) and grid_pos.y == start_pos.y -2 : print("calul este mutat la pozitia (linie,coloana) ", grid_pos.y, " ", grid_pos.x ) deplasare_piesa() #verificare mutare (-1, +2) if grid_pos.x == start_pos.x + (2*sens) and grid_pos.y == start_pos.y -1 : print("calul este mutat la pozitia (linie,coloana) ", grid_pos.y, " ", grid_pos.x ) deplasare_piesa() #verificare mutare (+1, +2) if grid_pos.x == start_pos.x + (2*sens) and grid_pos.y == start_pos.y +1 : print("calul este mutat la pozitia (linie,coloana) ", grid_pos.y, " ", grid_pos.x ) deplasare_piesa() #verificare mutare(+2,+1) if grid_pos.x == start_pos.x + (1*sens) and grid_pos.y == start_pos.y +2 : print("calul este mutat la pozitia (linie,coloana) ", grid_pos.y, " ", grid_pos.x ) deplasare_piesa() sens = -1 #verificare mutari partea stanga #verificare mutare (linie , coloana) (-2, -1) if grid_pos.x == start_pos.x + (1*sens) and grid_pos.y == start_pos.y -2 : print("calul este mutat la pozitia (linie,coloana) ", grid_pos.y, " ", grid_pos.x ) deplasare_piesa() #verificare mutare (-1, -2) if grid_pos.x == start_pos.x + (2*sens) and grid_pos.y == start_pos.y -1 : print("calul este mutat la pozitia (linie,coloana) ", grid_pos.y, " ", grid_pos.x ) deplasare_piesa() #verificare mutare (+1, -2) if grid_pos.x == start_pos.x + (2*sens) and grid_pos.y == start_pos.y +1 : print("calul este mutat la pozitia (linie,coloana) ", grid_pos.y, " ", grid_pos.x ) deplasare_piesa() #verificare mutare(+2,-1) if grid_pos.x == start_pos.x + (1*sens) and grid_pos.y == start_pos.y +2 : print("calul este mutat la pozitia (linie,coloana) ", grid_pos.y, " ", grid_pos.x ) deplasare_piesa() # functia luare_piesa_diagonala() verifica daca pozitia indicata de player se afla in diagonala cu pozitia piesei # si apoi verifica daca de la piesa pana la pozitia indicata se gaseste alta piesa care ii blocheaza calea # daca este o piesa inamica, o captureaza si ii ocupa pozitia #daca este o piesa aliata, ocupa un patratel inaintea ei func luare_piesa_diagonala(): var dx = abs(grid_pos.x - start_pos.x) var dy = abs(grid_pos.y - start_pos.y) #verific daca pozitia data este pe diagonala cu pozitia initiala if dx == dy and dx > 0 : if grid_pos.y < start_pos.y and grid_pos.x > start_pos.x : print("pozitie initiala la diagonala dreapta sus") print("esti in for loop") for i in range(1,8): if(start_pos.x + i > 7): print(" break deoarece start_pos.x + i > 7") break if(start_pos.x + i > grid_pos.x): print("break deoarece start_pos.x + i > grid_pos.x") break if(start_pos.y - i < 0): print(" break deoarece start_pos.y - i < 0") break if(start_pos.y - i < grid_pos.y): print("break deoarece start_pos.y - i < grid_pos.y") break print(i) # detecteaza inamici if grid_data[start_pos.y - i][start_pos.x + i][0] >= enemy.x and grid_data[start_pos.y - i][start_pos.x + i][0] <= enemy.y : grid_pos.x = start_pos.x + i grid_pos.y = start_pos.y - i print("Nebunul a intalnit un inamic in drum") print("Nebunul ramane pe pozitia cu grid_pos.x = ", grid_pos.x, " si grid_pos.y = ", grid_pos.y) break #detecteaza aliat if grid_data[start_pos.y - i][start_pos.x + i][0] >= ally.x and grid_data[start_pos.y - i][start_pos.x + i][0] <= ally.y : grid_pos.x = start_pos.x + i - 1 grid_pos.y = start_pos.y - i + 1 print("Nebunul a intalnic un aliat in drum") print("Nebunul ramane pe pozitia cu grid_pos.x = ", grid_pos.x, " si grid_pos.y = ", grid_pos.y) break elif grid_pos.y > start_pos.y and grid_pos.x < start_pos.x: # pozitie initiala la diagonala stanga jos print("pozitie initiala la diagonala stanga jos") print("esti in for loop") for i in range(1,8): if(start_pos.y + i > 7): print(" break deoarece start_pos.y + i > 7") break if(start_pos.y + i > grid_pos.y): print("break deoarece start_pos.y + i > grid_pos.x") break if(start_pos.x - i < 0): print(" break deoarece start_pos.x - i < 0") break if(start_pos.x - i < grid_pos.x): print("break deoarece start_pos.x - i < grid_pos.x") break print(i) # detecteaza inamici if grid_data[start_pos.y + i][start_pos.x - i][0] >= enemy.x and grid_data[start_pos.y + i][start_pos.x - i][0] <= enemy.y : grid_pos.x = start_pos.x - i grid_pos.y = start_pos.y + i print("Nebunul a intalnit un inamic in drum") print("Nebunul ramane pe pozitia cu grid_pos.x = ", grid_pos.x, " si grid_pos.y = ", grid_pos.y) break #detecteaza aliat if grid_data[start_pos.y + i][start_pos.x - i][0] >= ally.x and grid_data[start_pos.y + i][start_pos.x - i][0] <= ally.y : grid_pos.x = start_pos.x - i + 1 grid_pos.y = start_pos.y + i - 1 print("Nebunul a intalnic un aliat in drum") print("Nebunul ramane pe pozitia cu grid_pos.x = ", grid_pos.x, " si grid_pos.y = ", grid_pos.y) break elif grid_pos.y > start_pos.y and grid_pos.x > start_pos.x : print("pozitie initiala la diagonala dreapta jos") print("esti in for loop") for i in range(1,8): if(start_pos.x + i > 7): print(" break deoarece start_pos.x + i > 7") break if(start_pos.x + i > grid_pos.x): print("break deoarece start_pos.x + i > grid_pos.x") break print(i) # detecteaza inamici if grid_data[start_pos.y + i][start_pos.x + i][0] >= enemy.x and grid_data[start_pos.y + i][start_pos.x + i][0] <= enemy.y : grid_pos.x = start_pos.x + i grid_pos.y = start_pos.y + i print("Nebunul a intalnit un inamic in drum") print("Nebunul ramane pe pozitia cu grid_pos.x = ", grid_pos.x, " si grid_pos.y = ", grid_pos.y) break #detecteaza aliat if grid_data[start_pos.y + i][start_pos.x + i][0] >= ally.x and grid_data[start_pos.y + i][start_pos.x + i][0] <= ally.y : grid_pos.x = start_pos.x + i - 1 grid_pos.y = start_pos.y + i - 1 print("Nebunul a intalnic un aliat in drum") print("Nebunul ramane pe pozitia cu grid_pos.x = ", grid_pos.x, " si grid_pos.y = ", grid_pos.y) break elif grid_pos.y < start_pos.y and grid_pos.x < start_pos.x: print("pozitie initiala la diagonala stanga sus") print("esti in for loop") for i in range(1,8): if(start_pos.x - i < 0): print(" break deoarece start_pos.x - i < 0") break if(start_pos.x - i < grid_pos.x): print("break deoarece start_pos.x - i < grid_pos.x") break print(i) # detecteaza inamici if grid_data[start_pos.y - i][start_pos.x - i][0] >= enemy.x and grid_data[start_pos.y - i][start_pos.x - i][0] <= enemy.y : grid_pos.x = start_pos.x - i grid_pos.y = start_pos.y - i print("Nebunul a intalnit un inamic in drum") print("Nebunul ramane pe pozitia cu grid_pos.x = ", grid_pos.x, " si grid_pos.y = ", grid_pos.y) break #detecteaza aliat if grid_data[start_pos.y - i][start_pos.x - i][0] >= ally.x and grid_data[start_pos.y - i][start_pos.x - i][0] <= ally.y : grid_pos.x = start_pos.x - i + 1 grid_pos.y = start_pos.y - i + 1 print("Nebunul a intalnic un aliat in drum") print("Nebunul ramane pe pozitia cu grid_pos.x = ", grid_pos.x, " si grid_pos.y = ", grid_pos.y) break if grid_pos != start_pos: deplasare_piesa() else: pasi = 2 # se permite iar mutarea deoarece prima nu a produs nici-o miscare print("parasire functie luare_piesa_diagonala") # functia deplasare_regina() reuneste functiile luare_piesa_diagonala() si luare_piesa_linie_coloana() func deplasare_regina(): luare_piesa_linie_coloana() luare_piesa_diagonala() # functia deplasare_rege() este inca rudimentara, #aceasta verifica daca ozitia dorita de player este libera sau ocupata de un inamic si realizeaza mutarea regelui acolo func deplasare_rege() ->bool: print(" ") print("Ai intrat in functia deplasare_rege") var sens sens = 1 # verificare pozitie dreapta sus if grid_pos.y == start_pos.y - 1 and grid_pos.x == start_pos.x + (1 * sens): print("Regele mutat la pozitia grid_pos.x = ", grid_pos.x, " si grid_pos.y = ", grid_pos.y) deplasare_piesa() pos_rege_actual = grid_pos return true # verificare pozitie dreapta if grid_pos.y == start_pos.y and grid_pos.x == start_pos.x + (1 * sens): print("Regele mutat la pozitia grid_pos.x = ", grid_pos.x, " si grid_pos.y = ", grid_pos.y) deplasare_piesa() pos_rege_actual = grid_pos return true #verificare pozitie dreapta jos if grid_pos.y == start_pos.y + 1 and grid_pos.x == start_pos.x + (1 * sens): print("Regele mutat la pozitia grid_pos.x = ", grid_pos.x, " si grid_pos.y = ", grid_pos.y) deplasare_piesa() pos_rege_actual = grid_pos return true #verificare pozitie jos if grid_pos.y == start_pos.y + (1 * sens) and grid_pos.x == start_pos.x: print("Regele mutat la pozitia grid_pos.x = ", grid_pos.x, " si grid_pos.y = ", grid_pos.y) deplasare_piesa() pos_rege_actual = grid_pos return true sens = - 1 # pastea stanga si sus de poitii #verificare pozitie stanga sus if grid_pos.y == start_pos.y - 1 and grid_pos.x == start_pos.x + (1 * sens): print("Regele mutat la pozitia grid_pos.x = ", grid_pos.x, " si grid_pos.y = ", grid_pos.y) deplasare_piesa() pos_rege_actual = grid_pos return true # verificare pozitie stanga if grid_pos.y == start_pos.y and grid_pos.x == start_pos.x + (1 * sens): print("Regele mutat la pozitia grid_pos.x = ", grid_pos.x, " si grid_pos.y = ", grid_pos.y) deplasare_piesa() pos_rege_actual = grid_pos return true #verificare pozitie stanga jos if grid_pos.y == start_pos.y + 1 and grid_pos.x == start_pos.x + (1 * sens): print("Regele mutat la pozitia grid_pos.x = ", grid_pos.x, " si grid_pos.y = ", grid_pos.y) deplasare_piesa() pos_rege_actual = grid_pos return true #verificare pozitie sus if grid_pos.y == start_pos.y + (1 * sens) and grid_pos.x == start_pos.x: print("Regele mutat la pozitia grid_pos.x = ", grid_pos.x, " si grid_pos.y = ", grid_pos.y) deplasare_piesa() pos_rege_actual = grid_pos return true return false #pentru pozitia oferita functiei, se_afla_in_sah returneaza true daca acea pozitie se afla in sah si false in caz contrar func se_afla_in_sah(pozitie : Vector2i)-> bool: # verificam daca pe linie se afla piese ce pot pune in pericol pozitia # mai exact ture si regine print("") print("Intrare in functia se_afla_in_sah") print("Se verifica daca sunt inamici pe aceasi linie") var sens = 0 var grid_pos = Vector2i(7,pozitie.y) # de la pozitie la dreapta sens = 1 #print("Sensul este ", sens) #print("aliati player-ului ",player, " sunt ", ally ) for i in range(pozitie.x + 1,grid_pos.x + 1, sens): #print(i) #print("esti in for loop") # detecteaza inamici if grid_data[grid_pos.y][i][0] >= enemy.x and grid_data[grid_pos.y][i][0] <= enemy.y : if grid_data[grid_pos.y][i][0] == -1 * player or grid_data[grid_pos.y][i][0] == -5 * player: print("Piesa a intalnit un inamic pe linie la dreapta pozitiei ") return true if grid_data[grid_pos.y][i][0] == -2 * player and i == pozitie.x + 1: print("Aliatii player-ului sunt " ,ally) print("Piesa a intalnit un rege pe linie la dreapta pozitiei ") return true break if grid_data[grid_pos.y][i][0] >= ally.x and grid_data[grid_pos.y][i][0] <= ally.y : print("pe linie la drepta pozitiei se afla un aliat", grid_pos.y, i ) break # de la pozitie la stanga grid_pos = Vector2i(0,pozitie.y) sens = -1 #print("Sensul este ", sens) #print("aliati player-ului ",player, " sunt ", ally ) for i in range(pozitie.x-1 ,grid_pos.x - 1, sens): #print(i) #print("Esti in for loop") # detecteaza inamici if grid_data[grid_pos.y][i][0] >= enemy.x and grid_data[grid_pos.y][i][0] <= enemy.y : if grid_data[grid_pos.y][i][0] == -1 * player or grid_data[grid_pos.y][i][0] == -5 * player: print("Piesa a intalnit un inamic pe linie la stanga pozitiei ") return true if grid_data[grid_pos.y][i][0] == -2 * player and i == pozitie.x - 1: print("Piesa a intalnit un rege pe linie la stanga pozitiei ") return true break if grid_data[grid_pos.y][i][0] >= ally.x and grid_data[grid_pos.y][i][0] <= ally.y : print("pe linie la stanga pozitiei se afla un aliat", grid_pos.y , i ) break # verificam daca pe clooana se afla piese ce pot pune in pericol pozitia print("") print("Se verifica daca sunt inamici pe aceasi coloana") sens = 0 grid_pos = Vector2i(pozitie.x,7) # de la pozitie in jos sens = 1 #print("Sensul este ", sens) #print("aliati player-ului ",player, " sunt ", ally ) for i in range(pozitie.y + 1,grid_pos.y + 1, sens): # print(i) # print("esti in for loop") # detecteaza inamici if grid_data[i][grid_pos.x][0] >= enemy.x and grid_data[i][grid_pos.x][0] <= enemy.y : if grid_data[i][grid_pos.x][0] == -1 * player or grid_data[i][grid_pos.x][0] == -5 * player: print("Piesa a intalnit un inamic pe coloana sub pozitie ") return true if grid_data[i][grid_pos.x][0] == -2 * player and i == pozitie.y + 1 : print("Piesa a intalnit un rege pe coloana sub pozitie ") return true break if grid_data[i][grid_pos.x][0] >= ally.x and grid_data[i][grid_pos.x][0] <= ally.y : print("pe coloana sub pozitiei se afla un aliat", i,grid_pos.x) break # de la pozitie in sus grid_pos = Vector2i(pozitie.x, 0 ) sens = -1 #print("Sensul este ", sens) #print("aliati player-ului ",player, " sunt ", ally ) #print(pozitie.y-1 , " " ,grid_pos.y - 1) for i in range(pozitie.y-1 ,grid_pos.y - 1, sens): # print(i) # print("Esti in for loop") # detecteaza inamici if grid_data[i][grid_pos.x][0] >= enemy.x and grid_data[i][grid_pos.x][0] <= enemy.y : if grid_data[i][grid_pos.x][0] == -1 * player or grid_data[i][grid_pos.x][0] == -5 * player: print("Piesa a intalnit un inamic pe coloana mai sus de pozitie ") return true if grid_data[i][grid_pos.x][0] == -2 * player and i == pozitie.y - 1: print("Piesa a intalnit un rege pe coloana mai sus de pozitie ") return true break if grid_data[i][grid_pos.x][0] >= ally.x and grid_data[i][grid_pos.x][0] <= ally.y : print("pe coloana mai sus de pozitiei se afla un aliat",i,grid_pos.x) break #verificam daca pe diagonala de la pozitie la dreapta jos print(" ") print("se verifica daca sunt inamici pe diagonala principala") var no_treat = true #diagonala dreapta jos var j = 1 while no_treat == true: if pozitie.x + j == 8: break elif pozitie.y + j == 8: break elif grid_data[pozitie.y + j][pozitie.x + j][0] == -1 * player or grid_data[pozitie.y + j][pozitie.x + j][0] == -3 * player: ## verificam pentru regina si nebun print("pe diagonala dreapta jos se afla o regina sau nebun") return true # din dreapta jos doar regele alb poate fii atacat de catre un pion negru elif (grid_data[pozitie.y + j][pozitie.x + j][0] == - 6 and j == 1 and player == 1) or (grid_data[pozitie.y + j][pozitie.x + j][0] == -2 * player and j == 1): print("pe diagonala dreapta jos se afla un pion sau rege") return true elif grid_data[pozitie.y + j][pozitie.x + j][0] >= enemy.x and grid_data[pozitie.y + j][pozitie.x + j][0] <=enemy.y: break elif grid_data[pozitie.y + j][pozitie.x + j][0] >= ally.x and grid_data[pozitie.y + j][pozitie.x + j][0] <=ally.y: print("pe diagonala dreapta jos se afla un aliat",pozitie.y + j, pozitie.x + j) break j += 1 #diagonala stanga sus j = 1 while no_treat == true: if pozitie.x - j == -1: break elif pozitie.y - j == -1: break elif grid_data[pozitie.y - j][pozitie.x - j][0] == -1 * player or grid_data[pozitie.y - j][pozitie.x - j][0] == -3 * player : # verificam pentru regina si nebun print("pe diagonala stanga sus se afla o regina sau nebun") return true # din stanga sus doar regele negru poate fii atacat de catre un pion alb elif (grid_data[pozitie.y - j][pozitie.x - j][0] == 6 and j == 1 and player == -1) or (grid_data[pozitie.y - j][pozitie.x - j][0] == -2*player and j == 1) : print("pe diagonala sstanga sus se afla un pion sau rege") return true elif grid_data[pozitie.y - j][pozitie.x - j][0] >= enemy.x and grid_data[pozitie.y - j][pozitie.x - j][0] <= enemy.y: break elif grid_data[pozitie.y - j][pozitie.x - j][0] >= ally.x and grid_data[pozitie.y - j][pozitie.x - j][0] <= ally.y: print("pe diagonala stanga sus se afla un aliat", pozitie.y - j, pozitie.x - j) break j +=1 print("Se verifica daca sunt inamici pe diagonala secundara") # diagonala dreapta sus j = 1 while no_treat == true: if pozitie.x + j == 8: break elif pozitie.y -j == -1: break if grid_data[pozitie.y - j ][pozitie.x + j][0] == -1 * player or grid_data[pozitie.y - j ][pozitie.x + j][0] == -3 * player: #verificam pentru regina si nebun print("pe diagonala dreapta sus se afla o regina sau un nebun") return true # din dreapta sus doar regele alb poate fii atacat de catre un pion negru elif (grid_data[pozitie.y - j ][pozitie.x + j][0] == -6 and j == 1 and player == 1) or (grid_data[pozitie.y - j ][pozitie.x + j][0] == -2*player and j == 1) : print("pe diagonala drapta sus se afla un pion sau rege") return true elif grid_data[pozitie.y - j ][pozitie.x + j][0] >= enemy.x and grid_data[pozitie.y - j ][pozitie.x + j][0]<= enemy.y: break elif grid_data[pozitie.y - j ][pozitie.x + j][0] >= ally.x and grid_data[pozitie.y - j ][pozitie.x + j][0]<= ally.y: print("pe diagonala dreapta sus se afla un aliat", pozitie.y - j, pozitie.x + j) break j +=1 #diagonala stanga jos j = 1 while no_treat == true: if pozitie.x - j == -1: break elif pozitie.y + j == 8: break elif grid_data[pozitie.y + j ][pozitie.x - j][0] == -1 * player or grid_data[pozitie.y + j ][pozitie.x - j][0] == -3 * player: #verificam pentru regina si nebun print("pe diagonala stanga jos se afla o regina sau un nebun") return true elif (grid_data[pozitie.y + j ][pozitie.x - j][0] == 6 and j == 1 and player == -1) or grid_data[pozitie.y + j ][pozitie.x - j][0] == -2*player and j == 1 : print("pe diagonala stanga jos se afla un pion sau rege") return true elif grid_data[pozitie.y + j ][pozitie.x - j][0] >= enemy.x and grid_data[pozitie.y + j ][pozitie.x - j][0] <= enemy.y: break elif grid_data[pozitie.y + j ][pozitie.x - j][0] >= ally.x and grid_data[pozitie.y + j ][pozitie.x - j][0] <= ally.y: print("pe diagonala stanga jos se afla un aliat",pozitie.y + j,pozitie.x - j) break j +=1 # se verifica daca pe una din cele 8 pozitii din care poate ataca un cal,se afla un cal inamic sens = 1 # se verifica mutarile la dreapta de rege #verificare mutare (linie , coloana) (-2, +1) if pozitie.x + (1*sens) in range(0,8) and pozitie.y -2 in range(0,8) : if grid_data[pozitie.y -2][pozitie.x + (1*sens)][0] == -4*player: print("calul care ameninta regele (linie,coloana) ", pozitie.y -2, " ", pozitie.x + (1*sens) ) return true #verificare mutare (-1, +2) if pozitie.x + (2*sens) in range(0,8) and pozitie.y - 1 in range(0,8): if grid_data[pozitie.y - 1][pozitie.x + (2*sens)][0] == -4 * player : print("calul care ameninta regele (linie,coloana) ", pozitie.y - 1, " ", pozitie.x + (2*sens) ) return true #verificare mutare (+1, +2) if pozitie.x + (2*sens) in range(0,8) and pozitie.y + 1 in range(0,8) : if grid_data[pozitie.y + 1][pozitie.x + (2*sens)][0] == -4* player : print("calul care ameninta regele (linie,coloana) ", pozitie.y + 1, " ", pozitie.x + (2*sens) ) return true #verificare mutare(+2,+1) if pozitie.x + (1*sens) in range (0,8) and pozitie.y +2 in range(0,8): if grid_data[pozitie.y +2][pozitie.x + (1*sens)][0] == -4*player : print("calul care ameninta regele (linie,coloana) ", pozitie.y +2, " ", pozitie.x + (1*sens) ) return true sens = -1 # se verifica mutarile la stanga de rege #verificare mutare (linie , coloana) (-2, -1) if pozitie.x + (1*sens) in range(0,8) and pozitie.y -2 in range(0,8) : if grid_data[pozitie.y -2][pozitie.x + (1*sens)][0] == -4*player: print("calul care ameninta regele (linie,coloana) ", pozitie.y -2, " ", pozitie.x + (1*sens) ) return true #verificare mutare (-1, -2) if pozitie.x + (2*sens) in range(0,8) and pozitie.y - 1 in range(0,8): if grid_data[pozitie.y - 1][pozitie.x + (2*sens)][0] == -4 * player : print("calul care ameninta regele (linie,coloana) ", pozitie.y - 1, " ", pozitie.x + (2*sens) ) return true #verificare mutare (+1, -2) if pozitie.x + (2*sens) in range(0,8) and pozitie.y + 1 in range(0,8) : if grid_data[pozitie.y + 1][pozitie.x + (2*sens)][0] == -4* player : print("calul care ameninta regele (linie,coloana) ", pozitie.y + 1, " ", pozitie.x + (2*sens) ) return true #verificare mutare(+2,-1) if pozitie.x + (1*sens) in range (0,8) and pozitie.y +2 in range(0,8): if grid_data[pozitie.y +2][pozitie.x + (1*sens)][0] == -4*player : print("calul care ameninta regele (linie,coloana) ", pozitie.y +2, " ", pozitie.x + (1*sens) ) return true return false func _on_meniu_game_over_restart(): print("butonul de restart a fost apasat") new_game()