2023-06-15 22:07:01 +02:00
import pygame
from config import *
from agent import *
from map_add_ons import *
from mobs import *
from bfs import *
from nn import *
from astar import *
import math
import random
2023-06-16 12:46:47 +02:00
from drzewo_decyzyjne import *
2023-06-15 22:07:01 +02:00
class Game :
def __init__ ( self ) :
pygame . init ( )
self . state = [ - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 ]
self . SCREEN = pygame . display . set_mode ( ( WIDTH , HEIGHT ) )
self . running = True
self . clock = pygame . time . Clock ( )
self . BACKGROUND_IMG = pygame . image . load ( " ./pozostale_zdjecia/podloze.jpg " )
self . BACKGROUND = pygame . transform . scale ( self . BACKGROUND_IMG , ( 64 , 64 ) )
self . LVL_ICON_PNG = pygame . image . load ( " ./pozostale_zdjecia/lvl_icon.png " )
self . LVL_ICON = pygame . transform . scale ( self . LVL_ICON_PNG , ( 24 , 24 ) )
pygame . display . set_caption ( ' Gra-SI ' )
self . bfs = Bfs ( self )
self . nn = NeuralN ( )
self . astar = Astar ( self )
2023-06-16 12:46:47 +02:00
self . tree = Tree ( )
2023-06-15 22:07:01 +02:00
self . cell_costs = [ [ 1 for _ in range ( TILE_SIZE ) ] for _ in range ( TILE_SIZE ) ]
self . obstacles = [ [ False for _ in range ( TILE_SIZE ) ] for _ in range ( TILE_SIZE ) ]
def new ( self ) : # tworzy się nowa sesja grania
self . all_sprites = pygame . sprite . LayeredUpdates ( )
self . rock_sprites = pygame . sprite . LayeredUpdates ( )
self . grass_sprites = pygame . sprite . LayeredUpdates ( )
self . archer_orks = pygame . sprite . LayeredUpdates ( )
self . infantry_orks = pygame . sprite . LayeredUpdates ( )
self . sauronL = pygame . sprite . LayeredUpdates ( )
self . flowers = pygame . sprite . LayeredUpdates ( )
self . little_rock_sprites = pygame . sprite . LayeredUpdates ( )
#Agent,Archer_ork,infantry_ork,sauron,flower,grass x6, rocks x5 tablica 16 elementowa y=0-11 x=0-12 random.randint(x, y) = od x do y downolny int
self . allpositions = [ ]
self . allpositionsSet = set ( )
while ( len ( self . allpositionsSet ) < 100 ) :
self . positions = [ ] #.append
self . positionsSet = set ( ) #.add
for x in range ( 16 ) :
while len ( self . positionsSet ) < 16 :
pos1 = random . randint ( 0 , 12 ) #x
pos2 = random . randint ( 0 , 11 ) #y
pom = ( pos1 , pos2 )
lenSetBefore = len ( self . positionsSet )
self . positionsSet . add ( pom )
lenSetAfter = len ( self . positionsSet )
if ( lenSetAfter > lenSetBefore ) :
self . positions . append ( pom )
AllPositionsSetB = len ( self . allpositionsSet )
self . allpositionsSet . add ( tuple ( self . positions ) )
AllPositionsSetA = len ( self . allpositionsSet )
if ( AllPositionsSetA > AllPositionsSetB ) :
2023-06-16 00:51:54 +02:00
self . positions . append ( ( 1000 ) )
2023-06-15 22:07:01 +02:00
self . allpositions . append ( self . positions )
2023-06-16 00:51:54 +02:00
#print("TO SA KOLEJNE po randomowaniu")
#print(self.allpositions)
2023-06-15 22:07:01 +02:00
def sprawdz_powtorzenia ( tablica ) :
wystapienia = set ( )
for element in tablica [ : - 1 ] :
if tuple ( element ) in wystapienia :
return True # Powtórzenie znalezione
wystapienia . add ( tuple ( element ) )
return False # Brak powtórzeń
def ocena_tablicy ( dane ) :
for x in range ( 100 ) :
2023-06-16 00:51:54 +02:00
grade = 0
2023-06-15 22:07:01 +02:00
if ( sprawdz_powtorzenia ( dane [ x ] ) ) :
dane [ x ] [ - 1 ] = 10000000
else :
x1 , y1 = dane [ x ] [ 0 ]
x2 , y2 = dane [ x ] [ 1 ]
x3 , y3 = dane [ x ] [ 2 ]
x4 , y4 = dane [ x ] [ 3 ]
2023-06-16 00:51:54 +02:00
x5 , y5 = dane [ x ] [ 4 ]
r1 = math . sqrt ( ( x1 - x4 ) * * 2 + ( y1 - y4 ) * * 2 )
r2 = math . sqrt ( ( x4 - x2 ) * * 2 + ( y4 - y2 ) * * 2 )
r3 = math . sqrt ( ( x2 - x3 ) * * 2 + ( y2 - y3 ) * * 2 )
r4 = math . sqrt ( ( x3 - x5 ) * * 2 + ( y3 - y5 ) * * 2 )
r5 = math . sqrt ( ( x5 - x4 ) * * 2 + ( y5 - y4 ) * * 2 )
2023-06-15 22:07:01 +02:00
r12 = math . sqrt ( ( x1 - x3 ) * * 2 + ( y1 - y3 ) * * 2 )
r13 = math . sqrt ( ( x1 - x2 ) * * 2 + ( y1 - y2 ) * * 2 )
2023-06-16 00:51:54 +02:00
r14 = math . sqrt ( ( x1 - x5 ) * * 2 + ( y1 - y5 ) * * 2 )
spr = math . sqrt ( ( x2 - x3 ) * * 2 + ( y2 - y3 ) * * 2 )
spr1 = math . sqrt ( ( x2 - x4 ) * * 2 + ( y2 - y4 ) * * 2 )
spr2 = math . sqrt ( ( x2 - x5 ) * * 2 + ( y2 - y5 ) * * 2 )
spr3 = math . sqrt ( ( x3 - x4 ) * * 2 + ( y3 - y4 ) * * 2 )
spr4 = math . sqrt ( ( x3 - x5 ) * * 2 + ( y3 - y5 ) * * 2 )
spr5 = math . sqrt ( ( x4 - x5 ) * * 2 + ( y4 - y5 ) * * 2 )
avg = ( r1 + r2 + r3 + r4 + r5 ) / 5
grade = abs ( r1 - avg ) + abs ( r2 - avg ) + abs ( r3 - avg ) + abs ( r4 - avg ) + abs ( r5 - avg )
if ( r1 < 5 ) :
grade = grade + 2
if ( r12 < 5 ) :
grade = grade + 2
if ( r13 < 5 ) :
grade = grade + 2
if ( r14 < 5 ) :
grade = grade + 2
if ( spr < 5 or spr1 < 5 or spr2 < 5 or spr3 < 5 or spr4 < 5 or spr5 < 5 ) :
2023-06-15 22:07:01 +02:00
grade = grade + 5
2023-06-16 00:51:54 +02:00
x6 , y6 = dane [ x ] [ - 2 ]
x7 , y7 = dane [ x ] [ - 3 ]
x8 , y8 = dane [ x ] [ - 4 ]
x9 , y9 = dane [ x ] [ - 5 ]
x0 , y0 = dane [ x ] [ - 6 ]
rock1 = math . sqrt ( ( x6 - x7 ) * * 2 + ( y6 - y7 ) * * 2 )
rock2 = math . sqrt ( ( x6 - x8 ) * * 2 + ( y6 - y8 ) * * 2 )
rock3 = math . sqrt ( ( x6 - x9 ) * * 2 + ( y6 - y9 ) * * 2 )
rock4 = math . sqrt ( ( x6 - x0 ) * * 2 + ( y6 - y0 ) * * 2 )
rock5 = math . sqrt ( ( x7 - x8 ) * * 2 + ( y7 - y8 ) * * 2 )
rock6 = math . sqrt ( ( x7 - x9 ) * * 2 + ( y7 - y9 ) * * 2 )
rock7 = math . sqrt ( ( x7 - x0 ) * * 2 + ( y7 - y0 ) * * 2 )
rock8 = math . sqrt ( ( x8 - x9 ) * * 2 + ( y8 - y9 ) * * 2 )
rock9 = math . sqrt ( ( x8 - x0 ) * * 2 + ( y8 - y0 ) * * 2 )
rock0 = math . sqrt ( ( x9 - x0 ) * * 2 + ( y9 - y0 ) * * 2 )
if ( rock1 < 2 or rock2 < 2 or rock3 < 2 or rock4 < 2 or rock5 < 2 or rock6 < 2 or rock7 < 2 or rock8 < 2 or rock9 < 2 or rock0 < 2 ) :
grade = grade + 3
2023-06-15 22:07:01 +02:00
grade = round ( grade , 2 ) * 100
dane [ x ] [ - 1 ] = grade
return dane
def sort_tablicy ( dane ) :
posortowana_tablica = sorted ( dane , key = lambda x : x [ - 1 ] )
return posortowana_tablica
def generuj_pary ( n ) :
pary = [ ]
for i in range ( 1 , n + 1 ) :
for j in range ( i + 1 , n + 1 ) :
pary . append ( [ i , j ] )
return pary
self . WszystkiePary = generuj_pary ( 7 )
2023-06-16 00:51:54 +02:00
#print("")
#print("")
#print("WszystkiePary")
#print(self.WszystkiePary)
2023-06-15 22:07:01 +02:00
def polacz_tablice ( tablica1 , tablica2 , n ) :
nowa_tablica = tablica1 [ : n ] + tablica2 [ n : ]
return nowa_tablica
self . positionsAfterGrade = ocena_tablicy ( self . allpositions )
2023-06-16 00:51:54 +02:00
#print("")
#print("")
#print("")
#print("Po ocenie ")
#print(self.positionsAfterGrade)
2023-06-15 22:07:01 +02:00
self . sortedAfterGrade = sort_tablicy ( self . positionsAfterGrade )
2023-06-16 00:51:54 +02:00
#print("")
#print("")
#print("")
#print("Po sortowaniu ")
#print(self.sortedAfterGrade)
n = 100
2023-06-15 22:07:01 +02:00
self . licznik = 0
2023-06-16 00:51:54 +02:00
while ( self . sortedAfterGrade [ 0 ] [ 16 ] != 0 and self . licznik < n ) :
#print("NUMER ITERACJI: "+str(self.licznik))
#print("")
#print("")
2023-06-15 22:07:01 +02:00
self . WynikKombinacji = [ ]
pomWynikInt = 0
pomWszystkieParyInt = 0
2023-06-16 00:51:54 +02:00
2023-06-15 22:07:01 +02:00
while ( len ( self . WynikKombinacji ) < 20 and pomWszystkieParyInt < 21 ) :
2023-06-16 00:51:54 +02:00
2023-06-15 22:07:01 +02:00
gen1 = self . sortedAfterGrade [ self . WszystkiePary [ pomWszystkieParyInt ] [ 0 ] - 1 ]
2023-06-16 00:51:54 +02:00
gen1 [ - 1 ] = 9966
#print("gen1")
#print(gen1)
2023-06-15 22:07:01 +02:00
gen2 = self . sortedAfterGrade [ self . WszystkiePary [ pomWszystkieParyInt ] [ 1 ] - 1 ]
2023-06-16 00:51:54 +02:00
gen2 [ - 1 ] = 9966
#print("gen2")
#print(gen2)
2023-06-15 22:07:01 +02:00
rollKombinacja = random . randint ( 0 , 100 ) # chance 60%
2023-06-16 00:51:54 +02:00
#print("rollKombinacja:"+str(rollKombinacja))
2023-06-15 22:07:01 +02:00
if ( rollKombinacja < 61 ) :
2023-06-16 00:51:54 +02:00
KombInt = random . randint ( 1 , 4 )
#print("KombInt:"+str(KombInt))
#print("Przed append")
#print(self.WynikKombinacji)
losujKtoGen1 = random . randint ( 0 , 100 )
#print("")
#print(losujKtoGen1)
if ( losujKtoGen1 > 50 ) :
self . WynikKombinacji . append ( polacz_tablice ( gen1 , gen2 , KombInt ) )
else :
self . WynikKombinacji . append ( polacz_tablice ( gen2 , gen1 , KombInt ) )
#print("Po append")
#print(self.WynikKombinacji)
rollMutacja = random . randint ( 0 , 100 ) # chance 10%
#print("rollMutacja:"+str(rollMutacja))
if ( rollMutacja < 90 ) :
#print("rolowanie mutacji")
MutacjaInt = random . randint ( 0 , 4 )
#print(MutacjaInt)
2023-06-15 22:07:01 +02:00
xPoMutacji = random . randint ( 0 , 12 ) #x
yPoMutacji = random . randint ( 0 , 11 ) #y
2023-06-16 00:51:54 +02:00
#print("rolowanie x y")
#print(xPoMutacji,yPoMutacji)
2023-06-15 22:07:01 +02:00
self . WynikKombinacji [ pomWynikInt ] [ MutacjaInt ] = [ xPoMutacji , yPoMutacji ]
2023-06-16 00:51:54 +02:00
pomWynikInt = pomWynikInt + 1
2023-06-15 22:07:01 +02:00
pomWszystkieParyInt = pomWszystkieParyInt + 1
laczenieGeneracji = self . sortedAfterGrade [ : ( 100 - len ( self . WynikKombinacji ) ) ] + self . WynikKombinacji
2023-06-16 00:51:54 +02:00
#print("pewna czesc ")
#print(self.sortedAfterGrade[:(100-len(self.WynikKombinacji))])
#print("reszta ")
#print("")
#print(self.WynikKombinacji)
2023-06-15 22:07:01 +02:00
OcenaWszystkich = ocena_tablicy ( laczenieGeneracji )
2023-06-16 00:51:54 +02:00
#print("Przed DODANIEM GENERACJI")
#print(self.sortedAfterGrade)
#print("")
#print("")
2023-06-15 22:07:01 +02:00
self . sortedAfterGrade = sort_tablicy ( OcenaWszystkich )
2023-06-16 00:51:54 +02:00
#print("Po DODANIU GENERACJI")
#print(self.sortedAfterGrade)
2023-06-15 22:07:01 +02:00
self . licznik = self . licznik + 1
#self.sortedAfterGrade[0] najlepszy
2023-06-16 00:51:54 +02:00
#print("")
#print("")
print ( self . sortedAfterGrade )
2023-06-15 22:07:01 +02:00
self . najlepszaGeneracja = self . sortedAfterGrade [ 0 ] #Agent,Archer_ork,infantry_ork,sauron,flower,grass x6, rocks x5 tablica 16 elementowa y=0-11 x=0-12 random.randint(x, y) = od x do y downolny int
self . agent = Agent ( self , self . najlepszaGeneracja [ 0 ] [ 0 ] , self . najlepszaGeneracja [ 0 ] [ 1 ] )
self . archer_ork = Archer_ork ( self , self . najlepszaGeneracja [ 1 ] [ 0 ] , self . najlepszaGeneracja [ 1 ] [ 1 ] )
self . obstacles [ self . najlepszaGeneracja [ 1 ] [ 0 ] ] [ self . najlepszaGeneracja [ 1 ] [ 1 ] ] = True
self . bfs . enemy_cells . append ( self . bfs . get_cell_number ( self . archer_ork . x , self . archer_ork . y ) )
self . infantry_ork = Infantry_ork ( self , self . najlepszaGeneracja [ 2 ] [ 0 ] , self . najlepszaGeneracja [ 2 ] [ 1 ] )
self . obstacles [ self . najlepszaGeneracja [ 2 ] [ 0 ] ] [ self . najlepszaGeneracja [ 2 ] [ 1 ] ] = True
self . bfs . enemy_cells . append ( self . bfs . get_cell_number ( self . infantry_ork . x , self . infantry_ork . y ) )
self . sauron = Sauron ( self , self . najlepszaGeneracja [ 3 ] [ 0 ] , self . najlepszaGeneracja [ 3 ] [ 1 ] )
self . obstacles [ self . najlepszaGeneracja [ 3 ] [ 0 ] ] [ self . najlepszaGeneracja [ 3 ] [ 1 ] ] = True
self . bfs . enemy_cells . append ( self . bfs . get_cell_number ( self . sauron . x , self . sauron . y ) )
self . flower = Health_flower ( self , self . najlepszaGeneracja [ 4 ] [ 0 ] , self . najlepszaGeneracja [ 4 ] [ 1 ] )
for y in range ( 6 ) :
self . grass = Grass ( self , self . najlepszaGeneracja [ y + 5 ] [ 0 ] , self . najlepszaGeneracja [ y + 5 ] [ 1 ] )
self . cell_costs [ self . najlepszaGeneracja [ y + 5 ] [ 0 ] ] [ self . najlepszaGeneracja [ y + 5 ] [ 1 ] ] = 5
for y in range ( 5 ) :
self . rock = Rocks ( self , self . najlepszaGeneracja [ y + 11 ] [ 0 ] , self . najlepszaGeneracja [ y + 11 ] [ 1 ] )
self . obstacles [ self . najlepszaGeneracja [ y + 11 ] [ 0 ] ] [ self . najlepszaGeneracja [ y + 11 ] [ 1 ] ] = True
self . bfs . wall_cells . append ( self . bfs . get_cell_number ( self . rock . x , self . rock . y ) )
2023-06-16 12:46:47 +02:00
2023-06-15 22:07:01 +02:00
def update ( self ) :
self . all_sprites . update ( )
def events ( self ) :
for event in pygame . event . get ( ) :
if event . type == pygame . QUIT :
self . running = False
pygame . quit ( )
if event . type == pygame . KEYDOWN :
if event . key == pygame . K_SPACE :
self . goal_pos = ( self . flower . x / / TILE_SIZE , self . flower . y / / TILE_SIZE )
self . move_agent ( self . astar . a_star ( self . goal_pos ) )
if event . type == pygame . MOUSEBUTTONDOWN :
mouse_presses = pygame . mouse . get_pressed ( )
if mouse_presses [ 0 ] :
x = self . sauron . x
y = self . sauron . y
goal = x / / TILE_SIZE , y / / TILE_SIZE
mob_image = self . sauron . image_path
prediction = self . prediction_road ( x , y , mob_image )
prediction = " SAURON "
2023-06-16 12:46:47 +02:00
while True : #do poprawienia poprawne rozpoznawanie
print ( " goal: " , goal )
if prediction == " SAURON " :
if self . agent . level < self . sauron . level :
lvl = ' nie '
else :
lvl = ' tak '
przyklad = { ' zdrowie_bohatera ' : ' 100 ' ,
' moc_bohatera ' : ' tak ' ,
' moc_moba ' : ' tak ' ,
' lvl_wiekszy_bohater ' : lvl ,
' mob_jest_strzelcem ' : self . sauron . archer ,
' zdrowie_moba ' : ' 50 ' ,
' artefakt ' : self . agent . artifact }
decision = self . tree . tree ( przyklad )
print ( decision )
if decision == " walcz " :
self . obstacles [ self . najlepszaGeneracja [ 3 ] [ 0 ] ] [ self . najlepszaGeneracja [ 3 ] [ 1 ] ] = False
self . move_agent ( self . astar . a_star ( goal ) )
else :
x = self . archer_ork . x
y = self . archer_ork . y
goal = x / / TILE_SIZE , y / / TILE_SIZE
mob_image = self . archer_ork . image_path
prediction = self . prediction_road ( x , y , mob_image )
prediction = " ORK_ARCHER "
2023-06-15 22:07:01 +02:00
elif prediction == " ORK_INFANTRY " :
2023-06-16 12:46:47 +02:00
if self . agent . level < self . infantry_ork . level :
lvl = ' nie '
else :
lvl = ' tak '
przyklad = { ' zdrowie_bohatera ' : ' 100 ' ,
' moc_bohatera ' : ' tak ' ,
' moc_moba ' : ' tak ' ,
' lvl_wiekszy_bohater ' : lvl ,
' mob_jest_strzelcem ' : self . infantry_ork . archer ,
' zdrowie_moba ' : ' 50 ' ,
' artefakt ' : self . agent . artifact }
decision = self . tree . tree ( przyklad )
print ( decision )
if decision == " walcz " :
self . obstacles [ self . najlepszaGeneracja [ 2 ] [ 0 ] ] [ self . najlepszaGeneracja [ 2 ] [ 1 ] ] = False
self . move_agent ( self . astar . a_star ( goal ) )
2023-06-15 22:07:01 +02:00
if self . agent . current_health < self . agent . max_health :
goal = ( self . flower . x / / TILE_SIZE , self . flower . y / / TILE_SIZE )
self . move_agent ( self . astar . a_star ( goal ) )
x = self . sauron . x
y = self . sauron . y
goal = x / / TILE_SIZE , y / / TILE_SIZE
mob_image = self . sauron . image_path
prediction = self . prediction_road ( x , y , mob_image )
prediction = " SAURON "
elif prediction == " ORK_ARCHER " :
2023-06-16 12:46:47 +02:00
if self . agent . level < self . archer_ork . level :
lvl = ' nie '
else :
lvl = ' tak '
przyklad = { ' zdrowie_bohatera ' : ' 100 ' ,
' moc_bohatera ' : ' tak ' ,
' moc_moba ' : ' tak ' ,
' lvl_wiekszy_bohater ' : lvl ,
' mob_jest_strzelcem ' : self . archer_ork . archer ,
' zdrowie_moba ' : ' 50 ' ,
' artefakt ' : self . agent . artifact }
decision = self . tree . tree ( przyklad )
print ( decision )
if decision == " walcz " :
self . obstacles [ self . najlepszaGeneracja [ 1 ] [ 0 ] ] [ self . najlepszaGeneracja [ 1 ] [ 1 ] ] = False
self . move_agent ( self . astar . a_star ( goal ) )
2023-06-15 22:07:01 +02:00
if self . agent . current_health < self . agent . max_health :
goal = ( self . flower . x / / TILE_SIZE , self . flower . y / / TILE_SIZE )
self . move_agent ( self . astar . a_star ( goal ) )
x = self . infantry_ork . x
y = self . infantry_ork . y
goal = x / / TILE_SIZE , y / / TILE_SIZE
mob_image = self . infantry_ork . image_path
prediction = self . prediction_road ( x , y , mob_image )
prediction = " ORK_INFANTRY "
def prediction_road ( self , x , y , mob_image ) :
mob_goal_cell = ( self . bfs . get_cell_number ( x , y ) )
if self . bfs . get_up_cell ( mob_goal_cell ) == None :
goal_cell = self . bfs . get_down_cell ( mob_goal_cell )
x , y = self . bfs . get_coordinates ( goal_cell )
goal = x / / TILE_SIZE , y / / TILE_SIZE
self . move_agent ( self . astar . a_star ( goal ) )
prediction = self . nn . predict ( mob_image )
else :
goal_cell = self . bfs . get_up_cell ( mob_goal_cell )
x , y = self . bfs . get_coordinates ( goal_cell )
goal = x / / TILE_SIZE , y / / TILE_SIZE
self . move_agent ( self . astar . a_star ( goal ) )
prediction = self . nn . predict ( mob_image )
return prediction
def move_agent ( self , path ) :
print ( " PATH::::: " , path )
for cell_to_move in path :
x , y = self . bfs . get_coordinates ( cell_to_move )
2023-06-16 12:46:47 +02:00
#print("Ruch do kratki : ", cell_to_move, " z x: ", x, ", y: ", y, ", agent.x: ", self.agent.rect.x, ", agent.y: ", self.agent.rect.y)
2023-06-15 22:07:01 +02:00
if ( self . bfs . get_cell_number ( self . agent . rect . x , self . agent . rect . y ) != cell_to_move ) :
if x > self . agent . rect . x :
self . agent . direction = 0
elif y > self . agent . rect . y :
self . agent . direction = 1
elif x < self . agent . rect . x :
self . agent . direction = 2
elif y < self . agent . rect . y :
self . agent . direction = 3
if self . agent . direction == 0 :
2023-06-16 00:51:54 +02:00
##print("DIRECTION: "+self.agent.AGENT_IMAGES[self.agent.direction])
2023-06-15 22:07:01 +02:00
self . agent . x_change + = TILE_SIZE
elif self . agent . direction == 1 :
2023-06-16 00:51:54 +02:00
##print("DIRECTION: "+self.agent.AGENT_IMAGES[self.agent.direction])
2023-06-15 22:07:01 +02:00
self . agent . y_change + = TILE_SIZE
elif self . agent . direction == 2 :
2023-06-16 00:51:54 +02:00
##print("DIRECTION: "+self.agent.AGENT_IMAGES[self.agent.direction])
2023-06-15 22:07:01 +02:00
self . agent . x_change - = TILE_SIZE
elif self . agent . direction == 3 :
2023-06-16 00:51:54 +02:00
##print("DIRECTION: "+self.agent.AGENT_IMAGES[self.agent.direction])
2023-06-15 22:07:01 +02:00
self . agent . y_change - = TILE_SIZE
self . agent . rotate ( )
self . update ( )
self . map ( )
2023-06-16 12:46:47 +02:00
#print("Polozenie agenta: agent.x: ", self.agent.rect.x, ", agent.y: ", self.agent.rect.y)
2023-06-15 22:07:01 +02:00
self . clock . tick ( 2 )
def map ( self ) : # tworzenie mapy
self . clock . tick ( FRAMERATE )
for x in range ( 0 , WIDTH , TILE_SIZE ) :
for y in range ( 0 , 768 , TILE_SIZE ) :
self . SCREEN . blit ( self . BACKGROUND , ( x , y ) )
self . rect = pygame . Rect ( x , y , TILE_SIZE , TILE_SIZE )
pygame . draw . rect ( self . SCREEN , BLACK , self . rect , 1 )
self . flowers . draw ( self . SCREEN )
self . all_sprites . draw ( self . SCREEN )
self . rock_sprites . draw ( self . SCREEN )
self . grass_sprites . draw ( self . SCREEN )
self . SCREEN . blit ( self . LVL_ICON , ( 340 , 780 ) )
pygame . display . update ( )
def main ( self ) :
self . events ( )
self . update ( )
self . map ( )
g = Game ( )
g . new ( )
while g . running :
g . main ( )