[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[pygame] game freezes on start up with 1.2



okay so here's the deal; I'm trying to write a simple game that uses alot of the Aliens code and the some tiling code from twitch. it was working on pygame 1.1, but it freezes up when i installed 1.2.  it seems to blit the background to the screen and then it freezes.
oh and i get a bunch of these errors
libpng warning: Incomplete compressed datastream in iCCP chunk
libpng warning: Ignoring truncated iCCP profile.
but i use to get these errors when it worked
 
 
well here's the code:
 
import whrandom, os.path, sys
import pygame, pygame.image, pygame.mixer, pygame.font
from FpsClock import *
from pygame.locals import *
 
 
 

timer=FpsClock()
timer.set_fps(100)
 
dirtyrects=[]
impassable_rects=[]
ladder_rects=[]
class Img: pass
 
 
def display(string, textpos, color,background):
    font = pygame.font.Font(None, 20)
    text = font.render(string, 1, color)
    textpos = text.get_rect()
    r=background.blit(text, textpos)
    dirtyrects.append(r)
 
def load_image(file, transparent):
    "loads an image, prepares it for play"
    file = os.path.join('images', file)
    try:
        surface = pygame.image.load(file)
    except pygame.error:
        raise SystemExit, 'Could not load image "%s" %s'%(file, pygame.get_error())
    if transparent:
        corner = surface.get_at((0, 0))
        surface.set_colorkey(corner, RLEACCEL)
    return surface.convert()
   
class Actor:
 def __init__(self,image,posx=32,posy=32):
  self.posx=posx
  self.posy=posy
  self.image=image
  self.rect=image.get_rect()
  self.damage=0
  
 def walk(self,tmp_colliderect):
        # Move player to the supplied coordinates. Only allows movement if the destination
        # is clear.
  if tmp_colliderect.collidelist(impassable_rects) == -1:
      return 1
  else:
      return -1
       
 def update(self): pass
 
 def draw(self,screen):
  #display.blit(self.surface, self.rect.topleft)
  r=screen.blit(self.image, self.rect.topleft)
  dirtyrects.append(r)
  
 def erase(self, screen,background):
  "gets the sprite off of the screen"
  r = screen.blit(background, self.rect, self.rect)
  dirtyrects.append(r)
 
class Explosion(Actor):
    "Beware the fury"
    def __init__(self, actor):
        explosion=load_image('explosion.png', 1)
        Actor.__init__(self, explosion)
        self.life = 6
        self.rect.center = actor.rect.center
       
    def update(self):
        self.life -= 1
 
 
class Projectile(Actor):
 def __init__(self, player,velocity):
  image=pygame.image.load(shot).convert()
  self.velocity=velocity
  Actor.__init__(self, image)
  self.rect.centerx = player.rect.centerx
  self.rect.centery=player.rect.centery
  #self.rect.top = player.rect.top - 10
 
 def update(self):
  self.rect.centerx += self.velocity
  
  
class Robot(Actor):
 def __init__(self):
  image=load_image('robob.png', 1)
  Actor.__init__(self,image)
  self.reloading=0
 def move_x(self,velocity):
  temp_posx=self.posx+velocity
  temp_rect=Rect(temp_posx,self.posy,16,32)
  if self.walk(temp_rect)==1:
   self.posx=temp_posx
   self.rect=Rect(self.posx,self.posy,16,32)
   
 
 def move_y(self,velocity):
  temp_posy=self.posy+velocity
  temp_rect=Rect(self.posx,temp_posy,16,32)
  if self.walk(temp_rect)==1:
   self.posy=temp_posy
   self.rect=Rect(self.posx,self.posy,16,32)
 
 def hit(self):
  print self.damage
  self.damage+=1
 
 def chase(self, player,ladder_rects):
  self.visionx=Rect(0,(self.posy),200,10)
  if (player.posy-self.posy)<5 and (player.posy-self.posy)>-5:
   if player.posx>self.posx:
    self.move_x(1)
   if player.posx<self.posx :
    self.move_x(-1)
  else:
   
   
   ladder=self.visionx.collidelist(ladder_rects)
   print ladder
   if not ladder==-1:
    if (ladder_rects[ladder].centerx-8)>self.posx:
     self.move_x(1)
    if (ladder_rects[ladder].centerx-8)<self.posx:
     self.move_x(-1)
    self.rect=Rect(self.posx,self.posy,16,32)
    num=ladder_rects[ladder].centerx-self.posx
    if num==8 or num==-8:
     if player.posy<self.posy:
      self.move_y(-2)
     else:
      self.move_y(2)
  self.rect=Rect(self.posx,self.posy,16,32)
  
  
 
   
  
 
 
class Player(Actor):
 def __init__(self,posx=32,posy=32):
  image=load_image('steve.png', 1)
  Actor.__init__(self,image,posx,posy)
  self.reloading=0
 
 def move_x(self,velocity):
  temp_posx=self.posx+velocity
  temp_rect=Rect(temp_posx,self.posy,16,32)
  if self.walk(temp_rect)==1:
   self.posx=temp_posx
   self.rect=Rect(self.posx,self.posy,16,32)
 

 def move_y(self,velocity):
  temp_posy=self.posy+velocity
  temp_rect=Rect(self.posx,temp_posy,16,32)
  if self.walk(temp_rect)==1:
   self.posy=temp_posy
   self.rect=Rect(self.posx,self.posy,16,32)
 
 def teleport(self):
  self.posx=whrandom.randint (20, 200)
  self.posy=whrandom.randint(20,200)
 
 
 
class Tile:
    def __init__(self, column, row):
        self.rect = pygame.Rect(column * 16, row * 16, 16, 16)
        self.walkable = 0
        self.visible = 1
 self.climbable=0
 self.movable=0
        self.column = column
        self.row = row
       
    def draw(self,background):
        #display.blit(self.surface, self.rect.topleft)
        background.blit(self.surface, self.rect.topleft)
 
       
class Block(Tile):
    def __init__(self, column, row):
        Tile.__init__(self, column, row)
        self.surface = pygame.image.load(blockfile).convert()
        self.walkable = 0
 self.climable=0
 
class MBlock(Tile):
    def __init__(self, column, row):
        Tile.__init__(self, column, row)
        self.surface = pygame.image.load(mblockfile).convert()
        self.walkable = 0
 self.movable=1
 self.climable=0
 self.damage=0
 
    def hit(self):
  print self.damage
  self.damage+=1
       
class Blank(Tile):
    def __init__(self, column, row):
        Tile.__init__(self, column, row)
        self.walkable = 1
        self.surface = pygame.image.load(blankfile).convert()
 self.climable=0
 
class Ladder(Tile):
    def __init__(self, column, row):
        Tile.__init__(self, column, row)
        self.climable=1
 self.walkable = 1
        self.surface = pygame.image.load(ladder).convert()
 self.row=row
 self.column=column
 

blankfile = os.path.join('images','blank1.png')
blockfile=os.path.join('images','block1.png')
mblockfile=os.path.join('images','blockm.png')
shot=os.path.join('images','bullet.png')
ladder=os.path.join('images','ladder.png')
 
def calculate_impassable_rects(tiles):
        impassable_rect= []
        for tile in tiles:
     if tile.walkable == 0:
                impassable_rect.append(tile.rect)
        temp_rect=impassable_rect
 return temp_rect
 
def calculate_ladder_rects(tiles):
        ladder_rects= []
        for tile in tiles:
     if tile.climable == 1:
                ladder_rects.append(tile.rect)
 return ladder_rects
 
def calculate_movable_rects(tiles):
        movable_rects= []
        for tile in tiles:
     if tile.movable == 1:
                movable_rects.append(tile.rect)
 return movable_rects
 

def load_map_file(tiles):
 row=0
        # establish the platform-independent filename
        filename = os.path.join('world.map')
        try:
            map_file = open(filename, 'r')
        except IOError:
            raise SystemExit, "Fatal Error: Filename %s not found. Could not load map" % filename
 

 while 1:
  line = map_file.readline()
  column=0
  for char in line:
   if char=='E':
    this_tile=Blank(column,row)
   if char=='B':
    this_tile=Block(column,row)
   if char=='L':
    this_tile=Ladder(column,row)
   if char=='M':
    this_tile=MBlock(column,row)
   tiles.append(this_tile)
    
   column=column+1
  row=row+1
  if line=='': break
  
  
  
 
def draw_to_display(tiles,background):
        for tile in tiles:
            if tile.visible:
                tile.draw(background)
 
hitfile = os.path.join('sounds', 'boom.wav')
ouchfile = os.path.join('sounds', 'ouch.wav')
begfile = os.path.join('sounds', 'beg.wav')
arrghfile = os.path.join('sounds', 'arrgh.wav')
 

def main():
    "Run me for adrenaline"
 
    global dirtyrects, impassable_rects
    tiles=[]
    shots=[]
    explosions = []
    robots=[]
 

    pygame.init()
   
 
    hitsound = pygame.mixer.Sound(hitfile)
    ouchsound = pygame.mixer.Sound(ouchfile)
    begsound = pygame.mixer.Sound(begfile)
    arrghsound = pygame.mixer.Sound(arrghfile)
    screen = pygame.display.set_mode((340, 340), HWSURFACE|DOUBLEBUF)
    #screen2 = pygame.display.set_mode((320, 320), HWSURFACE|DOUBLEBUF)
    colorkey=255,255,255
    screen.set_colorkey(colorkey)
    pygame.display.set_caption('STEVE World')
    pygame.mouse.set_visible(1)
   
    load_map_file(tiles)
    impassable_rects=calculate_impassable_rects(tiles)
    ladder_rects=calculate_ladder_rects(tiles)
    movable_rects=calculate_movable_rects(tiles)
    ##print len(ladder_rects)
 

#Create The Backgound
    robob=Robot()
    steve=Player(200,32)
    robots.append(robob)
    screenrect=screen.get_size()
    background = "pygame.Surface(screen.get_size())    background.set_colorkey(255,255)
    draw_to_display(tiles,background)
    ##print background.get_size()
  
    font = pygame.font.Font(None, 20)
    text = font.render("Steve's World", 1, (200, 10, 10))
    textpos = text.get_rect()
    textpos.centerx = background.get_rect().centerx
    background.blit(text, textpos)
 
#Display The Background While Setup Finishes
    screen.blit(background, (0, 0))
    pygame.display.flip()
    up_state=0
    direction=1
   
    while 1:
 timer.tick()
 display("this is", (100,100), (200,10,10),screen)
 for actor in [steve] + robots + shots  + explosions:
            actor.erase(screen, background)
            actor.update()  
 if robob.damage<6:
  robob.chase(steve,ladder_rects)
 else:
  robots=[]
 
 
 
 
 for s in shots:
  if s.rect.centerx<0 or s.rect.centerx>500:
   shots.remove(s)
  if s.rect.colliderect(robob.rect):
   hitsound.play()
   if robob.damage==4:
    begsound.play()
         
   if robob.damage==5:
    arrghsound.play()
     
   else:
           ouchsound.play()
   robob.hit()
   explosions.append(Explosion(s))
   shots.remove(s)
 for e in explosions:
            if e.life <= 0:
                explosions.remove(e)
 
 
 
 keystate = pygame.key.get_pressed()
 if not steve.reloading and keystate[K_SPACE] and len(shots) < 3:
            shots.append(Projectile(steve,direction))
     ##print len(shots)
        steve.reloading = keystate[K_SPACE]
 if keystate[K_ESCAPE] or pygame.event.peek(QUIT):
            break
 if keystate[K_RIGHT]:
  steve.move_x(2)
  direction=1
 if keystate[K_LEFT]:
  steve.move_x(-2)
  direction=-1
 
 if keystate[K_UP]:
  steve.move_y(-2)
  
 if keystate[K_DOWN]:
  steve.teleport()
  
  
  
  
 #gravity
 steve.move_y(1)
 robob.move_y(1)
  
  
 for actor in [steve]  + robots+ shots + explosions:
            actor.draw(screen)
 
 pygame.display.update(dirtyrects)
        #~ screen.blit(background, (0,0))
 
 
        #pygame.display.flip()
 
 ###print dirtyrects
 dirtyrects=[]
   
if __name__ == '__main__': main()