Saving highscores in a Flappy Bird clone using json - python

I'm making a Flappy Bird clone.
I'm still kinda new to Pygame. I have watched a tutorial about json saving (as you can see). I've tried to make everything work, which it is, but I'm having trouble figuring out how to save the high score value still.
The tutorial shown was on a clicker game. I followed along, but a clicker game is different to saving a high score on a Flappy Bird clone and displaying it. I've tried to do what the tutorial says about displaying the amount saved, but it didn't work.
The code:
import pygame, sys, random
import json
def draw_floor():
screen.blit(floor_surface,(floor_x_pos,900))
screen.blit(floor_surface,(floor_x_pos + 576,900))
def create_pipe():
random_pipe_pos = random.choice(pipe_height)
bottom_pipe = pipe_surface.get_rect(midtop = (584,random_pipe_pos))
top_pipe = pipe_surface.get_rect(midbottom = (584,random_pipe_pos -300))
return bottom_pipe,top_pipe
def move_pipes(pipes):
for pipe in pipes:
pipe.centerx -= 5
visible_pipes = [pipe for pipe in pipes if pipe.right > -50]
return visible_pipes
def draw_pipes(pipes):
for pipe in pipes:
if pipe.bottom >= 1024:
screen.blit(pipe_surface,pipe)
else:
flip_pipe = pygame.transform.flip(pipe_surface,False,True)
screen.blit(flip_pipe,pipe)
def check_collision(pipes):
global can_score
for pipe in pipes:
if bird_rect.colliderect(pipe):
hit_sound.play()
can_score = True
return False
if bird_rect.top <= -100 or bird_rect.bottom >= 900:
can_score = True
hit_sound.play()
return False
return True
def rotate_bird(bird):
new_bird = pygame.transform.rotozoom(bird,-bird_movement * 3,1)
return new_bird
def bird_animation():
new_bird = bird_frames[bird_index]
new_bird_rect = new_bird.get_rect(center = (100,bird_rect.centery))
return new_bird,new_bird_rect
# Data
data = {
'highscore': 0
}
try:
with open('highscore.txt') as highscore_file:
data = json.load(highscore_file)
except:
print('No file')
def score_display(game_state):
if game_state == 'main_game':
score_surface = game_font.render(str(int(score)),True,(255,255,255))
score_rect = score_surface.get_rect(center = (288,100))
screen.blit(score_surface,score_rect)
if game_state == 'game_over':
score_surface = game_font.render(f'Score: {int(score)}',True,(255,255,255))
score_rect = score_surface.get_rect(center = (288,100))
screen.blit(score_surface,score_rect)
high_score_surface = game_font.render(f'High score: {int(high_score)}',True,(255,255,255))
high_score_rect = high_score_surface.get_rect(center = (288,850))
screen.blit(high_score_surface,high_score_rect)
def update_score(score,high_score):
if score > high_score:
high_score = score
return high_score
def pipe_score_check():
global score, can_score
if pipe_list:
for pipe in pipe_list:
if 95 < pipe.centerx < 105 and can_score:
score += 1
point_sound.play()
can_score = False
if pipe.centerx < 0:
can_score = True
# pygame.mixer.pre_init(frequency = 44100, size = 16, channels = 1, buffer = 512)
pygame.init()
screen = pygame.display.set_mode((576,1024))
clock = pygame.time.Clock()
game_font = pygame.font.Font('04B_19.ttf',40)
# Variables
gravity = 0.25
bird_movement = 0
game_active = True
score = 0
high_score = 0
can_score = True
# Loading images
bg_surface = pygame.image.load('assets/background-day.png').convert()
bg_surface = pygame.transform.scale2x(bg_surface)
floor_surface = pygame.image.load('assets/base.png').convert()
floor_surface = pygame.transform.scale2x(floor_surface)
floor_x_pos = 0
bird_downflap = pygame.transform.scale2x(pygame.image.load('assets/yellowbird-downflap.png').convert_alpha())
bird_midflap = pygame.transform.scale2x(pygame.image.load('assets/yellowbird-midflap.png').convert_alpha())
bird_upflap = pygame.transform.scale2x(pygame.image.load('assets/yellowbird-upflap.png').convert_alpha())
bird_frames = [bird_downflap,bird_midflap,bird_upflap]
bird_index = 0
bird_surface = bird_frames[bird_index]
bird_rect = bird_surface.get_rect(center = (100,512))
BIRDFLAP = pygame.USEREVENT + 1
pygame.time.set_timer(BIRDFLAP,200)
# bird_surface = pygame.image.load('assets/yellowbird-midflap.png').convert_alpha()
# bird_surface = pygame.transform.scale2x(bird_surface)
# bird_rect = bird_surface.get_rect(center = (100,512))
pipe_surface = pygame.image.load('assets/pipe-green.png').convert()
pipe_surface = pygame.transform.scale2x(pipe_surface)
pipe_list = []
SPAWNPIPE = pygame.USEREVENT
pygame.time.set_timer(SPAWNPIPE,1500)
pipe_height = [400,600,800]
game_over_surface = pygame.transform.scale2x(pygame.image.load('assets/message.png').convert_alpha())
game_over_rect = game_over_surface.get_rect(center = (288,512))
# Sounds
flap_sound = pygame.mixer.Sound('sound/sfx_wing.wav')
hit_sound = pygame.mixer.Sound('sound/sfx_hit.wav')
point_sound = pygame.mixer.Sound('sound/sfx_point.wav')
countdown_sound_score = 100
# Event loop
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
with open('highscore.txt','w') as highscore_file:
json.dump(data,highscore_file)
pygame.quit()
sys.exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and game_active:
bird_movement = 0
bird_movement -= 12
flap_sound.play()
if event.key == pygame.K_SPACE and game_active == False:
game_active = True
pipe_list.clear()
bird_rect.center = (100,512)
bird_movement = 0
score = 0
if event.type == SPAWNPIPE:
pipe_list.extend(create_pipe())
if event.type == BIRDFLAP:
if bird_index < 2:
bird_index += 1
else:
bird_index = 0
bird_surface,bird_rect = bird_animation()
# Pasting background image
screen.blit(bg_surface,(0,0))
if game_active:
# Bird movement and pasting bird
bird_movement += gravity
rotated_bird = rotate_bird(bird_surface)
bird_rect.centery += bird_movement
screen.blit(rotated_bird,bird_rect)
game_active = check_collision(pipe_list)
# Pipes
pipe_list = move_pipes(pipe_list)
draw_pipes(pipe_list)
# Score
pipe_score_check()
score_display('main_game')
else:
screen.blit(game_over_surface,game_over_rect)
high_score = update_score(score,high_score)
score_display('game_over')
# Floor movement and pasting floor image
floor_x_pos -= 1
draw_floor()
if floor_x_pos <=-576:
floor_x_pos = 0
pygame.display.update()
clock.tick(120)


You have to initialize the highscore variable with the data from the dictionary:
data = { 'highscore': 0 }
try:
with open('highscore.txt') as highscore_file:
data = json.load(highscore_file)
except:
print('No file')
high_score = 0
high_score = data.get('highscore', 0)
And you must create a dictionary with the new high score before writing the dictionary to the JSON file
if score > highscore:
with open('highscore.txt','w') as highscore_file:
data = { 'highscore': score }
json.dump(data, highscore_file)

Related

Getting Attribute error, int object has no attribute bird. the previous answers didnt solve

I'm new to python and cant figure out whats the issue, tried multiple solutions, but that didn't work.
posting from the main function
def main(genomes, config):
nets = []
ge = []
birds = []
base = Base(680)
pipes = [Pipe(600)]
win = pygame.display.set_mode((WIN_WIDTH, WIN_HEIGHT))
clock = pygame.time.Clock()
score = 0
run = True
while run:
clock.tick(30)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
pygame.quit()
quit()
for x, bird in enumerate(birds):
bird.move()
ge[x].fitness += 0.1
if output[0] > 0.5:
bird.jump()
add_pipe = False
rem = []
It works the same in the loop below
for pipe in pipes:
for x,bird in enumerate(birds):
if pipe.collide(bird):
ge[x].fitness -= 1
birds.pop(x)
nets.pop(x)
ge.pop(x)
if not pipe.passed and pipe.x < bird.x:
pipe.passed = True
add_pipe = True
if pipe.x + pipe.PIPE_TOP.get_width() < 0:
rem.append(pipe)
pipe.move()
if add_pipe:
score += 1
for g in ge:
g.fitness += 5
pipes.append(Pipe(600))
for r in rem:
pipes.remove(r)
Here i'm getting that 'int object has no attribute bird' it works in other parts of the code
for x.bird in enumerate(birds):
if bird.y + bird.img.get_height() >= 680 or bird. y < 0:
birds.pop(x)
nets.pop(x)
ge.pop(x)
base.move()
draw_window(win, birds, pipes, base, score)

You have used a dot instead of a comma:
for x, bird in enumerate(birds):
Enumerate functions typical format:
for index, value in enumerate(values):

TypeError: method missing required positional argument

This is a simplified version of the script I'm working on, in order to be posted here.
import pyglet as py
import pygame as pg
import os, time
pg.init()
class g:
wMainDisplay = 1024
hMainDiplay = 576
textTitle = "Pokémon Life and Death: ESPLORATORI DEL PROPRIO DESTINO"
flag = pg.DOUBLEBUF | pg.HWSURFACE | pg.NOFRAME
fpsDefault = 60
black = (0, 0, 0)
loopIntro = False
loopWarn = True
def __init__(self):
os.environ["SDL_VIDEO_CENTERED"] = "1"
self.display = pg.display.set_mode((self.wMainDisplay, self.hMainDiplay), self.flag)
self.display.set_alpha(None)
pg.display.set_caption(self.textTitle)
self.alphaSurface = pg.Surface((self.wMainDisplay, self.hMainDiplay))
self.alphaSurface.set_alpha(0)
self.clock = pg.time.Clock()
pg.key.set_repeat(500, 100)
pg.mouse.set_visible(False)
py.options['audio'] = ("openal", "pulse", "directsound", "silent")
self.all_sprites = pg.sprite.Group()
def warnings(self):
alph = 0
img_in = True
img_out = False
warnCount = 0
color = self.black
self.warningGroups = pg.sprite.Group()
_Warning(self, 1)
time.sleep(2)
while self.loopWarn:
self.clock.tick(self.fpsDefault)
self.display.fill(color)
if img_in and img_out is False:
alph += 1
if alph >= 255:
warnCount += 1
img_in = False
time.sleep(0.01)
if img_out and img_in is False:
alph -= 5
if alph <= 0:
warnCount += 1
img_out = False
time.sleep(0.01)
if warnCount == 1:
_Warning.sound(1)
warnCount += 1
time.sleep(0.01)
elif warnCount == 2:
if _Warning.updateAudio() is False:
warnCount += 1
time.sleep(0.01)
elif warnCount == 3:
img_out = True
elif warnCount == 4:
_Warning(2)
img_in = True
elif warnCount == 5:
_Warning.sound(2)
warnCount += 1
time.sleep(0.01)
elif warnCount == 6:
if _Warning.updateAudio() is False:
warnCount += 1
time.sleep(0.01)
elif warnCount == 7:
self.loopWarn = False
self.loopIntro = True
else:
pass
self.alphaSurface.set_alpha(alph)
self.warningGroups.draw(self.alphaSurface)
self.display.blit(self.alphaSurface, (0, 0))
pg.display.flip()
class _Warning(pg.sprite.Sprite):
def __init__(self, game, objectI):
self.groups = game.warningGroups
pg.sprite.Sprite.__init__(self, self.groups)
self.game = game
self.player = py.media.Player()
self.warningImage_1 = pg.image.load("wra.png")
self.warningImage_2 = pg.image.load("wrb.png")
self.warningSound_1 = py.media.load("wra.mp3")
self.warningSound_2 = py.media.load("wra.mp3")
if objectI == 1:
self.image = self.warningImage_1
elif objectI == 2:
self.image = self.warningImage_2
self.image = pg.transform.scale(self.image, (self.game.wMainDisplay, self.game.hMainDiplay))
self.rect = self.image.get_rect()
self.rect.x = 0
self.rect.y = 0
def sound(self, objectS):
if objectS == 1:
self.player.queue(self.warningSound_1)
elif objectS == 2:
self.player.queue(self.warningSound_2)
self.player.play()
py.app.run()
def updateAudio(self):
check = self.player.playing()
return check
g = g()
g.warnings()
When I run this Python code, I get this error:
Traceback (most recent call last):
File "C:/Users/BlackFenix06/Desktop/Isaac.py/cut.py", line 124, in <module>
g.warnings()
File "C:/Users/BlackFenix06/Desktop/Isaac.py/cut.py", line 57, in warnings
_Warning.sound(1)
TypeError: sound() missing 1 required positional argument: 'objectS'
And yet I'm passing objectS, so I do not understand where the error is...
As I was writing the question, it occurred to me, maybe the error is due to the fact that the class is already being used as pygame.sprite.Sprite. However I'm not using __init__ directly, but a different function of the class. What do you think?

Actually the missing argument is self. You should be calling the sound() method from a class instantiation, not the class type itself.
So instead of this:
_Warning(self, 1)
_Warning.sound(1)
You should have something like this:
warn = _Warning(self, 1)
warn.sound(1)

Low frame rate, possibly because un-accelerated graphics

So I began creating a game a couple months ago using pygame, it has a top view similar to Starcraft, Age of empires etc... I have written around 1320 lines of code to create the basis of my game; however, I am experiencing issues with frame rate when blitting images and believe this is because I cannot use accelerated graphics with pygame. The way I am currently blitting images is by blitting all images ahead of time on a surface which I then subsurface to create a blit image of my entire screen. Is there a more effective way that i should be utilizing?
So my assumption is that would be huge mess to look through and I do not want to waste your guy's time. Essentially any time I blit a surface the size of my screen my framerate drops by ~20 frames, is there a way I can avoid this in pygame?
##PYGAME INITATE##
import pygame, os
os.environ['SDL_VIDEO_CENTERED'] = '1'
pygame.init()
_W,_H = pygame.display.Info().current_w, pygame.display.Info().current_h
flags = pygame.DOUBLEBUF | pygame.HWSURFACE
gameDisplay = pygame.display.set_mode((_W,_H),pygame.FULLSCREEN ) ## CREATES SCREEN YOU DISPLAY ON ##
gameDisplay.fill((0,0,0)) ## FILL COLOR OF SCREEN ##
pygame.display.set_caption("Dope Game") ## SETS NAME ##
gameClock = pygame.time.Clock() ## CLOCK OF THE GAME ##
import math
import os
import random
import copy
SQRT = math.sqrt
PI = math.pi
cos = math.cos
sin = math.sin
## REPEATABLE FUNCTIONS ##
def loadScale(file,command,sizeX,sizeY):
temp = pygame.image.load(file)
tempInfo = temp.get_rect()
tempInfo1,tempInfo2,tempInfo3,tempInfo4 = temp.get_rect()
tempInfo3 = int(tempInfo3)
tempInfo4 = int(tempInfo4)
if (command == "ratio"):
tempInfo3 = tempInfo3*sizeX
tempInfo4 = tempInfo4*sizeY
temp = pygame.transform.scale(temp,(int(tempInfo3),int(tempInfo4) ) )
elif (command == "size"):
temp = pygame.transform.scale(temp, (sizeX,sizeY) )
return(temp)
## NON GAME RELATED CLASSES ##
class EnterFrame():
def __init__(self,frameReset,function,parse,reset):
self.frameReset = frameReset
self.currentFrame = frameReset
self.function = function
self.parse = parse
self.reset = reset
if (self.reset != "onComplete"):
self.reset = (reset-1)
enterFrameTable.append(self)
def step(self,enterFrameTable):
if (self.currentFrame == 0):
self.function(self.parse)
if (self.reset != "onComplete"):
if (self.reset > 0):
self.currentFrame = self.frameReset
self.reset = self.reset-1
else:
enterFrameTable.remove(self)
del self
else:
self.currentFrame = self.frameReset
else:
self.currentFrame = self.currentFrame-1
class PlayerCreation():
def __init__(self):
self.x = _W
self.y = _H
self.view = [1600,1600]
self.viewShift = []
self.viewChangeSpeed = 25
def moveView(self,key):
add = EnterFrame(0,self.moveViewAction,key,"onComplete")
self.viewShift.append([add,key])
def moveViewAction(self,key):
if (key == "up"):
self.view[1] = self.view[1]-self.viewChangeSpeed
Map.recenterView()
if (self.view[1] < 0):
self.view[1] = 0
elif (key == "right"):
self.view[0] = self.view[0]+self.viewChangeSpeed
Map.recenterView()
if (self.view[0] > Map.tileSize*4):
self.view[0] = Map.tileSize*4
elif (key == "down"):
self.view[1] = self.view[1]+self.viewChangeSpeed
Map.recenterView()
if (self.view[1] > Map.tileSize*4):
self.view[1] = Map.tileSize*4
elif (key == "left"):
self.view[0] = self.view[0]-self.viewChangeSpeed
Map.recenterView()
if (self.view[0] < 0):
self.view[0] = 0
def endMoveView(self,key):
for i in range(len(self.viewShift)-1,-1,-1 ):
if (self.viewShift[i][1] == key):
enterFrameTable.remove(self.viewShift[i][0])
del self.viewShift[i]
class ImageCreation():
def __init__(self,name,image,type,hitBox):
self.name = name
self.image = image
self.type = type
self.hitBox = hitBox
self.rect = self.image.get_rect()
if (self.hitBox != "none"):
self.shiftX = hitBox[0][0]
self.shiftY = hitBox[0][1]
for i in range(1,len(hitBox) ):
if (hitBox[i][0] < self.shiftX):
self.shiftX = hitBox[i][0]
if (hitBox[i][1] < self.shiftY):
self.shiftY = hitBox[i][1]
else:
self.shiftX = self.rect[2]/2
self.shiftY = self.rect[3]/2
imageTable.append(self)
def draw(self,x,y):
image = self.image
self.blit = gameDisplay.blit(image,(x,y) )
class MapCreation():
def __init__(self):
self.tileSize = 800
self.size = self.tileSize*10
self.tiles = []
self.loadedTiles = []
self.surface = pygame.Surface([self.tileSize*5,self.tileSize*5], pygame.SRCALPHA, 32)
self.centerTile = [5,5]
self.drawPoint = [(_W-self.tileSize)/2,(_H-self.tileSize)/2]
self.amount = round(self.size/self.tileSize)
backGround = loadScale("Grass.png","size",self.tileSize,self.tileSize)
for i in range(0,self.amount):
for u in range(0,self.amount):
image = copy.copy(backGround)
newTile = Tile(image,[u*self.tileSize,i*self.tileSize])
self.tiles.append(newTile)
info = imageFind("House.png")
tile = self.tiles[55]
imageObject(info,tile,[240,50])
self.loadTiles("center")
def recenterView(self):
if (Player.view[0] > 3*self.tileSize):
self.centerTile[0] = self.centerTile[0]+1
Player.view[0] = Player.view[0]-self.tileSize
self.loadTiles("right")
print("right")
elif (Player.view[0] < 1*self.tileSize):
self.centerTile[0] = self.centerTile[0]-1
Player.view[0] = Player.view[0]+self.tileSize
self.loadTiles("center")
print("center")
if (Player.view[1] > 3*self.tileSize):
self.centerTile[1] = self.centerTile[1]+1
Player.view[1] = Player.view[1]-self.tileSize
self.loadTiles("center")
print("center")
elif (Player.view[1] < 1*self.tileSize):
self.centerTile[1] = self.centerTile[1]-1
Player.view[1] = Player.view[1]+self.tileSize
self.loadTiles("center")
print("center")
def loadTiles(self,load):
tileIndex = self.centerTile[0]+self.centerTile[1]*self.amount
if (load == "center"):
self.loadedTiles = []
for i in range(-2,3):
for u in range(-2,3):
loadTile = tileIndex + i*self.amount + u
self.loadedTiles.append(self.tiles[loadTile])
self.tiles[loadTile].loaded = [u+2,i+2]
self.surface = pygame.Surface([self.tileSize*5,self.tileSize*5], pygame.SRCALPHA, 32)
for i in range(0,len(self.loadedTiles) ):
sx = self.loadedTiles[i].loaded[0]*self.tileSize
sy = self.loadedTiles[i].loaded[1]*self.tileSize
self.surface.blit(self.loadedTiles[i].buttomLayer,(sx,sy) )
for i in range(0,len(self.loadedTiles) ):
sx = self.loadedTiles[i].loaded[0]*(self.tileSize+2)
sy = self.loadedTiles[i].loaded[1]*(self.tileSize+2)
self.surface.blit(self.loadedTiles[i].middleLayer,(sx,sy) )
for i in range(0,len(self.loadedTiles) ):
sx = self.loadedTiles[i].loaded[0]*(self.tileSize+2)
sy = self.loadedTiles[i].loaded[1]*(self.tileSize+2)
self.surface.blit(self.loadedTiles[i].topLayer,(sx,sy) )
elif (load == "right"):
self.loadedTiles = []
for i in range(-2,3):
for u in range(-2,3):
loadTile = tileIndex + i*self.amount + u
self.loadedTiles.append(self.tiles[loadTile])
self.tiles[loadTile].loaded = [u+2,i+2]
## OLD METHOD THAT WASNT WORKING ##
##subSurf = self.surface.subsurface(self.tileSize,0,self.tileSize*1,self.tileSize*5)
##self.surface = pygame.Surface([self.tileSize*5,self.tileSize*5], pygame.SRCALPHA, 32)
##self.surface.blit(subSurf,(0,0) )
## NEW METHOD ##
self.surface.scroll(dx=-self.tileSize*1,dy=0)
def draw(self):
global Player
image = self.surface.subsurface(Player.view[0],Player.view[1],self.tileSize,self.tileSize)
image = pygame.transform.scale(image,(self.tileSize,self.tileSize) )
gameDisplay.blit(image,((_W-self.tileSize)/2,(_H-self.tileSize)/2) )
image = pygame.transform.scale(self.surface,(300,300) )
gameDisplay.blit(image,(0,0 ) )
class Tile():
def __init__(self,image,coords):
transparentSurface = pygame.Surface([1000,1000], pygame.SRCALPHA, 32)
self.x = coords[0]
self.y = coords[1]
self.loaded = False
self.buttomLayer = image
self.middleLayer = copy.copy(transparentSurface)
self.topLayer = transparentSurface
class imageObject():
def __init__(self,info,tile,coords):
self.info = info
self.image = info.image
self.rect = self.image.get_rect()
self.x = coords[0]
self.y = coords[1]
self.hitBox = []
if (self.info.hitBox != "none"):
for i in range(0,len(self.info.hitBox) ):
self.hitBox.append([self.info.hitBox[i][0]+self.x,self.info.hitBox[i][1]+self.y])
#self.object = createObject(self.hitBox,True,"none")
if (info.type == "background"):
tile.buttomLayer.blit(self.image,(self.x,self.y) )
if (info.type == "object"):
tile.middleLayer.blit(self.image,(self.x,self.y) )
if (info.type == "object alphas"):
tile.topLayer.blit(self.image,(self.x,self.y) )
def imageFind(name):
for i in range(0,len(imageTable) ):
if (name == imageTable[i].name):
return(imageTable[i])
return("none")
def imageLoad(types):
if (types == "basic"):
image = loadScale("House.png","ratio",1,1)
basicHouse = ImageCreation("House.png",image,"object",[[190, 375], [350, 375], [350, 235], [190, 235]])
image = loadScale("Grass.png","ratio",1,1)
grass = ImageCreation("Grass.png",image,"background","none")
def enterFrameHandle(enterFrameTable):
for i in range(len(enterFrameTable)-1,-1,-1 ):
enterFrameTable[i].step(enterFrameTable)
def EventHandle(event):
global Player
if (event.type == pygame.QUIT):
endGame()
elif(event.type == pygame.KEYDOWN):
key = (pygame.key.name(event.key) )
if (key == "escape"):
endGame()
elif (key == "up" or key == "right" or key == "down" or key == "left"):
Player.moveView(key)
elif(event.type == pygame.KEYUP):
key = (pygame.key.name(event.key) )
if (key == "up" or key == "right" or key == "down" or key == "left"):
Player.endMoveView(key)
def endGame():
global QuitGame
QuitGame = True
def mainLoop():
## GLOBALS ##
global QuitGame
QuitGame = False
global Player
Player = PlayerCreation()
## MAIN TABLES ##
global enterFrameTable
enterFrameTable = []
global basicObjectTable
basicObjectTable = []
## TEMP TABLES ##
global imageTable
imageTable = []
## START UP LOOPS ##
imageLoad("basic")
global Map
Map = MapCreation()
## Temporary ##
while (QuitGame == False):
enterFrameHandle(enterFrameTable)
for event in pygame.event.get():
EventHandle(event)
Map.draw()
pygame.display.update() ## updates the screen ##
gameDisplay.fill([0,0,0]) ## Clears screen for next frame ##
gameClock.tick(64) ## The FPS ##
fps = gameClock.get_fps()
if (fps < 64 and fps != 0):
fps = gameClock.get_fps()
print("FPS HAS DROPPED TOO LOW DOWN TO",fps)
runGameNow = True
mainLoop()
pygame.quit()
quit()
Issue with path finder is due to picking up on itteration lines when finding nearest point.

The problem is quite straight forward really.
Your view the amount of lines as disease and the cause must be Pygame. Usually, or at least in almost any case - if you're not a god at using the language and library, the problem is probably not the language or the library. Because odds are you are no wear near to pushing the limits of what the two can deliver for you.
One dead give-away of this fact is, if you look at what your eyes see on screen, you'll quickly notice that whenever your background is about to loop around - that's when the glitch/frame drop occur.
Obviously, this COULD be a cause of the library doing something suspicious.. if it was the library that did the actual loop-around.
But in your code, this is a implementation you've done yourself.
So the best bet is to start looking there.
Just to be extremely confident in where the delay occurs - we can have a look at the profiler that comes with Python (cProfiler).
python -m cProfile -o sample_data.pyprof awesome_game.py
pyprof2calltree -i sample_data.pyprof -k
The result would show something along the lines of:
From this we can see that a lot of processing time goes to pygame.Surface and enterFrameHandle. And I bet that pygame.Surface is called within enterFrameHandle somewhere down the line.
So the best bet is to start at the end of the eventFrameHandle chain.
And in this breakdown, that's loadTiles.
And straight off the bat, a lot of warning signs in here.
There's at least four loops in here.. and loops are bad, because those take processing time.
I added debug information by simply doing:
def loadTiles
if load == "center":
print('Loading center')
elif load == "right":
print('Loading right')
Apparently center gets triggered whenever the glitch occurs.
So that narrows it down a little further. So i added timers around each for loop.
Loop one: takes 0.0 seconds
Loop two: takes 0.29 seconds
Loop three: takes 0.5 seconds
Loop four: takes 0.6 seconds
All in all, these are EXTREMELY bad for you, since they directly impact the render sequence. So why is this? Lets break it down even further.
We'll start off with the first loop that takes up 0.3 seconds:
for i in range(0,len(self.loadedTiles) ):
sx = self.loadedTiles[i].loaded[0]*self.tileSize
sy = self.loadedTiles[i].loaded[1]*self.tileSize
self.surface.blit(self.loadedTiles[i].buttomLayer,(sx,sy) )
So len(self.loadedTiles) will be 25.
That means this loop has to iterate 25 times per render cycle where loadTiles("center") is called.
Each cycle takes almost exactly 0.01 seconds which amounts up to 0.25 seconds per full loop. It's not terrible, well it is.. If you want 60 FPS out of your game, no loop or function call can take more than 0.0166 seconds in total.
So we've already overrun our desired FPS target. So we gotta knock a few milliseconds off this if we wanna get anywhere.
The loop in itself is not that bad, i mean 25 iterations, a modern PC can do that in less time than time() can measure. So, it all points to self.surface.blit().. Which from experience, it sure is.
This also correlate with the fact that our graph above spends 30% of the total CPU time in pygame.surface.blit.. So here's our first thief.
Looking at the rest of the loops, they are essentially the same, except with bigger numbers in the math which takes slight longer to calculate, hence probably the time difference in the loops.
So, what can we do to shrink down .blit times?
Well we can stop calling blit in every loop iteration, and just move the sprite objects positions and then blit them one by one.
But sensei, that's almost the same thing?
Well yes my soon to be ninja turtle, it is.. That's why, we'll move the sprites in to batches/groups, and render the group. Thus, we can change the positions (fast operation), and because we moved the rendering outside of the loops, we can also convert them into a group object and render the group.
First, we'll convert your objects into pygame.sprite.Sprite, these are clever little objects that contain both collision detection, moving arounds etc.
self.grass = pygame.sprite.Sprite()
self.grass.image = pygame.image.load("Grass.png")
self.grass.rect = pygame.Rect(0, 0, 60, 60)
And you add this into a rendering group (a batch):
self.main_group = pygame.sprite.Group(self.grass)
Bam, and instead of updating 25 sprites, now you can do:
self.main_group.draw(gameDisplay)
And bam, SPEED!
Now, your code is NOT designed for this.
So this will take a while to fix and correct this design flaw.
Because this would take hours for me in order to keep your original code as close as possible, i ignored this and reworked your entire MapCreation and modified your PlayerCreation and how you move the map around (I changed from trying to recenter each time, it's a nice idea but far to complex to implement 1PM rewriting someone else's code).. So.. Here's the new approach to your problem:
import pygame, os
from time import time
from collections import OrderedDict
os.environ['SDL_VIDEO_CENTERED'] = '1'
pygame.init()
_W,_H = pygame.display.Info().current_w, pygame.display.Info().current_h
flags = pygame.DOUBLEBUF | pygame.HWSURFACE | pygame.RESIZABLE
gameDisplay = pygame.display.set_mode((500, 500))
gameDisplay.fill((0,0,0)) ## FILL COLOR OF SCREEN ##
pygame.display.set_caption("Dope Game") ## SETS NAME ##
gameClock = pygame.time.Clock() ## CLOCK OF THE GAME ##
import math
import os
import random
import copy
SQRT = math.sqrt
PI = math.pi
cos = math.cos
sin = math.sin
## REPEATABLE FUNCTIONS ##
def loadScale(file,command,sizeX,sizeY):
temp = pygame.image.load(file)
tempInfo = temp.get_rect()
tempInfo1,tempInfo2,tempInfo3,tempInfo4 = temp.get_rect()
tempInfo3 = int(tempInfo3)
tempInfo4 = int(tempInfo4)
if (command == "ratio"):
tempInfo3 = tempInfo3*sizeX
tempInfo4 = tempInfo4*sizeY
temp = pygame.transform.scale(temp,(int(tempInfo3),int(tempInfo4) ) )
elif (command == "size"):
temp = pygame.transform.scale(temp, (sizeX,sizeY) )
return(temp)
## NON GAME RELATED CLASSES ##
class EnterFrame():
def __init__(self,frameReset,function,parse,reset):
self.frameReset = frameReset
self.currentFrame = frameReset
self.function = function
self.parse = parse
self.reset = reset
if (self.reset != "onComplete"):
self.reset = (reset-1)
enterFrameTable.append(self)
def step(self,enterFrameTable):
if (self.currentFrame == 0):
self.function(self.parse)
if (self.reset != "onComplete"):
if (self.reset > 0):
self.currentFrame = self.frameReset
self.reset = self.reset-1
else:
enterFrameTable.remove(self)
del self
else:
self.currentFrame = self.frameReset
else:
self.currentFrame = self.currentFrame-1
class PlayerCreation():
def __init__(self):
self.x = _W
self.y = _H
self.view = [1600,1600]
self.viewShift = []
self.viewChangeSpeed = 25
def moveView(self,key):
add = EnterFrame(0,self.moveViewAction,key,"onComplete")
self.viewShift.append([add,key])
def moveViewAction(self,key):
if (key == "up"):
self.view[1] = self.view[1]-self.viewChangeSpeed
Map.move_tile(0, 1) # Player moves up, so the tiles should move down -> (0, 1) == (x, y)
if (self.view[1] < 0):
self.view[1] = 0
elif (key == "right"):
self.view[0] = self.view[0]+self.viewChangeSpeed
Map.move_tile(-1, 0)
if (self.view[0] > Map.tileSize*4):
self.view[0] = Map.tileSize*4
elif (key == "down"):
self.view[1] = self.view[1]+self.viewChangeSpeed
Map.move_tile(0, -1)
if (self.view[1] > Map.tileSize*4):
self.view[1] = Map.tileSize*4
elif (key == "left"):
self.view[0] = self.view[0]-self.viewChangeSpeed
Map.move_tile(1, 0)
if (self.view[0] < 0):
self.view[0] = 0
def endMoveView(self,key):
for i in range(len(self.viewShift)-1,-1,-1 ):
if (self.viewShift[i][1] == key):
enterFrameTable.remove(self.viewShift[i][0])
del self.viewShift[i]
class ImageCreation():
def __init__(self,name,image,type,hitBox):
self.name = name
self.image = image
self.type = type
self.hitBox = hitBox
self.rect = self.image.get_rect()
if (self.hitBox != "none"):
self.shiftX = hitBox[0][0]
self.shiftY = hitBox[0][1]
for i in range(1,len(hitBox) ):
if (hitBox[i][0] < self.shiftX):
self.shiftX = hitBox[i][0]
if (hitBox[i][1] < self.shiftY):
self.shiftY = hitBox[i][1]
else:
self.shiftX = self.rect[2]/2
self.shiftY = self.rect[3]/2
imageTable.append(self)
def draw(self,x,y):
image = self.image
self.blit = gameDisplay.blit(image,(x,y) )
class MapCreation():
def __init__(self):
self.tileSize = 800
self.size = self.tileSize*10
self.tiles = []
self.centerTile = [5,5]
self.amount = round(self.size/self.tileSize)
self.sprites = OrderedDict()
self.grass_image = pygame.image.load("Grass.png")
self.grass_group = pygame.sprite.Group()
for x in range(0, self.amount*60, 60): ## 10*60, but we step 60 pixels, so in the end, this will be 10 steps.
for y in range(0, self.amount*60, 60): ## Which is the same as `for x in range(self.amount)` but we scale it up
## to give us pixels instead of just the ammount.
index = len(self.sprites) # -- Generate a index for this sprite. Used for access later (to update pos for instace)
## == Create the sprite, add a image to it and define a position and size.
self.sprites[index] = pygame.sprite.Sprite()
self.sprites[index].image = self.grass_image
self.sprites[index].rect = pygame.Rect(x, y, 60, 60)
## == Then add the sprite to the grass group.
self.grass_group.add(self.sprites[index])
def move_tile(self, dx, dy):
for index in self.sprites:
x, y, width, height = self.sprites[index].rect
## == this is how you move the sprites:d
self.sprites[index].rect = pygame.Rect(x+dx, y+dy, 60, 60)
def draw(self):
self.grass_group.update()
self.grass_group.draw(gameDisplay)
class Tile():
def __init__(self,image,coords):
transparentSurface = pygame.Surface([1000,1000], pygame.SRCALPHA, 32)
self.x = coords[0]
self.y = coords[1]
self.loaded = False
self.buttomLayer = image
self.middleLayer = copy.copy(transparentSurface)
self.topLayer = transparentSurface
class imageObject():
def __init__(self,info,tile,coords):
self.info = info
self.image = info.image
self.rect = self.image.get_rect()
self.x = coords[0]
self.y = coords[1]
self.hitBox = []
if (self.info.hitBox != "none"):
for i in range(0,len(self.info.hitBox) ):
self.hitBox.append([self.info.hitBox[i][0]+self.x,self.info.hitBox[i][1]+self.y])
#self.object = createObject(self.hitBox,True,"none")
if (info.type == "background"):
tile.buttomLayer.blit(self.image,(self.x,self.y) )
if (info.type == "object"):
tile.middleLayer.blit(self.image,(self.x,self.y) )
if (info.type == "object alphas"):
tile.topLayer.blit(self.image,(self.x,self.y) )
def imageFind(name):
for i in range(0,len(imageTable) ):
if (name == imageTable[i].name):
return(imageTable[i])
return("none")
def imageLoad(types):
if (types == "basic"):
image = loadScale("House.png","ratio",1,1)
basicHouse = ImageCreation("House.png",image,"object",[[190, 375], [350, 375], [350, 235], [190, 235]])
image = loadScale("Grass.png","ratio",1,1)
grass = ImageCreation("Grass.png",image,"background","none")
def enterFrameHandle(enterFrameTable):
for i in range(len(enterFrameTable)-1,-1,-1 ):
enterFrameTable[i].step(enterFrameTable)
def EventHandle(event):
global Player
if (event.type == pygame.QUIT):
endGame()
elif(event.type == pygame.KEYDOWN):
key = (pygame.key.name(event.key) )
if (key == "escape"):
endGame()
elif (key == "up" or key == "right" or key == "down" or key == "left"):
Player.moveView(key)
elif(event.type == pygame.KEYUP):
key = (pygame.key.name(event.key) )
if (key == "up" or key == "right" or key == "down" or key == "left"):
Player.endMoveView(key)
def endGame():
global QuitGame
QuitGame = True
def mainLoop():
## GLOBALS ##
global QuitGame
QuitGame = False
global Player
Player = PlayerCreation()
## MAIN TABLES ##
global enterFrameTable
enterFrameTable = []
global basicObjectTable
basicObjectTable = []
## TEMP TABLES ##
global imageTable
imageTable = []
## START UP LOOPS ##
imageLoad("basic")
global Map
Map = MapCreation()
## Temporary ##
while (QuitGame == False):
enterFrameHandle(enterFrameTable)
for event in pygame.event.get():
EventHandle(event)
pygame.display.update() ## updates the screen ##
gameDisplay.fill([0,0,0]) ## Clears screen for next frame ##
#Map.draw()
Map.grass_group.update()
Map.grass_group.draw(gameDisplay)
gameClock.tick(64) ## The FPS ##
fps = gameClock.get_fps()
if (fps < 64 and fps != 0):
fps = gameClock.get_fps()
print("FPS HAS DROPPED TOO LOW DOWN TO",fps)
pygame.display.flip()
runGameNow = True
mainLoop()
pygame.quit()
quit()
This code rarely drop down in FPS.
And when it does, it drops down to ~63 FPS because I moved the window around (that's a taxing thing to do because all the OpenGL references need to compensate for the new window position and events that triggers within Pygame (resize events, move events etc are taxing, but occurs once and not every render loop.. so it's acceptable).
Conclusion
It's rarely the library's fault for slow performance.
Stop thinking as a developer for a second, and watch the screen and see if you can find clues to as where the fault may lie. In this case a obvious glitch occurred every time the tiles rotated around the screen edge.. That's a clue! Not a single programming skill needed to visually see this bug.
Use a profiler and debug where your code spends most of the time.
Try to see how others have solved game designs.. You're on the right track by putting everything in classes, but that mostly helps your readability of the code - try to see what's in other peoples classes and how they use Pygame calls.
All in all, it's quite a fun and nice code you got going.
It's just not made for performance and it's hard to code in afterwards.. so maybe it's not such a bad idea to start all over? But keep your old code base for reference and avoid the obvious traps:
loops in the render sequence
rendering objects one by one, use batches instead
Only do loops to update positions/stats, not graphics!
Last note on the topic: Graphic cards are huge power houses. They can calculate a few million operations a second if not more. And each time you blit something to the screen, the graphics card needs to interrupt it's calculations and memory allocation to flip around buffers and update what you see on the screen.. And that's slow work because it's not calculations, it's operational tasks (which usually includes waiting for queues and signals).. So instead of throwing hundreds of blit's a second to the graphics card, throw math operations at it by sending it textures (math data describing how things look).. and then call blit (draw, in this case) once and let the graphics card take all the math you threw at it - do one big logical operation - and presto.. x100 the speed already.

screen.blit(Lab.image,Lab.rect) AttributeError: type object 'LabClass' has no attribute 'image'

Hi I am working on a new game and I want to test it to fix any problems and make it work. However the python shell keep giving me this message.
screen.blit(Lab.image,Lab.rect)
AttributeError: type object 'LabClass' has no attribute 'image'
I have tried every thing to fix this but I can't. Can soneone pleas help me?
I do know that there could be other problems that I will have to fix but I need help with this problem.
import pygame
import time
key1_images = ["clear.png", "key1.png"]
guy_images = ["lab.png", "shock.png"]
class LabClass(pygame.sprite.Sprite):
def __init__(self):
pygame.sprite.Sprite.__init__(self)
self.image = pygame.image.load("lab.png")
self.rect = self.image.get_rect()
class key1Class(pygame.sprite.Sprite):
def __init__(self):
pygame.sprite.Sprite.__init__(self)
self.image = pygame.image.load("clear.png")
self.rect = self.image.get_rect()
self.rect.center = [310,250]
def levelUp():
levelUp = False
if levelUp == True:
level = level + 1
levelUp = False
def zap():
guy.image = pygame.image.load("shock.png")
animate()
time.sleep(2)
T_text = font.render("Oh no, you were", 1, (255, 0, 0))
screen.blit(T_text,[220,320])
pygame.display.flip()
def key1Kill():
key1.image = pygame.image.load("clear.png")
animate()
time.sleep(0.1)
zap()
def key1Play():
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN:
score = True
score()
choose = True
choose()
key1.image = pygame.image.load("clear.png")
animate()
else:
key1Kill()
if level <5:
clock.tick(10)
key1die = True
if key1die == True and score == False:
key1Kill()
else:
key1die = False
if level >5 and not 10:
clock.tick(5)
key1die = True
if key1die == True and score == False and choose == False:
key1Kill()
else:
key1die = False
if level >9:
clock.tick(3)
key1die = True
if key1die == True and score == False:
key1Kill()
else:
key1die = False
def choose():
choose = True
if choose == True:
clock.tick(2)
key = random.randint(1,3)
if key == 1:
key1.image = pygame.image.load("key1.png")
animate()
key1Play()
choose = False
def score():
score = False
if score == True:
pointstest = pointstest + 1
score = False
if pointstest == 10:
levelUp = True
levelUp()
def getLife():
if level >18 and levelUp == True:
num = random.randint(1,20)
if num ==(10, 15, 1, 3, 11):
lives = lives + 1
def getCoin():
if levelUp == True:
num2 = random.randint(1,15)
if num2 ==(1, 5, 15, 3, 7):
coins = coins + 1
def animate():
screen.blit(Lab.image,Lab.rect)
screen.blit(key1.image,key1.rect)
pygame.display.flip()
pygame.init()
clock = pygame.time.Clock()
screen = pygame.display.set_mode([640,640])
coins = 0
lives = 0
level = 1
pointstest = 0
Lab = LabClass
key1 = key1Class
while True:
animate()
choose()
getLife()
getcoin()
levelUp()
score()

You need to initialized LabClass. Change:
Lab = LabClass
To:
Lab = LabClass()
This way it can access the image variable by doing Lab.image. I recommend taking another look at the Python Classes Tutorial.

When you do:
Lab = LabClass
key1 = key1Class
You are not calling the constructor of these two classes, you probably mean:
Lab = LabClass()
key1 = key1Class()
Although there seem to be other mistakes (for instance you use the random module without importing it)

How do I change the picture and the answers on the quiz after clicking one of the answers

How do I change the picture and 3 answering options after clicking on one of them. My code already checks if the answer is true or false but I can't seem to find how to put on a new picture and new answer options after I have clicked one of them.
import os, sys
import math
from pygame import *
from random import *
init()
must = [0,0,0]
suurus = [1000,600]
screen = display.set_mode(suurus)
screen.fill(must)
punktid = 1
samblikud=[]
vastused=[]
#pildid = {"samblik1.jpg":"vaguapiksamblik","samblik2.jpg":"alpipõdrasamblik"}
for i in range(7):
pilt = image.load("samblik"+str(i+1)+".jpg")
samblikud.append(pilt)
for i in range(7):
pilt = image.load("vastus"+str(i+1)+".jpg")
vastused.append(pilt)
jargmine = image.load("jargmine.jpg")
s = randint(0,6) #pildi number
nr = {} #sõnastik, kuhu valime kolm vastusevarianti
nr[s]=1 #samblik
vo = True
to = True
while (vo == True) or (to == True):
v = randint(0,6)#vastusevariandi nr
t = randint(0,6)
if v in nr:
v = randint(0,6) #kui olemas genereerib uue
else:
nr[v]=0
vo = False
if t in nr: #kui t on olemas
t = randint(0,6)
else:
nr[t]=0
to = False
var=[]
for key in nr:
var.append(key)
o = [] #milline õige, kui väärtus on 1
for key in nr:
if nr[key] == 1:
o.append(key)
print(var)
print(nr)
def joonista():
screen.fill(must)
screen.blit(samblikud[o[0]],[0,0]) #samblik
screen.blit(vastused[var[0]], [500,100])
screen.blit(vastused[var[1]], [500,200])
screen.blit(vastused[var[2]], [500,300])
screen.blit(jargmine, [500, 500])
display.flip()
def kysimus():
teksti_font = font.Font(None,25)
tekst1_pildina = teksti_font.render('Milline samblik on pildil?',1,[0,255,0])
tekst1_raam = tekst1_pildina.get_rect()
screen.blit(tekst1_pildina,(500,50))
tekst2_pildina = teksti_font.render('Vastamiseks vajuta õigel vastusel.',1,[0,255,0])
tekst2_raam = tekst2_pildina.get_rect()
screen.blit(tekst2_pildina,(500,75))
display.flip()
x_v=347#vastuse kasti x suurus
y_v=81#vastuse kasti y suurus
def kontrolli():
while True:
if var[0]==o[0]:
y_o = 100 #õige vastuse koordi
y_w1 = 200
y_w2 = 300
elif var[1]==o[0]:
y_o = 200
y_w1 = 100
y_w2 = 300
elif var[2]==o[0]:
y_o = 300
y_w1 = 200
y_w2 = 100
for i in event.get():
if i.type == QUIT:
sys.exit()
if i.type == MOUSEBUTTONDOWN:
x, y = i.pos
# Check to see if the click is in the range we want
if ( x in range(500,500+x_v)) and (y in range(y_o,y_o+y_v)):
# Grab the next image,
next_image = image.load('oige_v.png') #õige vastuse kuvamine
screen.blit(next_image, (500,y_o)) #uus pilt
punktid = punktid + 1
display.flip()
elif (x in range(500,500+x_v)) and (y in range(y_w1,y_w1+y_v)):
next_image = image.load('vale_v.png')
screen.blit(next_image, (500,y_w1)) # vale vastus
display.flip()
elif (x in range(500,500+x_v)) and (y in range(y_w2,y_w2+y_v)):
next_image = image.load('vale_v.png')
screen.blit(next_image, (500,y_w2)) #vale vastus
display.flip()
elif (x in range(500,500+x_v)) and (y in range(500,500+y_v)):
break
while True:
for i in range(punktid):
joonista()
kysimus()
#joonista()
#kysimus()
while True:
if var[0]==o[0]:
y_o = 100
y_w1 = 200
y_w2 = 300
elif var[1]==o[0]:
y_o = 200
y_w1 = 100
y_w2 = 300
elif var[2]==o[0]:
y_o = 300
y_w1 = 200
y_w2 = 100
for i in event.get():
if i.type == QUIT:
sys.exit()
if i.type == MOUSEBUTTONDOWN:
x, y = i.pos
# Check to see if the click is in the range we want
if ( x in range(500,500+x_v)) and (y in range(y_o,y_o+y_v)):
# Grab the next image,
next_image = image.load('oige_v.png') #õige vastuse kuvamine
screen.blit(next_image, (500,y_o)) #uus pilt
punktid = punktid + 1
display.flip()
elif (x in range(500,500+x_v)) and (y in range(y_w1,y_w1+y_v)):
next_image = image.load('vale_v.png')
screen.blit(next_image, (500,y_w1)) # vale vastus
display.flip()
elif (x in range(500,500+x_v)) and (y in range(y_w2,y_w2+y_v)):
next_image = image.load('vale_v.png')
screen.blit(next_image, (500,y_w2)) #vale vastus
display.flip()
elif (x in range(500,500+x_v)) and (y in range(500,500+y_v)):
next_image = image.load('vale_v.png')
screen.blit(next_image, (500,500)) #vale vastus
display.flip()
#kontrolli()
display.flip()
done()

I would try and use a question class. So here is basically what I would do.
class Question:
def __init__(self, image, question, answer, numOfAnswers):
self.image = image
self.question = question
self.answer = {}
self.answer[1] = answer
self.totalAnswers = len(answer)
def newImage(image):
self.image = image
def newQuestion(question, answer):
self.question = question
self.answer.clear()
self.answer[1] = answer
def addAnswer(answer):
self.answer[len(answer)+1] = answer
Another thing is that your code is really sloppy because you have a while loop inside of your main game loop which i wouldn't recommend most especially considering that you only have one break and that is if your x is greater than 500. And I dont understand any of your variables, because I speak English, but tell me if you need any more clarification regarding accessing the class or using it. Just for your information classes are very useful in any programming language for uses such as this.

Categories

Resources